astro 5.5.5 → 5.6.0

package/dist/core/config/schemas/relative.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { z } from "zod";
+import { appendForwardSlash, prependForwardSlash, removeTrailingForwardSlash } from "../../path.js";
+import { ASTRO_CONFIG_DEFAULTS, AstroConfigSchema } from "./base.js";
+function resolveDirAsUrl(dir, root) {
+  let resolvedDir = path.resolve(root, dir);
+  if (!resolvedDir.endsWith(path.sep)) {
+    resolvedDir += path.sep;
+  }
+  return pathToFileURL(resolvedDir);
+}
+function createRelativeSchema(cmd, fileProtocolRoot) {
+  let originalBuildClient;
+  let originalBuildServer;
+  const AstroConfigRelativeSchema = AstroConfigSchema.extend({
+    root: z.string().default(ASTRO_CONFIG_DEFAULTS.root).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    srcDir: z.string().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    compressHTML: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.compressHTML),
+    publicDir: z.string().default(ASTRO_CONFIG_DEFAULTS.publicDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    outDir: z.string().default(ASTRO_CONFIG_DEFAULTS.outDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    cacheDir: z.string().default(ASTRO_CONFIG_DEFAULTS.cacheDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    build: z.object({
+      format: z.union([z.literal("file"), z.literal("directory"), z.literal("preserve")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
+      // NOTE: `client` and `server` are transformed relative to the default outDir first,
+      // later we'll fix this to be relative to the actual `outDir`
+      client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => {
+        originalBuildClient = val;
+        return resolveDirAsUrl(
+          val,
+          path.resolve(fileProtocolRoot, ASTRO_CONFIG_DEFAULTS.outDir)
+        );
+      }),
+      server: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.server).transform((val) => {
+        originalBuildServer = val;
+        return resolveDirAsUrl(
+          val,
+          path.resolve(fileProtocolRoot, ASTRO_CONFIG_DEFAULTS.outDir)
+        );
+      }),
+      assets: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.assets),
+      assetsPrefix: z.string().optional().or(z.object({ fallback: z.string() }).and(z.record(z.string())).optional()),
+      serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry),
+      redirects: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.redirects),
+      inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets),
+      concurrency: z.number().min(1).optional().default(ASTRO_CONFIG_DEFAULTS.build.concurrency)
+    }).optional().default({}),
+    server: z.preprocess(
+      // preprocess
+      (val) => {
+        if (typeof val === "function") {
+          return val({ command: cmd === "dev" ? "dev" : "preview" });
+        } else {
+          return val;
+        }
+      },
+      // validate
+      z.object({
+        open: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.open),
+        host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
+        port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
+        headers: z.custom().optional(),
+        streaming: z.boolean().optional().default(true),
+        allowedHosts: z.union([z.array(z.string()), z.literal(true)]).optional().default(ASTRO_CONFIG_DEFAULTS.server.allowedHosts)
+      }).optional().default({})
+    )
+  }).transform((config) => {
+    if (config.outDir.toString() !== resolveDirAsUrl(ASTRO_CONFIG_DEFAULTS.outDir, fileProtocolRoot).toString()) {
+      const outDirPath = fileURLToPath(config.outDir);
+      config.build.client = resolveDirAsUrl(originalBuildClient, outDirPath);
+      config.build.server = resolveDirAsUrl(originalBuildServer, outDirPath);
+    }
+    if (config.trailingSlash === "never") {
+      config.base = prependForwardSlash(removeTrailingForwardSlash(config.base));
+      config.image.endpoint.route = prependForwardSlash(
+        removeTrailingForwardSlash(config.image.endpoint.route)
+      );
+    } else if (config.trailingSlash === "always") {
+      config.base = prependForwardSlash(appendForwardSlash(config.base));
+      config.image.endpoint.route = prependForwardSlash(
+        appendForwardSlash(config.image.endpoint.route)
+      );
+    } else {
+      config.base = prependForwardSlash(config.base);
+      config.image.endpoint.route = prependForwardSlash(config.image.endpoint.route);
+    }
+    return config;
+  });
+  return AstroConfigRelativeSchema;
+}
+export {
+  createRelativeSchema
+};

package/dist/core/config/validate.d.ts

@@ -1,3 +1,9 @@
 import type { AstroConfig } from '../../types/public/config.js';
 /** Turn raw config values into normalized values */
 export declare function validateConfig(userConfig: any, root: string, cmd: string): Promise<AstroConfig>;
+/**
+ * Used twice:
+ * - To validate the user config
+ * - To validate the config after all integrations (that may have updated it)
+ */
+export declare function validateConfigRefined(updatedConfig: AstroConfig): Promise<AstroConfig>;

package/dist/core/config/validate.js

@@ -1,9 +1,15 @@
 import { errorMap } from "../errors/index.js";
-import { createRelativeSchema } from "./schema.js";
+import { AstroConfigRefinedSchema, createRelativeSchema } from "./schemas/index.js";
 async function validateConfig(userConfig, root, cmd) {
   const AstroConfigRelativeSchema = createRelativeSchema(cmd, root);
-  return await AstroConfigRelativeSchema.parseAsync(userConfig, { errorMap });
+  return await validateConfigRefined(
+    await AstroConfigRelativeSchema.parseAsync(userConfig, { errorMap })
+  );
+}
+async function validateConfigRefined(updatedConfig) {
+  return await AstroConfigRefinedSchema.parseAsync(updatedConfig, { errorMap });
 }
 export {
-  validateConfig
+  validateConfig,
+  validateConfigRefined
 };

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.5.5";
+const ASTRO_VERSION = "5.6.0";
 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/dev.js

@@ -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.5.5";
+  const currentVersion = "5.6.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

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

@@ -60,7 +60,7 @@ export declare const ClientAddressNotAvailable: {
 export declare const PrerenderClientAddressNotAvailable: {
     name: string;
     title: string;
-    message: string;
+    message: (name: string) => string;
 };
 /**
  * @docs

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

@@ -16,7 +16,7 @@ const ClientAddressNotAvailable = {
 const PrerenderClientAddressNotAvailable = {
   name: "PrerenderClientAddressNotAvailable",
   title: "`Astro.clientAddress` cannot be used inside prerendered routes.",
-  message: `\`Astro.clientAddress\` cannot be used inside prerendered routes`
+  message: (name) => `\`Astro.clientAddress\` cannot be used inside prerendered route ${name}`
 };
 const StaticClientAddressNotAvailable = {
   name: "StaticClientAddressNotAvailable",

package/dist/core/messages.js

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

package/dist/core/render-context.js

@@ -238,7 +238,7 @@ class RenderContext {
       reroutePayload,
       this.request
     );
-    if (this.pipeline.serverLike === true && this.routeData.prerender === false && routeData.prerender === true) {
+    if (this.pipeline.serverLike && !this.routeData.prerender && routeData.prerender) {
       throw new AstroError({
         ...ForbiddenRewrite,
         message: ForbiddenRewrite.message(this.pathname, pathname, routeData.component),
@@ -463,7 +463,10 @@ class RenderContext {
   getClientAddress() {
     const { pipeline, request, routeData, clientAddress } = this;
     if (routeData.prerender) {
-      throw new AstroError(AstroErrorData.PrerenderClientAddressNotAvailable);
+      throw new AstroError({
+        ...AstroErrorData.PrerenderClientAddressNotAvailable,
+        message: AstroErrorData.PrerenderClientAddressNotAvailable.message(routeData.component)
+      });
     }
     if (clientAddress) {
       return clientAddress;

package/dist/core/session.d.ts

@@ -45,6 +45,14 @@ export declare class AstroSession<TDriver extends SessionDriverName = any> {
     regenerate(): Promise<void>;
     [PERSIST_SYMBOL](): Promise<void>;
     get sessionID(): string | undefined;
+    /**
+     * Loads a session from storage with the given ID, and replaces the current session.
+     * Any changes made to the current session will be lost.
+     * This is not normally needed, as the session is automatically loaded using the cookie.
+     * However it can be used to restore a session where the ID has been recorded somewhere
+     * else (e.g. in a database).
+     */
+    load(sessionID: string): Promise<void>;
 }
 export declare function resolveSessionDriver(driver: string | undefined): Promise<string | null>;
 export declare function validateSessionConfig(settings: AstroSettings): void;

package/dist/core/session.js

@@ -221,6 +221,19 @@ class AstroSession {
   get sessionID() {
     return this.#sessionID;
   }
+  /**
+   * Loads a session from storage with the given ID, and replaces the current session.
+   * Any changes made to the current session will be lost.
+   * This is not normally needed, as the session is automatically loaded using the cookie.
+   * However it can be used to restore a session where the ID has been recorded somewhere
+   * else (e.g. in a database).
+   */
+  async load(sessionID) {
+    this.#sessionID = sessionID;
+    this.#data = void 0;
+    await this.#setCookie();
+    await this.#ensureData();
+  }
   /**
    * Sets the session cookie.
    */

package/dist/events/session.js

@@ -1,4 +1,4 @@
-import { AstroConfigSchema } from "../core/config/schema.js";
+import { AstroConfigSchema } from "../core/config/schemas/index.js";
 const EVENT_SESSION = "ASTRO_CLI_SESSION_STARTED";
 function measureIsDefined(val) {
   if (val === void 0) {

package/dist/i18n/index.d.ts

@@ -78,6 +78,7 @@ export declare function normalizeTheLocale(locale: string): string;
  * Returns an array of only locales, by picking the `code`
  * @param locales
  */
+export declare function getAllCodes(locales: Locales): string[];
 export declare function toCodes(locales: Locales): string[];
 /**
  * It returns the array of paths

package/dist/i18n/index.js

@@ -132,6 +132,17 @@ function getLocaleByPath(path, locales) {
 function normalizeTheLocale(locale) {
   return locale.replaceAll("_", "-").toLowerCase();
 }
+function getAllCodes(locales) {
+  const result = [];
+  for (const loopLocale of locales) {
+    if (typeof loopLocale === "string") {
+      result.push(loopLocale);
+    } else {
+      result.push(...loopLocale.codes);
+    }
+  }
+  return result;
+}
 function toCodes(locales) {
   return locales.map((loopLocale) => {
     if (typeof loopLocale === "string") {
@@ -258,6 +269,7 @@ function createMiddleware(i18nManifest, base, trailingSlash, format) {
 }
 export {
   createMiddleware,
+  getAllCodes,
   getLocaleAbsoluteUrl,
   getLocaleAbsoluteUrlList,
   getLocaleByPath,

package/dist/i18n/utils.js

@@ -1,4 +1,4 @@
-import { normalizeTheLocale, toCodes } from "./index.js";
+import { getAllCodes, normalizeTheLocale } from "./index.js";
 function parseLocale(header) {
   if (header === "*") {
     return [{ locale: header, qualityValue: void 0 }];
@@ -35,7 +35,7 @@ function parseLocale(header) {
   return result;
 }
 function sortAndFilterLocales(browserLocaleList, locales) {
-  const normalizedLocales = toCodes(locales).map(normalizeTheLocale);
+  const normalizedLocales = getAllCodes(locales).map(normalizeTheLocale);
   return browserLocaleList.filter((browserLocale) => {
     if (browserLocale.locale !== "*") {
       return normalizedLocales.includes(normalizeTheLocale(browserLocale.locale));
@@ -59,11 +59,13 @@ function computePreferredLocale(request, locales) {
         if (typeof currentLocale === "string") {
           if (normalizeTheLocale(currentLocale) === normalizeTheLocale(firstResult.locale)) {
             result = currentLocale;
+            break;
           }
         } else {
           for (const currentCode of currentLocale.codes) {
             if (normalizeTheLocale(currentCode) === normalizeTheLocale(firstResult.locale)) {
-              result = currentLocale.path;
+              result = currentCode;
+              break;
             }
           }
         }
@@ -78,13 +80,7 @@ function computePreferredLocaleList(request, locales) {
   if (acceptHeader) {
     const browserLocaleList = sortAndFilterLocales(parseLocale(acceptHeader), locales);
     if (browserLocaleList.length === 1 && browserLocaleList.at(0).locale === "*") {
-      return locales.map((locale) => {
-        if (typeof locale === "string") {
-          return locale;
-        } else {
-          return locale.codes.at(0);
-        }
-      });
+      return getAllCodes(locales);
     } else if (browserLocaleList.length > 0) {
       for (const browserLocale of browserLocaleList) {
         for (const loopLocale of locales) {
@@ -95,7 +91,7 @@ function computePreferredLocaleList(request, locales) {
           } else {
             for (const code of loopLocale.codes) {
               if (code === browserLocale.locale) {
-                result.push(loopLocale.path);
+                result.push(code);
               }
             }
           }

package/dist/integrations/hooks.d.ts

@@ -64,9 +64,9 @@ export declare function runHookServerDone({ config, logger, }: {
     config: AstroConfig;
     logger: Logger;
 }): Promise<void>;
-export declare function runHookBuildStart({ config, logging, }: {
+export declare function runHookBuildStart({ config, logger, }: {
     config: AstroConfig;
-    logging: Logger;
+    logger: Logger;
 }): Promise<void>;
 export declare function runHookBuildSetup({ config, vite, pages, target, logger, }: {
     config: AstroConfig;
@@ -91,9 +91,9 @@ type RunHookBuildDone = {
     settings: AstroSettings;
     pages: string[];
     routes: RouteData[];
-    logging: Logger;
+    logger: Logger;
 };
-export declare function runHookBuildDone({ settings, pages, routes, logging }: RunHookBuildDone): Promise<void>;
+export declare function runHookBuildDone({ settings, pages, routes, logger }: RunHookBuildDone): Promise<void>;
 export declare function runHookRouteSetup({ route, settings, logger, }: {
     route: RouteOptions;
     settings: AstroSettings;