astro 5.5.6 → 5.6.1

package/dist/core/config/{schema.js → schemas/base.js}

@@ -1,10 +1,7 @@
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { markdownConfigDefaults, syntaxHighlightDefaults } 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";
+import { EnvSchema } from "../../../env/schema.js";
 const ASTRO_CONFIG_DEFAULTS = {
   root: ".",
   srcDir: "./src",
@@ -88,19 +85,7 @@ const AstroConfigSchema = z.object({
     client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => new URL(val)),
     server: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.server).transform((val) => new URL(val)),
     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()).refine(
-      (value) => {
-        if (value && typeof value !== "string") {
-          if (!value.fallback) {
-            return false;
-          }
-        }
-        return true;
-      },
-      {
-        message: "The `fallback` is mandatory when defining the option as an object."
-      }
-    ),
+    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),
@@ -158,16 +143,9 @@ const AstroConfigSchema = z.object({
     remotePatterns: z.array(
       z.object({
         protocol: z.string().optional(),
-        hostname: z.string().refine(
-          (val) => !val.includes("*") || val.startsWith("*.") || val.startsWith("**."),
-          {
-            message: "wildcards can only be placed at the beginning of the hostname"
-          }
-        ).optional(),
+        hostname: z.string().optional(),
         port: z.string().optional(),
-        pathname: z.string().refine((val) => !val.includes("*") || val.endsWith("/*") || val.endsWith("/**"), {
-          message: "wildcards can only be placed at the end of a pathname"
-        }).optional()
+        pathname: z.string().optional()
       })
     ).default([]),
     experimentalLayout: z.enum(["responsive", "fixed", "full-width", "none"]).optional(),
@@ -249,94 +227,12 @@ const AstroConfigSchema = z.object({
       routing: z.literal("manual").or(
         z.object({
           prefixDefaultLocale: z.boolean().optional().default(false),
+          // TODO: Astro 6.0 change to false
           redirectToDefaultLocale: z.boolean().optional().default(true),
           fallbackType: z.enum(["redirect", "rewrite"]).optional().default("redirect")
-        }).refine(
-          ({ prefixDefaultLocale, redirectToDefaultLocale }) => {
-            return !(prefixDefaultLocale === false && redirectToDefaultLocale === false);
-          },
-          {
-            message: "The option `i18n.redirectToDefaultLocale` is only useful when the `i18n.prefixDefaultLocale` is set to `true`. Remove the option `i18n.redirectToDefaultLocale`, or change its value to `true`."
-          }
-        )
+        })
       ).optional().default({})
-    }).optional().superRefine((i18n, ctx) => {
-      if (i18n) {
-        const { defaultLocale, locales: _locales, fallback, domains } = i18n;
-        const locales = _locales.map((locale) => {
-          if (typeof locale === "string") {
-            return locale;
-          } else {
-            return locale.path;
-          }
-        });
-        if (!locales.includes(defaultLocale)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The default locale \`${defaultLocale}\` is not present in the \`i18n.locales\` array.`
-          });
-        }
-        if (fallback) {
-          for (const [fallbackFrom, fallbackTo] of Object.entries(fallback)) {
-            if (!locales.includes(fallbackFrom)) {
-              ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `The locale \`${fallbackFrom}\` key in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`
-              });
-            }
-            if (fallbackFrom === defaultLocale) {
-              ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `You can't use the default locale as a key. The default locale can only be used as value.`
-              });
-            }
-            if (!locales.includes(fallbackTo)) {
-              ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `The locale \`${fallbackTo}\` value in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`
-              });
-            }
-          }
-        }
-        if (domains) {
-          const entries = Object.entries(domains);
-          const hasDomains = domains ? Object.keys(domains).length > 0 : false;
-          if (entries.length > 0 && !hasDomains) {
-            ctx.addIssue({
-              code: z.ZodIssueCode.custom,
-              message: `When specifying some domains, the property \`i18n.routingStrategy\` must be set to \`"domains"\`.`
-            });
-          }
-          for (const [domainKey, domainValue] of entries) {
-            if (!locales.includes(domainKey)) {
-              ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `The locale \`${domainKey}\` key in the \`i18n.domains\` record doesn't exist in the \`i18n.locales\` array.`
-              });
-            }
-            if (!domainValue.startsWith("https") && !domainValue.startsWith("http")) {
-              ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "The domain value must be a valid URL, and it has to start with 'https' or 'http'.",
-                path: ["domains"]
-              });
-            } else {
-              try {
-                const domainUrl = new URL(domainValue);
-                if (domainUrl.pathname !== "/") {
-                  ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: `The URL \`${domainValue}\` must contain only the origin. A subsequent pathname isn't allowed here. Remove \`${domainUrl.pathname}\`.`,
-                    path: ["domains"]
-                  });
-                }
-              } catch {
-              }
-            }
-          }
-        }
-      }
-    })
+    }).optional()
   ),
   security: z.object({
     checkOrigin: z.boolean().default(ASTRO_CONFIG_DEFAULTS.security.checkOrigin)
@@ -368,25 +264,7 @@ const AstroConfigSchema = z.object({
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     responsiveImages: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.responsiveImages),
     session: z.boolean().optional(),
-    svg: z.union([
-      z.boolean(),
-      z.object({
-        mode: z.union([z.literal("inline"), z.literal("sprite")]).optional()
-      }).optional()
-    ]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.svg).transform((svgConfig) => {
-      if (typeof svgConfig === "boolean") {
-        return svgConfig ? {
-          mode: "inline"
-        } : void 0;
-      } else {
-        if (!svgConfig.mode) {
-          return {
-            mode: "inline"
-          };
-        }
-      }
-      return svgConfig;
-    }),
+    svg: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.svg),
     serializeConfig: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.serializeConfig),
     headingIdCompat: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.headingIdCompat),
     preserveScriptOrder: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.preserveScriptOrder)
@@ -399,130 +277,7 @@ See https://docs.astro.build/en/reference/experimental-flags/ for a list of all
     collections: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.legacy.collections)
   }).default({})
 });
-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()).refine(
-        (value) => {
-          if (value && typeof value !== "string") {
-            if (!value.fallback) {
-              return false;
-            }
-          }
-          return true;
-        },
-        {
-          message: "The `fallback` is mandatory when defining the option as an object."
-        }
-      ),
-      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;
-  }).refine((obj) => !obj.outDir.toString().startsWith(obj.publicDir.toString()), {
-    message: "The value of `outDir` must not point to a path within the folder set as `publicDir`, this will cause an infinite loop"
-  }).superRefine((configuration, ctx) => {
-    const { site, i18n, output, image, experimental } = configuration;
-    const hasDomains = i18n?.domains ? Object.keys(i18n.domains).length > 0 : false;
-    if (hasDomains) {
-      if (!site) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "The option `site` isn't set. When using the 'domains' strategy for `i18n`, `site` is required to create absolute URLs for locales that aren't mapped to a domain."
-        });
-      }
-      if (output !== "server") {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: 'Domain support is only available when `output` is `"server"`.'
-        });
-      }
-    }
-    if (!experimental.responsiveImages && (image.experimentalLayout || image.experimentalObjectFit || image.experimentalObjectPosition || image.experimentalBreakpoints)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "The `experimentalLayout`, `experimentalObjectFit`, `experimentalObjectPosition` and `experimentalBreakpoints` options are only available when `experimental.responsiveImages` is enabled."
-      });
-    }
-  });
-  return AstroConfigRelativeSchema;
-}
-function resolveDirAsUrl(dir, root) {
-  let resolvedDir = path.resolve(root, dir);
-  if (!resolvedDir.endsWith(path.sep)) {
-    resolvedDir += path.sep;
-  }
-  return pathToFileURL(resolvedDir);
-}
 export {
   ASTRO_CONFIG_DEFAULTS,
-  AstroConfigSchema,
-  createRelativeSchema
+  AstroConfigSchema
 };

package/dist/core/config/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export { AstroConfigSchema, ASTRO_CONFIG_DEFAULTS, type AstroConfigType } from './base.js';
+export { createRelativeSchema } from './relative.js';
+export { AstroConfigRefinedSchema } from './refined.js';

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

@@ -0,0 +1,9 @@
+import { AstroConfigSchema, ASTRO_CONFIG_DEFAULTS } from "./base.js";
+import { createRelativeSchema } from "./relative.js";
+import { AstroConfigRefinedSchema } from "./refined.js";
+export {
+  ASTRO_CONFIG_DEFAULTS,
+  AstroConfigRefinedSchema,
+  AstroConfigSchema,
+  createRelativeSchema
+};

package/dist/core/config/schemas/refined.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { AstroConfig } from '../../../types/public/config.js';
+export declare const AstroConfigRefinedSchema: z.ZodEffects<z.ZodType<AstroConfig, z.ZodTypeDef, AstroConfig>, AstroConfig, AstroConfig>;

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

@@ -0,0 +1,141 @@
+import { z } from "zod";
+const AstroConfigRefinedSchema = z.custom().superRefine((config, ctx) => {
+  if (config.build.assetsPrefix && typeof config.build.assetsPrefix !== "string" && !config.build.assetsPrefix.fallback) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "The `fallback` is mandatory when defining the option as an object.",
+      path: ["build", "assetsPrefix"]
+    });
+  }
+  for (let i = 0; i < config.image.remotePatterns.length; i++) {
+    const { hostname, pathname } = config.image.remotePatterns[i];
+    if (hostname && hostname.includes("*") && !(hostname.startsWith("*.") || hostname.startsWith("**."))) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "wildcards can only be placed at the beginning of the hostname",
+        path: ["image", "remotePatterns", i, "hostname"]
+      });
+    }
+    if (pathname && pathname.includes("*") && !(pathname.endsWith("/*") || pathname.endsWith("/**"))) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "wildcards can only be placed at the end of a pathname",
+        path: ["image", "remotePatterns", i, "pathname"]
+      });
+    }
+  }
+  if (config.outDir.toString().startsWith(config.publicDir.toString())) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "The value of `outDir` must not point to a path within the folder set as `publicDir`, this will cause an infinite loop",
+      path: ["outDir"]
+    });
+  }
+  if (config.i18n) {
+    const { defaultLocale, locales: _locales, fallback, domains } = config.i18n;
+    const locales = _locales.map((locale) => {
+      if (typeof locale === "string") {
+        return locale;
+      } else {
+        return locale.path;
+      }
+    });
+    if (!locales.includes(defaultLocale)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `The default locale \`${defaultLocale}\` is not present in the \`i18n.locales\` array.`,
+        path: ["i18n", "locales"]
+      });
+    }
+    if (fallback) {
+      for (const [fallbackFrom, fallbackTo] of Object.entries(fallback)) {
+        if (!locales.includes(fallbackFrom)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The locale \`${fallbackFrom}\` key in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`,
+            path: ["i18n", "fallbacks"]
+          });
+        }
+        if (fallbackFrom === defaultLocale) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `You can't use the default locale as a key. The default locale can only be used as value.`,
+            path: ["i18n", "fallbacks"]
+          });
+        }
+        if (!locales.includes(fallbackTo)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The locale \`${fallbackTo}\` value in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`,
+            path: ["i18n", "fallbacks"]
+          });
+        }
+      }
+    }
+    if (domains) {
+      const entries = Object.entries(domains);
+      const hasDomains = domains ? Object.keys(domains).length > 0 : false;
+      if (entries.length > 0 && !hasDomains) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `When specifying some domains, the property \`i18n.routing.strategy\` must be set to \`"domains"\`.`,
+          path: ["i18n", "routing", "strategy"]
+        });
+      }
+      if (hasDomains) {
+        if (!config.site) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "The option `site` isn't set. When using the 'domains' strategy for `i18n`, `site` is required to create absolute URLs for locales that aren't mapped to a domain.",
+            path: ["site"]
+          });
+        }
+        if (config.output !== "server") {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Domain support is only available when `output` is `"server"`.',
+            path: ["output"]
+          });
+        }
+      }
+      for (const [domainKey, domainValue] of entries) {
+        if (!locales.includes(domainKey)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The locale \`${domainKey}\` key in the \`i18n.domains\` record doesn't exist in the \`i18n.locales\` array.`,
+            path: ["i18n", "domains"]
+          });
+        }
+        if (!domainValue.startsWith("https") && !domainValue.startsWith("http")) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "The domain value must be a valid URL, and it has to start with 'https' or 'http'.",
+            path: ["i18n", "domains"]
+          });
+        } else {
+          try {
+            const domainUrl = new URL(domainValue);
+            if (domainUrl.pathname !== "/") {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `The URL \`${domainValue}\` must contain only the origin. A subsequent pathname isn't allowed here. Remove \`${domainUrl.pathname}\`.`,
+                path: ["i18n", "domains"]
+              });
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  if (!config.experimental.responsiveImages && (config.image.experimentalLayout || config.image.experimentalObjectFit || config.image.experimentalObjectPosition || config.image.experimentalBreakpoints)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "The `experimentalLayout`, `experimentalObjectFit`, `experimentalObjectPosition` and `experimentalBreakpoints` options are only available when `experimental.responsiveImages` is enabled.",
+      path: ["experimental", "responsiveImages"]
+    });
+  }
+});
+export {
+  AstroConfigRefinedSchema
+};