astro 5.5.6 → 5.6.1

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.6";
+const ASTRO_VERSION = "5.6.1";
 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.6";
+  const currentVersion = "5.6.1";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.5.6";
+  const version = "5.6.1";
   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.6"}`
+        `v${"5.6.1"}`
       )} ${headline}`
     );
   }

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

@@ -36,14 +36,14 @@ function vitePluginMiddleware({ settings }) {
         if (!userMiddlewareIsPresent && settings.config.i18n?.routing === "manual") {
           throw new AstroError(MissingMiddlewareForInternationalization);
         }
-        return "export const onRequest = (_, next) => next()";
+        return { code: "export const onRequest = (_, next) => next()" };
       } else if (id === MIDDLEWARE_MODULE_ID) {
         if (!userMiddlewareIsPresent && settings.config.i18n?.routing === "manual") {
           throw new AstroError(MissingMiddlewareForInternationalization);
         }
         const preMiddleware = createMiddlewareImports(settings.middlewares.pre, "pre");
         const postMiddleware = createMiddlewareImports(settings.middlewares.post, "post");
-        const source = `
+        const code = `
 				${userMiddlewareIsPresent ? `import { onRequest as userOnRequest } from '${resolvedMiddlewareId}';` : ""}
 import { sequence } from 'astro:middleware';
 ${preMiddleware.importsCode}${postMiddleware.importsCode}
@@ -54,7 +54,7 @@ export const onRequest = sequence(
 	${postMiddleware.sequenceCode}
 );
 `.trim();
-        return source;
+        return { code };
       }
     }
   };

package/dist/core/server-islands/vite-plugin-server-islands.js

@@ -22,7 +22,7 @@ function vitePluginServerIslands({ settings, logger }) {
     },
     load(id) {
       if (id === RESOLVED_VIRTUAL_ISLAND_MAP_ID) {
-        return `export const serverIslandMap = ${serverIslandPlaceholder};`;
+        return { code: `export const serverIslandMap = ${serverIslandPlaceholder};` };
       }
     },
     transform(_code, id) {

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/env/vite-plugin-env.js

@@ -54,12 +54,12 @@ function astroEnv({ settings, sync, envLoader }) {
     load(id, options) {
       if (id === resolveVirtualModuleId(VIRTUAL_MODULES_IDS.client)) {
         ensureTemplateAreLoaded();
-        return templates.client;
+        return { code: templates.client };
       }
       if (id === resolveVirtualModuleId(VIRTUAL_MODULES_IDS.server)) {
         if (options?.ssr) {
           ensureTemplateAreLoaded();
-          return templates.server;
+          return { code: templates.server };
         }
         throw new AstroError({
           ...AstroErrorData.ServerOnlyModule,
@@ -68,7 +68,7 @@ function astroEnv({ settings, sync, envLoader }) {
       }
       if (id === resolveVirtualModuleId(VIRTUAL_MODULES_IDS.internal)) {
         ensureTemplateAreLoaded();
-        return templates.internal;
+        return { code: templates.internal };
       }
     }
   };

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/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;