astro 5.1.3 → 5.1.5

package/dist/core/config/schema.js

@@ -1,7 +1,7 @@
-import { markdownConfigDefaults } from "@astrojs/markdown-remark";
-import { bundledThemes } from "shiki";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { markdownConfigDefaults } from "@astrojs/markdown-remark";
+import { bundledThemes } from "shiki";
 import { z } from "zod";
 import { EnvSchema } from "../../env/schema.js";
 import { appendForwardSlash, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.1.3";
+const ASTRO_VERSION = "5.1.5";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/container.js

@@ -66,7 +66,8 @@ async function createContainer({
       cleanup: true
     },
     force: inlineConfig?.force,
-    manifest
+    manifest,
+    command: "dev"
   });
   const viteServer = await vite.createServer(viteConfig);
   const container = {

package/dist/core/dev/dev.js

@@ -1,4 +1,4 @@
-import fs, { existsSync } from "node:fs";
+import fs from "node:fs";
 import { performance } from "node:perf_hooks";
 import { green } from "kleur/colors";
 import { gt, major, minor, patch } from "semver";
@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.1.3";
+  const currentVersion = "5.1.5";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -53,21 +53,19 @@ async function dev(inlineConfig) {
   let store;
   try {
     const dataStoreFile = getDataStoreFile(restart.container.settings, true);
-    if (existsSync(dataStoreFile)) {
-      store = await MutableDataStore.fromFile(dataStoreFile);
-    }
+    store = await MutableDataStore.fromFile(dataStoreFile);
   } catch (err) {
     logger.error("content", err.message);
   }
   if (!store) {
-    store = new MutableDataStore();
+    logger.error("content", "Failed to create data store");
   }
   await attachContentServerListeners(restart.container);
   const config = globalContentConfigObserver.get();
   if (config.status === "error") {
     logger.error("content", config.error.message);
   }
-  if (config.status === "loaded") {
+  if (config.status === "loaded" && store) {
     const contentLayer = globalContentLayer.init({
       settings: restart.container.settings,
       logger,

package/dist/core/errors/dev/utils.js

@@ -4,8 +4,8 @@ import { fileURLToPath } from "node:url";
 import { stripVTControlCharacters } from "node:util";
 import { escape } from "html-escaper";
 import { bold, underline } from "kleur/colors";
-import { normalizePath } from "vite";
 import { removeLeadingForwardSlashWindows } from "../../path.js";
+import { normalizePath } from "../../viteUtils.js";
 import { AggregateError } from "../errors.js";
 import { AstroErrorData } from "../index.js";
 import { codeFrame } from "../printer.js";

package/dist/core/messages.js

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

package/dist/core/middleware/sequence.js

@@ -39,7 +39,11 @@ function sequence(...handlers) {
             if (pipeline.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
               throw new AstroError({
                 ...ForbiddenRewrite,
-                message: ForbiddenRewrite.message(pathname, pathname, routeData.component),
+                message: ForbiddenRewrite.message(
+                  handleContext.url.pathname,
+                  pathname,
+                  routeData.component
+                ),
                 hint: ForbiddenRewrite.hint(routeData.component)
               });
             }

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

@@ -1,9 +1,9 @@
-import { normalizePath } from "vite";
 import { getOutputDirectory } from "../../prerender/utils.js";
 import { addRollupInput } from "../build/add-rollup-input.js";
 import { 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 NOOP_MIDDLEWARE = "\0noop-middleware";
 function vitePluginMiddleware({ settings }) {

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

@@ -19,7 +19,7 @@ async function getProps(opts) {
     ssr: serverLike,
     base
   });
-  const params = getParams(route, decodeURI(pathname));
+  const params = getParams(route, pathname);
   const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
   if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
     throw new AstroError({

package/dist/core/render-context.js

@@ -72,7 +72,7 @@ class RenderContext {
       pipeline,
       locals,
       sequence(...pipeline.internalMiddleware, middleware ?? pipelineMiddleware),
-      decodeURI(pathname),
+      pathname,
       request,
       routeData,
       status,
@@ -137,7 +137,14 @@ class RenderContext {
         if (payload instanceof Request) {
           this.request = payload;
         } else {
-          this.request = copyRequest(newUrl, this.request);
+          this.request = copyRequest(
+            newUrl,
+            this.request,
+            // need to send the flag of the previous routeData
+            routeData.prerender,
+            this.pipeline.logger,
+            this.routeData.route
+          );
         }
         this.isRewriting = true;
         this.url = new URL(this.request.url);
@@ -228,7 +235,14 @@ class RenderContext {
     if (reroutePayload instanceof Request) {
       this.request = reroutePayload;
     } else {
-      this.request = copyRequest(newUrl, this.request);
+      this.request = copyRequest(
+        newUrl,
+        this.request,
+        // need to send the flag of the previous routeData
+        routeData.prerender,
+        this.pipeline.logger,
+        this.routeData.route
+      );
     }
     this.url = new URL(this.request.url);
     this.cookies = new AstroCookies(this.request);

package/dist/core/request.d.ts

@@ -1,13 +1,12 @@
 import type { IncomingHttpHeaders } from 'node:http';
 import type { Logger } from './logger/core.js';
 type HeaderType = Headers | Record<string, any> | IncomingHttpHeaders;
-type RequestBody = ArrayBuffer | Blob | ReadableStream | URLSearchParams | FormData;
 export interface CreateRequestOptions {
     url: URL | string;
     clientAddress?: string | undefined;
     headers: HeaderType;
     method?: string;
-    body?: RequestBody | undefined;
+    body?: RequestInit['body'];
     logger: Logger;
     locals?: object | undefined;
     /**
@@ -19,6 +18,7 @@ export interface CreateRequestOptions {
      */
     isPrerendered?: boolean;
     routePattern: string;
+    init?: RequestInit;
 }
 /**
  * Used by astro internals to create a web standard request object.
@@ -27,5 +27,5 @@ export interface CreateRequestOptions {
  *
  * This is used by the static build to create fake requests for prerendering, and by the dev server to convert node requests into the standard request object.
  */
-export declare function createRequest({ url, headers, method, body, logger, isPrerendered, routePattern, }: CreateRequestOptions): Request;
+export declare function createRequest({ url, headers, method, body, logger, isPrerendered, routePattern, init, }: CreateRequestOptions): Request;
 export {};

package/dist/core/request.js

@@ -5,7 +5,8 @@ function createRequest({
   body = void 0,
   logger,
   isPrerendered = false,
-  routePattern
+  routePattern,
+  init
 }) {
   const headersObj = isPrerendered ? void 0 : headers instanceof Headers ? headers : new Headers(
     // Filter out HTTP/2 pseudo-headers. These are internally-generated headers added to all HTTP/2 requests with trusted metadata about the request.
@@ -22,7 +23,8 @@ function createRequest({
     method,
     headers: headersObj,
     // body is made available only if the request is for a page that will be on-demand rendered
-    body: isPrerendered ? null : body
+    body: isPrerendered ? null : body,
+    ...init
   });
   if (isPrerendered) {
     let _headers = request.headers;

package/dist/core/routing/manifest/create.d.ts

@@ -3,7 +3,6 @@ import type { Logger } from '../../logger/core.js';
 import nodeFs from 'node:fs';
 import type { RoutePart } from '../../../types/public/internal.js';
 export declare function getParts(part: string, file: string): RoutePart[];
-export declare function validateSegment(segment: string, file?: string): void;
 export interface CreateRouteManifestParams {
     /** Astro Settings object */
     settings: AstroSettings;

package/dist/core/routing/manifest/create.js

@@ -19,14 +19,8 @@ import { routeComparator } from "../priority.js";
 import { getRouteGenerator } from "./generator.js";
 import { getPattern } from "./pattern.js";
 import { getRoutePrerenderOption } from "./prerender.js";
+import { validateSegment } from "./segment.js";
 const require2 = createRequire(import.meta.url);
-function countOccurrences(needle, haystack) {
-  let count = 0;
-  for (const hay of haystack) {
-    if (hay === needle) count += 1;
-  }
-  return count;
-}
 const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
 const ROUTE_SPREAD = /^\.{3}.+$/;
 function getParts(part, file) {
@@ -46,18 +40,6 @@ function getParts(part, file) {
   });
   return result;
 }
-function validateSegment(segment, file = "") {
-  if (!file) file = segment;
-  if (segment.includes("][")) {
-    throw new Error(`Invalid route ${file} \u2014 parameters must be separated`);
-  }
-  if (countOccurrences("[", segment) !== countOccurrences("]", segment)) {
-    throw new Error(`Invalid route ${file} \u2014 brackets are unbalanced`);
-  }
-  if ((/.+\[\.\.\.[^\]]+\]/.test(segment) || /\[\.\.\.[^\]]+\].+/.test(segment)) && file.endsWith(".astro")) {
-    throw new Error(`Invalid route ${file} \u2014 rest parameter must be a standalone segment`);
-  }
-}
 function isSemanticallyEqualSegment(segmentA, segmentB) {
   if (segmentA.length !== segmentB.length) {
     return false;
@@ -529,6 +511,5 @@ function joinSegments(segments) {
 export {
   createRouteManifest,
   getParts,
-  resolveInjectedRoute,
-  validateSegment
+  resolveInjectedRoute
 };

package/dist/core/routing/manifest/parts.d.ts

@@ -0,0 +1,2 @@
+import type { RoutePart } from '../../../types/public/index.js';
+export declare function getParts(part: string, file: string): RoutePart[];

package/dist/core/routing/manifest/parts.js

@@ -0,0 +1,22 @@
+const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
+const ROUTE_SPREAD = /^\.{3}.+$/;
+function getParts(part, file) {
+  const result = [];
+  part.split(ROUTE_DYNAMIC_SPLIT).map((str, i) => {
+    if (!str) return;
+    const dynamic = i % 2 === 1;
+    const [, content] = dynamic ? /([^(]+)$/.exec(str) || [null, null] : [null, str];
+    if (!content || dynamic && !/^(?:\.\.\.)?[\w$]+$/.test(content)) {
+      throw new Error(`Invalid route ${file} \u2014 parameter name must match /^[a-zA-Z0-9_$]+$/`);
+    }
+    result.push({
+      content,
+      dynamic,
+      spread: dynamic && ROUTE_SPREAD.test(content)
+    });
+  });
+  return result;
+}
+export {
+  getParts
+};

package/dist/core/routing/manifest/segment.d.ts

@@ -0,0 +1 @@
+export declare function validateSegment(segment: string, file?: string): void;

package/dist/core/routing/manifest/segment.js

@@ -0,0 +1,22 @@
+function validateSegment(segment, file = "") {
+  if (!file) file = segment;
+  if (segment.includes("][")) {
+    throw new Error(`Invalid route ${file} \u2014 parameters must be separated`);
+  }
+  if (countOccurrences("[", segment) !== countOccurrences("]", segment)) {
+    throw new Error(`Invalid route ${file} \u2014 brackets are unbalanced`);
+  }
+  if ((/.+\[\.\.\.[^\]]+\]/.test(segment) || /\[\.\.\.[^\]]+\].+/.test(segment)) && file.endsWith(".astro")) {
+    throw new Error(`Invalid route ${file} \u2014 rest parameter must be a standalone segment`);
+  }
+}
+function countOccurrences(needle, haystack) {
+  let count = 0;
+  for (const hay of haystack) {
+    if (hay === needle) count += 1;
+  }
+  return count;
+}
+export {
+  validateSegment
+};

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

@@ -1,6 +1,7 @@
 import type { RewritePayload } from '../../types/public/common.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
+import type { Logger } from '../logger/core.js';
 export type FindRouteToRewrite = {
     payload: RewritePayload;
     routes: RouteData[];
@@ -25,7 +26,10 @@ export declare function findRouteToRewrite({ payload, routes, request, trailingS
  *
  * @param newUrl The new `URL`
  * @param oldRequest The old `Request`
+ * @param isPrerendered It needs to be the flag of the previous routeData, before the rewrite
+ * @param logger
+ * @param routePattern
  */
-export declare function copyRequest(newUrl: URL, oldRequest: Request): Request;
+export declare function copyRequest(newUrl: URL, oldRequest: Request, isPrerendered: boolean, logger: Logger, routePattern: string): Request;
 export declare function setOriginPathname(request: Request, pathname: string): void;
 export declare function getOriginPathname(request: Request): string;

package/dist/core/routing/rewrite.js

@@ -2,6 +2,7 @@ import { shouldAppendForwardSlash } from "../build/util.js";
 import { originPathnameSymbol } from "../constants.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { appendForwardSlash, removeTrailingForwardSlash } from "../path.js";
+import { createRequest } from "../request.js";
 import { DEFAULT_404_ROUTE } from "./astro-designed-error-pages.js";
 function findRouteToRewrite({
   payload,
@@ -46,26 +47,32 @@ function findRouteToRewrite({
     }
   }
 }
-function copyRequest(newUrl, oldRequest) {
+function copyRequest(newUrl, oldRequest, isPrerendered, logger, routePattern) {
   if (oldRequest.bodyUsed) {
     throw new AstroError(AstroErrorData.RewriteWithBodyUsed);
   }
-  return new Request(newUrl, {
+  return createRequest({
+    url: newUrl,
     method: oldRequest.method,
-    headers: oldRequest.headers,
     body: oldRequest.body,
-    referrer: oldRequest.referrer,
-    referrerPolicy: oldRequest.referrerPolicy,
-    mode: oldRequest.mode,
-    credentials: oldRequest.credentials,
-    cache: oldRequest.cache,
-    redirect: oldRequest.redirect,
-    integrity: oldRequest.integrity,
-    signal: oldRequest.signal,
-    keepalive: oldRequest.keepalive,
-    // https://fetch.spec.whatwg.org/#dom-request-duplex
-    // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
-    duplex: "half"
+    isPrerendered,
+    logger,
+    headers: isPrerendered ? {} : oldRequest.headers,
+    routePattern,
+    init: {
+      referrer: oldRequest.referrer,
+      referrerPolicy: oldRequest.referrerPolicy,
+      mode: oldRequest.mode,
+      credentials: oldRequest.credentials,
+      cache: oldRequest.cache,
+      redirect: oldRequest.redirect,
+      integrity: oldRequest.integrity,
+      signal: oldRequest.signal,
+      keepalive: oldRequest.keepalive,
+      // https://fetch.spec.whatwg.org/#dom-request-duplex
+      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
+      duplex: "half"
+    }
   });
 }
 function setOriginPathname(request, pathname) {

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

@@ -12,6 +12,7 @@ export type SyncOptions = {
         cleanup?: boolean;
     };
     manifest: ManifestData;
+    command: 'build' | 'dev' | 'sync';
 };
 export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _telemetry }?: {
     fs?: typeof fsMod;
@@ -20,10 +21,11 @@ export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _
 /**
  * Clears the content layer and content collection cache, forcing a full rebuild.
  */
-export declare function clearContentLayerCache({ settings, logger, fs, }: {
+export declare function clearContentLayerCache({ settings, logger, fs, isDev, }: {
     settings: AstroSettings;
     logger: Logger;
     fs?: typeof fsMod;
+    isDev: boolean;
 }): Promise<void>;
 /**
  * Generates TypeScript types for all Astro modules. This sets up a `src/env.d.ts` file for type inferencing,
@@ -31,4 +33,4 @@ export declare function clearContentLayerCache({ settings, logger, fs, }: {
  *
  * @experimental The JavaScript API is experimental
  */
-export declare function syncInternal({ mode, logger, fs, settings, skip, force, manifest, }: SyncOptions): Promise<void>;
+export declare function syncInternal({ mode, logger, fs, settings, skip, force, manifest, command, }: SyncOptions): Promise<void>;

package/dist/core/sync/index.js

@@ -1,10 +1,9 @@
-import fsMod, { existsSync } from "node:fs";
+import fsMod from "node:fs";
 import { dirname, relative } from "node:path";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { dim } from "kleur/colors";
 import { createServer } from "vite";
-import { normalizePath } from "vite";
 import { CONTENT_TYPES_FILE } from "../../content/consts.js";
 import { getDataStoreFile, globalContentLayer } from "../../content/content-layer.js";
 import { createContentTypesGenerator } from "../../content/index.js";
@@ -28,6 +27,7 @@ import {
 } from "../errors/index.js";
 import { createRouteManifest } from "../routing/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
+import { normalizePath } from "../viteUtils.js";
 async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
@@ -49,15 +49,17 @@ async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
     mode: "production",
     fs,
     force: inlineConfig.force,
-    manifest
+    manifest,
+    command: "sync"
   });
 }
 async function clearContentLayerCache({
   settings,
   logger,
-  fs = fsMod
+  fs = fsMod,
+  isDev
 }) {
-  const dataStore = getDataStoreFile(settings);
+  const dataStore = getDataStoreFile(settings, isDev);
   if (fs.existsSync(dataStore)) {
     logger.debug("content", "clearing data store");
     await fs.promises.rm(dataStore, { force: true });
@@ -71,10 +73,12 @@ async function syncInternal({
   settings,
   skip,
   force,
-  manifest
+  manifest,
+  command
 }) {
+  const isDev = command === "dev";
   if (force) {
-    await clearContentLayerCache({ settings, logger, fs });
+    await clearContentLayerCache({ settings, logger, fs, isDev });
   }
   const timerStart = performance.now();
   if (!skip?.content) {
@@ -82,15 +86,14 @@ async function syncInternal({
     settings.timer.start("Sync content layer");
     let store;
     try {
-      const dataStoreFile = getDataStoreFile(settings);
-      if (existsSync(dataStoreFile)) {
-        store = await MutableDataStore.fromFile(dataStoreFile);
-      }
+      const dataStoreFile = getDataStoreFile(settings, isDev);
+      store = await MutableDataStore.fromFile(dataStoreFile);
     } catch (err) {
       logger.error("content", err.message);
     }
     if (!store) {
-      store = new MutableDataStore();
+      logger.error("content", "Failed to load content store");
+      return;
     }
     const contentLayer = globalContentLayer.init({
       settings,

package/dist/core/util.d.ts

@@ -1,6 +1,6 @@
 import type { AstroSettings } from '../types/astro.js';
 import type { AstroConfig } from '../types/public/config.js';
-import type { RouteType } from '../types/public/internal.js';
+import type { RouteData } from '../types/public/internal.js';
 /** Returns true if argument is an object of any prototype/class (but not null). */
 export declare function isObject(value: unknown): value is Record<string, any>;
 /** Cross-realm compatible URL */
@@ -17,7 +17,7 @@ export declare function padMultilineString(source: string, n?: number): string;
  * Handles both "/foo" and "foo" `name` formats.
  * Handles `/404` and `/` correctly.
  */
-export declare function getOutputFilename(astroConfig: AstroConfig, name: string, type: RouteType): string;
+export declare function getOutputFilename(astroConfig: AstroConfig, name: string, routeData: RouteData): string;
 /** is a specifier an npm package? */
 export declare function parseNpmName(spec: string): {
     scope?: string;

package/dist/core/util.js

@@ -26,8 +26,8 @@ function padMultilineString(source, n = 2) {
 `);
 }
 const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
-function getOutputFilename(astroConfig, name, type) {
-  if (type === "endpoint") {
+function getOutputFilename(astroConfig, name, routeData) {
+  if (routeData.type === "endpoint") {
     return name;
   }
   if (name === "/" || name === "") {
@@ -36,6 +36,9 @@ function getOutputFilename(astroConfig, name, type) {
   if (astroConfig.build.format === "file" || STATUS_CODE_PAGES.has(name)) {
     return `${removeTrailingForwardSlash(name || "index")}.html`;
   }
+  if (astroConfig.build.format === "preserve" && !routeData.isIndex) {
+    return `${removeTrailingForwardSlash(name || "index")}.html`;
+  }
   return path.posix.join(name, "index.html");
 }
 function parseNpmName(spec) {