astro 5.16.5 → 6.0.0-alpha.1

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

@@ -1,7 +1,6 @@
-import type { MiddlewareHandler, Params } from '../../types/public/common.js';
+import type { Params } from '../../types/public/common.js';
 import type { APIContext } from '../../types/public/context.js';
 import { sequence } from './sequence.js';
-declare function defineMiddleware(fn: MiddlewareHandler): MiddlewareHandler;
 /**
  * Payload for creating a context to be passed to Astro middleware
  */
@@ -25,7 +24,7 @@ export type CreateContext = {
     /**
      * Initial value of the locals
      */
-    locals: App.Locals;
+    locals?: App.Locals;
 };
 /**
  * Creates a context to be passed to Astro middleware `onRequest` function.
@@ -43,4 +42,5 @@ declare function createContext({ request, params, userDefinedLocales, defaultLoc
  * @param value
  */
 declare function trySerializeLocals(value: unknown): string;
-export { createContext, defineMiddleware, sequence, trySerializeLocals };
+export { createContext, sequence, trySerializeLocals };
+export { defineMiddleware } from './defineMiddleware.js';

package/dist/core/middleware/index.js

@@ -4,21 +4,18 @@ import {
   computePreferredLocale,
   computePreferredLocaleList
 } from "../../i18n/utils.js";
-import { ASTRO_VERSION, clientLocalsSymbol } from "../constants.js";
+import { ASTRO_GENERATOR } from "../constants.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { getClientIpAddress } from "../routing/request.js";
 import { getOriginPathname } from "../routing/rewrite.js";
 import { sequence } from "./sequence.js";
-function defineMiddleware(fn) {
-  return fn;
-}
 function createContext({
   request,
   params = {},
   userDefinedLocales = [],
   defaultLocale = "",
-  locals
+  locals = {}
 }) {
   let preferredLocale = void 0;
   let preferredLocaleList = void 0;
@@ -34,7 +31,7 @@ function createContext({
     request,
     params,
     site: void 0,
-    generator: `Astro v${ASTRO_VERSION}`,
+    generator: ASTRO_GENERATOR,
     props: {},
     rewrite,
     routePattern: "",
@@ -71,14 +68,10 @@ function createContext({
       return clientIpAddress;
     },
     get locals() {
-      let _locals = locals ?? Reflect.get(request, clientLocalsSymbol);
-      if (locals === void 0) {
-        _locals = {};
-      }
-      if (typeof _locals !== "object") {
+      if (typeof locals !== "object") {
         throw new AstroError(AstroErrorData.LocalsNotAnObject);
       }
-      return _locals;
+      return locals;
     },
     set locals(_) {
       throw new AstroError(AstroErrorData.LocalsReassigned);
@@ -136,6 +129,7 @@ function trySerializeLocals(value) {
     throw new Error("The passed value can't be serialized.");
   }
 }
+import { defineMiddleware } from "./defineMiddleware.js";
 export {
   createContext,
   defineMiddleware,

package/dist/core/middleware/sequence.js

@@ -1,9 +1,9 @@
+import { pipelineSymbol } from "../constants.js";
 import { ForbiddenRewrite } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
 import { getParams } from "../render/index.js";
-import { apiContextRoutesSymbol } from "../render-context.js";
 import { setOriginPathname } from "../routing/rewrite.js";
-import { defineMiddleware } from "./index.js";
+import { defineMiddleware } from "./defineMiddleware.js";
 function sequence(...handlers) {
   const filtered = handlers.filter((h) => !!h);
   const length = filtered.length;
@@ -32,12 +32,12 @@ function sequence(...handlers) {
               );
             }
             const oldPathname = handleContext.url.pathname;
-            const pipeline = Reflect.get(handleContext, apiContextRoutesSymbol);
+            const pipeline = Reflect.get(handleContext, pipelineSymbol);
             const { routeData, pathname } = await pipeline.tryRewrite(
               payload,
               handleContext.request
             );
-            if (pipeline.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
+            if (pipeline.manifest.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
               throw new AstroError({
                 ...ForbiddenRewrite,
                 message: ForbiddenRewrite.message(

package/dist/core/middleware/vite-plugin.d.ts

@@ -2,7 +2,7 @@ import type { Plugin as VitePlugin } from 'vite';
 import type { AstroSettings } from '../../types/astro.js';
 import type { BuildInternals } from '../build/internal.js';
 import type { StaticBuildOptions } from '../build/types.js';
-export declare const MIDDLEWARE_MODULE_ID = "\0astro-internal:middleware";
+export declare const MIDDLEWARE_MODULE_ID = "virtual:astro:middleware";
 export declare function vitePluginMiddleware({ settings }: {
     settings: AstroSettings;
 }): VitePlugin;

package/dist/core/middleware/vite-plugin.js

@@ -1,10 +1,11 @@
 import { getServerOutputDirectory } from "../../prerender/utils.js";
 import { addRollupInput } from "../build/add-rollup-input.js";
-import { MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES, MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
 import { MissingMiddlewareForInternationalization } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
 import { normalizePath } from "../viteUtils.js";
-const MIDDLEWARE_MODULE_ID = "\0astro-internal:middleware";
+const MIDDLEWARE_MODULE_ID = "virtual:astro:middleware";
+const MIDDLEWARE_RESOLVED_MODULE_ID = "\0" + MIDDLEWARE_MODULE_ID;
 const NOOP_MIDDLEWARE = "\0noop-middleware";
 function vitePluginMiddleware({ settings }) {
   let resolvedMiddlewareId = void 0;
@@ -12,6 +13,9 @@ function vitePluginMiddleware({ settings }) {
   let userMiddlewareIsPresent = false;
   return {
     name: "@astro/plugin-middleware",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
     async resolveId(id) {
       if (id === MIDDLEWARE_MODULE_ID) {
         const middlewareId = await this.resolve(
@@ -20,9 +24,9 @@ function vitePluginMiddleware({ settings }) {
         userMiddlewareIsPresent = !!middlewareId;
         if (middlewareId) {
           resolvedMiddlewareId = middlewareId.id;
-          return MIDDLEWARE_MODULE_ID;
+          return MIDDLEWARE_RESOLVED_MODULE_ID;
         } else if (hasIntegrationMiddleware) {
-          return MIDDLEWARE_MODULE_ID;
+          return MIDDLEWARE_RESOLVED_MODULE_ID;
         } else {
           return NOOP_MIDDLEWARE;
         }
@@ -37,7 +41,7 @@ function vitePluginMiddleware({ settings }) {
           throw new AstroError(MissingMiddlewareForInternationalization);
         }
         return { code: "export const onRequest = (_, next) => next()" };
-      } else if (id === MIDDLEWARE_MODULE_ID) {
+      } else if (id === MIDDLEWARE_RESOLVED_MODULE_ID) {
         if (!userMiddlewareIsPresent && settings.config.i18n?.routing === "manual") {
           throw new AstroError(MissingMiddlewareForInternationalization);
         }
@@ -76,14 +80,21 @@ function createMiddlewareImports(entrypoints, prefix) {
   };
 }
 function vitePluginMiddlewareBuild(opts, internals) {
+  let canSplitMiddleware = true;
   return {
     name: "@astro/plugin-middleware-build",
+    configResolved(config) {
+      canSplitMiddleware = config.ssr.target !== "webworker";
+    },
     options(options) {
-      return addRollupInput(options, [MIDDLEWARE_MODULE_ID]);
+      if (canSplitMiddleware) {
+        return addRollupInput(options, [MIDDLEWARE_MODULE_ID]);
+      } else {
+      }
     },
     writeBundle(_, bundle) {
       for (const [chunkName, chunk] of Object.entries(bundle)) {
-        if (chunk.type !== "asset" && chunk.facadeModuleId === MIDDLEWARE_MODULE_ID) {
+        if (chunk.type !== "asset" && chunk.facadeModuleId === MIDDLEWARE_RESOLVED_MODULE_ID) {
           const outputDirectory = getServerOutputDirectory(opts.settings);
           internals.middlewareEntryPoint = new URL(chunkName, outputDirectory);
         }

package/dist/core/module-loader/index.d.ts

@@ -1,3 +1,3 @@
-export type { LoaderEvents, ModuleInfo, ModuleLoader, ModuleNode } from './loader.js';
-export { createLoader } from './loader.js';
+export type { LoaderEvents, ModuleInfo, ModuleLoader } from './runner.js';
+export { createLoader } from './runner.js';
 export { createViteLoader } from './vite.js';

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

@@ -1,4 +1,4 @@
-import { createLoader } from "./loader.js";
+import { createLoader } from "./runner.js";
 import { createViteLoader } from "./vite.js";
 export {
   createLoader,

package/dist/core/module-loader/{loader.d.ts → runner.d.ts}

@@ -1,4 +1,5 @@
 import type * as fs from 'node:fs';
+import type { EnvironmentModuleNode, RunnableDevEnvironment } from 'vite';
 import type { TypedEventEmitter } from '../../types/typed-emitter.js';
 export type LoaderEvents = {
     'file-add': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
@@ -16,29 +17,17 @@ export type ModuleLoaderEventEmitter = TypedEventEmitter<LoaderEvents>;
 export interface ModuleLoader {
     import: (src: string) => Promise<Record<string, any>>;
     resolveId: (specifier: string, parentId: string | undefined) => Promise<string | undefined>;
-    getModuleById: (id: string) => ModuleNode | undefined;
-    getModulesByFile: (file: string) => Set<ModuleNode> | undefined;
+    getModuleById: (id: string) => EnvironmentModuleNode | undefined;
+    getModulesByFile: (file: string) => Set<EnvironmentModuleNode> | undefined;
     getModuleInfo: (id: string) => ModuleInfo | null;
-    eachModule(callbackfn: (value: ModuleNode, key: string) => void): void;
-    invalidateModule(mod: ModuleNode): void;
+    eachModule(callbackfn: (value: EnvironmentModuleNode, key: string, map: Map<string, EnvironmentModuleNode>) => void): void;
+    invalidateModule(mod: EnvironmentModuleNode): void;
     fixStacktrace: (error: Error) => void;
     clientReload: () => void;
     webSocketSend: (msg: any) => void;
     isHttps: () => boolean;
     events: TypedEventEmitter<LoaderEvents>;
-}
-export interface ModuleNode {
-    id: string | null;
-    url: string;
-    file: string | null;
-    ssrModule: Record<string, any> | null;
-    ssrTransformResult: {
-        deps?: string[];
-        dynamicDeps?: string[];
-    } | null;
-    ssrError: Error | null;
-    importedModules: Set<ModuleNode>;
-    importers: Set<ModuleNode>;
+    getSSREnvironment: () => RunnableDevEnvironment;
 }
 export interface ModuleInfo {
     id: string;

package/dist/core/module-loader/{loader.js → runner.js}

@@ -30,6 +30,9 @@ function createLoader(overrides) {
     isHttps() {
       return true;
     },
+    getSSREnvironment() {
+      throw new Error("Not implemented");
+    },
     events: new EventEmitter(),
     ...overrides
   };

package/dist/core/module-loader/vite.d.ts

@@ -1,3 +1,4 @@
 import type * as vite from 'vite';
-import type { ModuleLoader } from './loader.js';
-export declare function createViteLoader(viteServer: vite.ViteDevServer): ModuleLoader;
+import type { RunnableDevEnvironment } from 'vite';
+import type { ModuleLoader } from './runner.js';
+export declare function createViteLoader(viteServer: vite.ViteDevServer, ssrEnvironment: RunnableDevEnvironment): ModuleLoader;

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

@@ -3,7 +3,8 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
 import { getViteErrorPayload } from "../errors/dev/vite.js";
-function createViteLoader(viteServer) {
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
+function createViteLoader(viteServer, ssrEnvironment) {
   const events = new EventEmitter();
   let isTsconfigUpdated = false;
   function isTsconfigUpdate(filePath) {
@@ -26,8 +27,8 @@ function createViteLoader(viteServer) {
       events.emit("file-change", args);
     }
   });
-  const _wsSend = viteServer.hot.send;
-  viteServer.hot.send = function(...args) {
+  const _wsSend = viteServer.environments.client.hot.send;
+  viteServer.environments.client.hot.send = function(...args) {
     if (isTsconfigUpdated) {
       isTsconfigUpdated = false;
       return;
@@ -55,41 +56,44 @@ function createViteLoader(viteServer) {
   };
   return {
     import(src) {
-      return viteServer.ssrLoadModule(src);
+      return ssrEnvironment.runner.import(src);
     },
     async resolveId(spec, parent) {
-      const ret = await viteServer.pluginContainer.resolveId(spec, parent);
+      const ret = await ssrEnvironment.pluginContainer.resolveId(spec, parent);
       return ret?.id;
     },
     getModuleById(id) {
-      return viteServer.moduleGraph.getModuleById(id);
+      return ssrEnvironment.moduleGraph.getModuleById(id);
     },
     getModulesByFile(file) {
-      return viteServer.moduleGraph.getModulesByFile(file);
+      return ssrEnvironment.moduleGraph.getModulesByFile(file);
     },
     getModuleInfo(id) {
-      return viteServer.pluginContainer.getModuleInfo(id);
+      return ssrEnvironment.pluginContainer.getModuleInfo(id);
     },
     eachModule(cb) {
-      return viteServer.moduleGraph.idToModuleMap.forEach(cb);
+      return ssrEnvironment.moduleGraph.idToModuleMap.forEach(cb);
     },
     invalidateModule(mod) {
-      viteServer.moduleGraph.invalidateModule(mod);
+      ssrEnvironment.moduleGraph.invalidateModule(mod);
     },
     fixStacktrace(err) {
       return viteServer.ssrFixStacktrace(err);
     },
     clientReload() {
-      viteServer.hot.send({
+      viteServer.environments.client.hot.send({
         type: "full-reload",
         path: "*"
       });
     },
     webSocketSend(msg) {
-      return viteServer.hot.send(msg);
+      return viteServer.environments.client.hot.send(msg);
+    },
+    getSSREnvironment() {
+      return viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
     },
     isHttps() {
-      return !!viteServer.config.server.https;
+      return !!ssrEnvironment.config.server.https;
     },
     events
   };

package/dist/core/preview/index.js

@@ -4,22 +4,28 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { AstroIntegrationLogger } from "../../core/logger/core.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
-import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
+import {
+  normalizeCodegenDir,
+  runHookConfigDone,
+  runHookConfigSetup
+} from "../../integrations/hooks.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
 import { createSettings } from "../config/settings.js";
-import { apply as applyPolyfills } from "../polyfill.js";
 import { createRoutesList } from "../routing/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
 import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
 async function preview(inlineConfig) {
-  applyPolyfills();
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "preview");
   telemetry.record(eventCliSession("preview", userConfig));
-  const _settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
+  const _settings = await createSettings(
+    astroConfig,
+    inlineConfig.logLevel,
+    fileURLToPath(astroConfig.root)
+  );
   const settings = await runHookConfigSetup({
     settings: _settings,
     command: "preview",
@@ -61,7 +67,16 @@ async function preview(inlineConfig) {
     port: settings.config.server.port,
     base: settings.config.base,
     logger: new AstroIntegrationLogger(logger.options, settings.adapter.name),
-    headers: settings.config.server.headers
+    headers: settings.config.server.headers,
+    createCodegenDir: () => {
+      const codegenDir = new URL(
+        normalizeCodegenDir(settings.adapter ? settings.adapter.name : "_temp"),
+        settings.dotAstroDir
+      );
+      fs.mkdirSync(codegenDir, { recursive: true });
+      return codegenDir;
+    },
+    root: settings.config.root
   });
   return server;
 }

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

@@ -15,6 +15,7 @@ async function createStaticPreviewServer(settings, logger) {
       build: {
         outDir: fileURLToPath(settings.config.outDir)
       },
+      root: fileURLToPath(settings.config.root),
       preview: {
         host: settings.config.server.host,
         port: settings.config.server.port,

package/dist/core/redirects/component.js

@@ -7,8 +7,7 @@ const RedirectComponentInstance = {
 };
 const RedirectSinglePageBuiltModule = {
   page: () => Promise.resolve(RedirectComponentInstance),
-  onRequest: (_, next) => next(),
-  renderers: []
+  onRequest: (_, next) => next()
 };
 export {
   RedirectComponentInstance,

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

@@ -1,3 +1,2 @@
 export { RedirectComponentInstance, RedirectSinglePageBuiltModule } from './component.js';
-export { routeIsRedirect } from './helpers.js';
 export { getRedirectLocationOrThrow } from './validate.js';

package/dist/core/redirects/index.js

@@ -1,9 +1,7 @@
 import { RedirectComponentInstance, RedirectSinglePageBuiltModule } from "./component.js";
-import { routeIsRedirect } from "./helpers.js";
 import { getRedirectLocationOrThrow } from "./validate.js";
 export {
   RedirectComponentInstance,
   RedirectSinglePageBuiltModule,
-  getRedirectLocationOrThrow,
-  routeIsRedirect
+  getRedirectLocationOrThrow
 };

package/dist/core/redirects/render.js

@@ -1,3 +1,4 @@
+import { getRouteGenerator } from "../routing/manifest/generator.js";
 function redirectIsExternal(redirect) {
   if (typeof redirect === "string") {
     return redirect.startsWith("http://") || redirect.startsWith("https://");
@@ -25,10 +26,12 @@ async function renderRedirect(renderContext) {
 function redirectRouteGenerate(renderContext) {
   const {
     params,
-    routeData: { redirect, redirectRoute }
+    routeData: { redirect, redirectRoute },
+    pipeline
   } = renderContext;
   if (typeof redirectRoute !== "undefined") {
-    return redirectRoute?.generate(params) || redirectRoute?.pathname || "/";
+    const generate = getRouteGenerator(redirectRoute.segments, pipeline.manifest.trailingSlash);
+    return generate(params) || redirectRoute?.pathname || "/";
   } else if (typeof redirect === "string") {
     if (redirectIsExternal(redirect)) {
       return redirect;

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

@@ -1,4 +1,4 @@
 import type { PaginateFunction } from '../../types/public/common.js';
 import type { AstroConfig } from '../../types/public/index.js';
 import type { RouteData } from '../../types/public/internal.js';
-export declare function generatePaginateFunction(routeMatch: RouteData, base: AstroConfig['base']): (...args: Parameters<PaginateFunction>) => ReturnType<PaginateFunction>;
+export declare function generatePaginateFunction(routeMatch: RouteData, base: AstroConfig['base'], trailingSlash: AstroConfig['trailingSlash']): (...args: Parameters<PaginateFunction>) => ReturnType<PaginateFunction>;

package/dist/core/render/paginate.js

@@ -1,7 +1,9 @@
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { joinPaths } from "../path.js";
-function generatePaginateFunction(routeMatch, base) {
+import { getRouteGenerator } from "../routing/manifest/generator.js";
+function generatePaginateFunction(routeMatch, base, trailingSlash) {
   return function paginateUtility(data, args = {}) {
+    const generate = getRouteGenerator(routeMatch.segments, trailingSlash);
     let { pageSize: _pageSize, params: _params, props: _props } = args;
     const pageSize = _pageSize || 10;
     const paramName = "page";
@@ -27,23 +29,23 @@ function generatePaginateFunction(routeMatch, base) {
         ...additionalParams,
         [paramName]: includesFirstPageNumber || pageNum > 1 ? String(pageNum) : void 0
       };
-      const current = addRouteBase(routeMatch.generate({ ...params }), base);
-      const next = pageNum === lastPage ? void 0 : addRouteBase(routeMatch.generate({ ...params, page: String(pageNum + 1) }), base);
+      const current = addRouteBase(generate({ ...params }), base);
+      const next = pageNum === lastPage ? void 0 : addRouteBase(generate({ ...params, page: String(pageNum + 1) }), base);
       const prev = pageNum === 1 ? void 0 : addRouteBase(
-        routeMatch.generate({
+        generate({
           ...params,
           page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
         }),
         base
       );
       const first = pageNum === 1 ? void 0 : addRouteBase(
-        routeMatch.generate({
+        generate({
           ...params,
           page: includesFirstPageNumber ? "1" : void 0
         }),
         base
       );
-      const last = pageNum === lastPage ? void 0 : addRouteBase(routeMatch.generate({ ...params, page: String(lastPage) }), base);
+      const last = pageNum === lastPage ? void 0 : addRouteBase(generate({ ...params, page: String(lastPage) }), base);
       return {
         params,
         props: {

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

@@ -1,5 +1,6 @@
 import type { ComponentInstance } from '../../types/astro.js';
 import type { Params, Props } from '../../types/public/common.js';
+import type { AstroConfig } from '../../types/public/index.js';
 import type { RouteData } from '../../types/public/internal.js';
 import type { Logger } from '../logger/core.js';
 import type { RouteCache } from './route-cache.js';
@@ -11,6 +12,7 @@ interface GetParamsAndPropsOptions {
     logger: Logger;
     serverLike: boolean;
     base: string;
+    trailingSlash: AstroConfig['trailingSlash'];
 }
 export declare function getProps(opts: GetParamsAndPropsOptions): Promise<Props>;
 /**

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

@@ -1,10 +1,18 @@
 import { DEFAULT_404_COMPONENT } from "../constants.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-import { routeIsFallback } from "../redirects/helpers.js";
-import { routeIsRedirect } from "../redirects/index.js";
+import { routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
 import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
 async function getProps(opts) {
-  const { logger, mod, routeData: route, routeCache, pathname, serverLike, base } = opts;
+  const {
+    logger,
+    mod,
+    routeData: route,
+    routeCache,
+    pathname,
+    serverLike,
+    base,
+    trailingSlash
+  } = opts;
   if (!route || route.pathname) {
     return {};
   }
@@ -15,12 +23,12 @@ async function getProps(opts) {
     mod,
     route,
     routeCache,
-    logger,
     ssr: serverLike,
-    base
+    base,
+    trailingSlash
   });
   const params = getParams(route, pathname);
-  const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
+  const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger, trailingSlash);
   if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
     throw new AstroError({
       ...AstroErrorData.NoMatchingStaticPathFound,
@@ -36,7 +44,11 @@ async function getProps(opts) {
 }
 function getParams(route, pathname) {
   if (!route.params.length) return {};
-  const paramsMatch = route.pattern.exec(pathname) || route.fallbackRoutes.map((fallbackRoute) => fallbackRoute.pattern.exec(pathname)).find((x) => x);
+  let path = pathname;
+  if (pathname.endsWith(".html")) {
+    path = path.slice(0, -5);
+  }
+  const paramsMatch = route.pattern.exec(path) || route.fallbackRoutes.map((fallbackRoute) => fallbackRoute.pattern.exec(path)).find((x) => x);
   if (!paramsMatch) return {};
   const params = {};
   route.params.forEach((key, i) => {

package/dist/core/render/route-cache.d.ts

@@ -7,11 +7,11 @@ interface CallGetStaticPathsOptions {
     mod: ComponentInstance | undefined;
     route: RouteData;
     routeCache: RouteCache;
-    logger: Logger;
     ssr: boolean;
     base: AstroConfig['base'];
+    trailingSlash: AstroConfig['trailingSlash'];
 }
-export declare function callGetStaticPaths({ mod, route, routeCache, logger, ssr, base, }: CallGetStaticPathsOptions): Promise<GetStaticPathsResultKeyed>;
+export declare function callGetStaticPaths({ mod, route, routeCache, ssr, base, trailingSlash, }: CallGetStaticPathsOptions): Promise<GetStaticPathsResultKeyed>;
 interface RouteCacheEntry {
     staticPaths: GetStaticPathsResultKeyed;
 }
@@ -31,5 +31,5 @@ export declare class RouteCache {
     get(route: RouteData): RouteCacheEntry | undefined;
     key(route: RouteData): string;
 }
-export declare function findPathItemByKey(staticPaths: GetStaticPathsResultKeyed, params: Params, route: RouteData, logger: Logger): GetStaticPathsItem | undefined;
+export declare function findPathItemByKey(staticPaths: GetStaticPathsResultKeyed, params: Params, route: RouteData, logger: Logger, trailingSlash: AstroConfig['trailingSlash']): GetStaticPathsItem | undefined;
 export {};

package/dist/core/render/route-cache.js

@@ -5,9 +5,9 @@ async function callGetStaticPaths({
   mod,
   route,
   routeCache,
-  logger,
   ssr,
-  base
+  base,
+  trailingSlash
 }) {
   const cached = routeCache.get(route);
   if (!mod) {
@@ -29,14 +29,14 @@ async function callGetStaticPaths({
   staticPaths = await mod.getStaticPaths({
     // Q: Why the cast?
     // A: So users downstream can have nicer typings, we have to make some sacrifice in our internal typings, which necessitate a cast here
-    paginate: generatePaginateFunction(route, base),
+    paginate: generatePaginateFunction(route, base, trailingSlash),
     routePattern: route.route
   });
-  validateGetStaticPathsResult(staticPaths, logger, route);
+  validateGetStaticPathsResult(staticPaths, route);
   const keyedStaticPaths = staticPaths;
   keyedStaticPaths.keyed = /* @__PURE__ */ new Map();
   for (const sp of keyedStaticPaths) {
-    const paramsKey = stringifyParams(sp.params, route);
+    const paramsKey = stringifyParams(sp.params, route, trailingSlash);
     keyedStaticPaths.keyed.set(paramsKey, sp);
   }
   routeCache.set(route, { ...cached, staticPaths: keyedStaticPaths });
@@ -68,8 +68,8 @@ class RouteCache {
     return `${route.route}_${route.component}`;
   }
 }
-function findPathItemByKey(staticPaths, params, route, logger) {
-  const paramsKey = stringifyParams(params, route);
+function findPathItemByKey(staticPaths, params, route, logger, trailingSlash) {
+  const paramsKey = stringifyParams(params, route, trailingSlash);
   const matchedStaticPath = staticPaths.keyed.get(paramsKey);
   if (matchedStaticPath) {
     return matchedStaticPath;