astro 2.9.5 → 2.9.7

package/dist/core/app/index.js

@@ -20,6 +20,7 @@ import { matchRoute } from "../routing/match.js";
 import { deserializeManifest } from "./common.js";
 const clientLocalsSymbol = Symbol.for("astro.locals");
 const responseSentSymbol = Symbol.for("astro.responseSent");
+const STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
 class App {
   /**
    * The current environment of the application
@@ -91,46 +92,28 @@ class App {
     }
     return pathname;
   }
-  match(request, { matchNotFound = false } = {}) {
+  // Disable no-unused-vars to avoid breaking signature change
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(request, _opts = {}) {
     const url = new URL(request.url);
-    if (this.#manifest.assets.has(url.pathname)) {
+    if (this.#manifest.assets.has(url.pathname))
       return void 0;
-    }
     let pathname = prependForwardSlash(this.removeBase(url.pathname));
     let routeData = matchRoute(pathname, this.#manifestData);
-    if (routeData) {
-      if (routeData.prerender)
-        return void 0;
-      return routeData;
-    } else if (matchNotFound) {
-      const notFoundRouteData = matchRoute("/404", this.#manifestData);
-      if (notFoundRouteData == null ? void 0 : notFoundRouteData.prerender)
-        return void 0;
-      return notFoundRouteData;
-    } else {
+    if (!routeData || routeData.prerender)
       return void 0;
-    }
+    return routeData;
   }
   async render(request, routeData, locals) {
-    let defaultStatus = 200;
     if (!routeData) {
       routeData = this.match(request);
-      if (!routeData) {
-        defaultStatus = 404;
-        routeData = this.match(request, { matchNotFound: true });
-      }
-      if (!routeData) {
-        return new Response(null, {
-          status: 404,
-          statusText: "Not found"
-        });
-      }
     }
-    Reflect.set(request, clientLocalsSymbol, locals ?? {});
-    if (routeData.route === "/404") {
-      defaultStatus = 404;
+    if (!routeData) {
+      return this.#renderError(request, { routeData, status: 404 });
     }
-    let mod = await this.#getModuleForRoute(routeData);
+    Reflect.set(request, clientLocalsSymbol, locals ?? {});
+    const defaultStatus = this.#getDefaultStatusCode(routeData.route);
+    const mod = await this.#getModuleForRoute(routeData);
     const pageModule = await mod.page();
     const url = new URL(request.url);
     const renderContext = await this.#createRenderContext(
@@ -151,46 +134,26 @@ class App {
       );
     } catch (err) {
       error(this.#logging, "ssr", err.stack || err.message || String(err));
-      response = new Response(null, {
-        status: 500,
-        statusText: "Internal server error"
-      });
+      return this.#renderError(request, { routeData, status: 500 });
     }
     if (isResponse(response, routeData.type)) {
-      if (response.status === 500 || response.status === 404) {
-        const errorRouteData = matchRoute("/" + response.status, this.#manifestData);
-        if (errorRouteData && errorRouteData.route !== routeData.route) {
-          mod = await this.#getModuleForRoute(errorRouteData);
-          try {
-            const newRenderContext = await this.#createRenderContext(
-              url,
-              request,
-              routeData,
-              mod,
-              response.status
-            );
-            const page = await mod.page();
-            const errorResponse = await tryRenderRoute(
-              routeData.type,
-              newRenderContext,
-              this.#env,
-              page
-            );
-            return errorResponse;
-          } catch {
-          }
-        }
+      if (STATUS_CODES.has(response.status)) {
+        return this.#renderError(request, {
+          routeData,
+          response,
+          status: response.status
+        });
       }
       Reflect.set(response, responseSentSymbol, true);
       return response;
     } else {
       if (response.type === "response") {
         if (response.response.headers.get("X-Astro-Response") === "Not-Found") {
-          const fourOhFourRequest = new Request(new URL("/404", request.url));
-          const fourOhFourRouteData = this.match(fourOhFourRequest);
-          if (fourOhFourRouteData) {
-            return this.render(fourOhFourRequest, fourOhFourRouteData);
-          }
+          return this.#renderError(request, {
+            routeData,
+            response: response.response,
+            status: 404
+          });
         }
         return response.response;
       } else {
@@ -265,6 +228,63 @@ class App {
       });
     }
   }
+  /**
+   * If is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
+   * This also handles pre-rendered /404 or /500 routes
+   */
+  async #renderError(request, { routeData, status, response: originalResponse }) {
+    const errorRouteData = matchRoute("/" + status, this.#manifestData);
+    const url = new URL(request.url);
+    if (errorRouteData) {
+      if (errorRouteData.prerender && !errorRouteData.route.endsWith(`/${status}`)) {
+        const statusURL = new URL(`${this.#baseWithoutTrailingSlash}/${status}`, url);
+        const response2 = await fetch(statusURL.toString());
+        return this.#mergeResponses(response2, originalResponse);
+      }
+      const finalRouteData = routeData ?? errorRouteData;
+      const mod = await this.#getModuleForRoute(errorRouteData);
+      try {
+        const newRenderContext = await this.#createRenderContext(
+          url,
+          request,
+          finalRouteData,
+          mod,
+          status
+        );
+        const page = await mod.page();
+        const response2 = await tryRenderRoute(
+          "page",
+          // this is hardcoded to ensure proper behavior for missing endpoints
+          newRenderContext,
+          this.#env,
+          page
+        );
+        return this.#mergeResponses(response2, originalResponse);
+      } catch {
+      }
+    }
+    const response = this.#mergeResponses(new Response(null, { status }), originalResponse);
+    Reflect.set(response, responseSentSymbol, true);
+    return response;
+  }
+  #mergeResponses(newResponse, oldResponse) {
+    if (!oldResponse)
+      return newResponse;
+    const { status, statusText, headers } = oldResponse;
+    return new Response(newResponse.body, {
+      status: status === 200 ? newResponse.status : status,
+      statusText,
+      headers: new Headers(Array.from(headers))
+    });
+  }
+  #getDefaultStatusCode(route) {
+    route = removeTrailingForwardSlash(route);
+    if (route.endsWith("/404"))
+      return 404;
+    if (route.endsWith("/500"))
+      return 500;
+    return 200;
+  }
   async #getModuleForRoute(route) {
     if (route.type === "redirect") {
       return RedirectSinglePageBuiltModule;

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

@@ -1,15 +1,10 @@
-import type yargs from 'yargs-parser';
-import type { AstroSettings, RuntimeMode } from '../../@types/astro';
-import { type LogOptions } from '../logger/core.js';
+import type { AstroInlineConfig } from '../../@types/astro';
 export interface BuildOptions {
-    mode?: RuntimeMode;
-    logging: LogOptions;
     /**
      * Teardown the compiler WASM instance after build. This can improve performance when
      * building once, but may cause a performance hit if building multiple times in a row.
      */
     teardownCompiler?: boolean;
-    flags?: yargs.Arguments;
 }
 /** `astro build` */
-export default function build(settings: AstroSettings, options: BuildOptions): Promise<void>;
+export default function build(inlineConfig: AstroInlineConfig, options: BuildOptions): Promise<void>;

package/dist/core/build/index.js

@@ -1,7 +1,10 @@
 import * as colors from "kleur/colors";
 import fs from "node:fs";
 import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
 import { injectImageEndpoint } from "../../assets/internal.js";
+import { telemetry } from "../../events/index.js";
+import { eventCliSession } from "../../events/session.js";
 import {
   runHookBuildDone,
   runHookBuildStart,
@@ -9,33 +12,28 @@ import {
   runHookConfigSetup
 } from "../../integrations/index.js";
 import { isServerLikeOutput } from "../../prerender/utils.js";
+import { resolveConfig } from "../config/config.js";
+import { createNodeLogging } from "../config/logging.js";
+import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
 import { debug, info, levels, timerMessage, warn } from "../logger/core.js";
-import { printHelp } from "../messages.js";
 import { apply as applyPolyfill } from "../polyfill.js";
 import { RouteCache } from "../render/route-cache.js";
 import { createRouteManifest } from "../routing/index.js";
 import { collectPagesData } from "./page-data.js";
 import { staticBuild, viteBuild } from "./static-build.js";
 import { getTimeStat } from "./util.js";
-async function build(settings, options) {
-  var _a, _b;
+async function build(inlineConfig, options) {
   applyPolyfill();
-  if (((_a = options.flags) == null ? void 0 : _a.help) || ((_b = options.flags) == null ? void 0 : _b.h)) {
-    printHelp({
-      commandName: "astro build",
-      usage: "[...flags]",
-      tables: {
-        Flags: [
-          ["--drafts", `Include Markdown draft pages in the build.`],
-          ["--help (-h)", "See all available flags."]
-        ]
-      },
-      description: `Builds your site for deployment.`
-    });
-    return;
-  }
-  const builder = new AstroBuilder(settings, options);
+  const logging = createNodeLogging(inlineConfig);
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "build");
+  telemetry.record(eventCliSession("build", userConfig));
+  const settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
+  const builder = new AstroBuilder(settings, {
+    ...options,
+    logging,
+    mode: inlineConfig.mode
+  });
   await builder.run();
 }
 class AstroBuilder {
@@ -77,8 +75,8 @@ class AstroBuilder {
       { settings: this.settings, logging, mode: "build", command: "build" }
     );
     await runHookConfigDone({ settings: this.settings, logging });
-    const { sync } = await import("../sync/index.js");
-    const syncRet = await sync(this.settings, { logging, fs });
+    const { syncInternal } = await import("../sync/index.js");
+    const syncRet = await syncInternal(this.settings, { logging, fs });
     if (syncRet !== 0) {
       return process.exit(syncRet);
     }

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

@@ -1,40 +1,24 @@
 /// <reference types="node" />
 import type { Arguments as Flags } from 'yargs-parser';
-import type { AstroConfig, AstroUserConfig, CLIFlags } from '../../@types/astro';
+import type { AstroConfig, AstroInlineConfig, AstroUserConfig, CLIFlags } from '../../@types/astro';
 import fs from 'node:fs';
-export declare const LEGACY_ASTRO_CONFIG_KEYS: Set<string>;
 /** Turn raw config values into normalized values */
 export declare function validateConfig(userConfig: any, root: string, cmd: string): Promise<AstroConfig>;
 /** Convert the generic "yargs" flag object into our own, custom TypeScript object. */
 export declare function resolveFlags(flags: Partial<Flags>): CLIFlags;
 export declare function resolveRoot(cwd?: string | URL): string;
-interface LoadConfigOptions {
-    cwd?: string;
-    flags?: Flags;
-    cmd: string;
-    validate?: boolean;
-    /** Invalidate when reloading a previously loaded config */
-    isRestart?: boolean;
-    fsMod?: typeof fs;
-}
 interface ResolveConfigPathOptions {
-    cwd?: string;
-    flags?: Flags;
+    root: string;
+    configFile?: string;
     fs: typeof fs;
 }
 /**
  * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file
  */
-export declare function resolveConfigPath(configOptions: ResolveConfigPathOptions): Promise<string | undefined>;
-interface OpenConfigResult {
+export declare function resolveConfigPath(options: ResolveConfigPathOptions): Promise<string | undefined>;
+interface ResolveConfigResult {
     userConfig: AstroUserConfig;
     astroConfig: AstroConfig;
-    flags: CLIFlags;
-    root: string;
 }
-/** Load a configuration file, returning both the userConfig and astroConfig */
-export declare function openConfig(configOptions: LoadConfigOptions): Promise<OpenConfigResult>;
-/** Attempt to resolve an Astro configuration object. Normalize, validate, and return. */
-export declare function resolveConfig(userConfig: AstroUserConfig, root: string, flags: CLIFlags | undefined, cmd: string): Promise<AstroConfig>;
-export declare function createDefaultDevConfig(userConfig?: AstroUserConfig, root?: string): Promise<AstroConfig>;
+export declare function resolveConfig(inlineConfig: AstroInlineConfig, command: string, fsMod?: typeof fs): Promise<ResolveConfigResult>;
 export {};

package/dist/core/config/config.js

@@ -2,7 +2,11 @@ import * as colors from "kleur/colors";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { ZodError } from "zod";
+import { eventConfigError, telemetry } from "../../events/index.js";
+import { trackAstroConfigZodError } from "../errors/errors.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
+import { formatConfigErrorMessage } from "../messages.js";
 import { mergeConfig } from "./merge.js";
 import { createRelativeSchema } from "./schema.js";
 import { loadConfigWithVite } from "./vite-load.js";
@@ -60,7 +64,17 @@ async function validateConfig(userConfig, root, cmd) {
     });
   }
   const AstroConfigRelativeSchema = createRelativeSchema(cmd, root);
-  const result = await AstroConfigRelativeSchema.parseAsync(userConfig);
+  let result;
+  try {
+    result = await AstroConfigRelativeSchema.parseAsync(userConfig);
+  } catch (e) {
+    if (e instanceof ZodError) {
+      trackAstroConfigZodError(e);
+      console.error(formatConfigErrorMessage(e) + "\n");
+      telemetry.record(eventConfigError({ cmd, err: e, isFatal: true }));
+    }
+    throw e;
+  }
   return result;
 }
 function resolveFlags(flags) {
@@ -82,20 +96,6 @@ function resolveRoot(cwd) {
   }
   return cwd ? path.resolve(cwd) : process.cwd();
 }
-function mergeCLIFlags(astroConfig, flags) {
-  return mergeConfig(astroConfig, {
-    site: flags.site,
-    base: flags.base,
-    markdown: {
-      drafts: flags.drafts
-    },
-    server: {
-      port: flags.port,
-      host: flags.host,
-      open: flags.open
-    }
-  });
-}
 async function search(fsMod, root) {
   const paths = [
     "astro.config.mjs",
@@ -111,63 +111,64 @@ async function search(fsMod, root) {
     }
   }
 }
-async function resolveConfigPath(configOptions) {
-  const root = resolveRoot(configOptions.cwd);
-  const flags = resolveFlags(configOptions.flags || {});
+async function resolveConfigPath(options) {
   let userConfigPath;
-  if (flags == null ? void 0 : flags.config) {
-    userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
-    userConfigPath = fileURLToPath(new URL(userConfigPath, `file://${root}/`));
-    if (!configOptions.fs.existsSync(userConfigPath)) {
+  if (options.configFile) {
+    userConfigPath = path.join(options.root, options.configFile);
+    if (!options.fs.existsSync(userConfigPath)) {
       throw new AstroError({
         ...AstroErrorData.ConfigNotFound,
-        message: AstroErrorData.ConfigNotFound.message(flags.config)
+        message: AstroErrorData.ConfigNotFound.message(options.configFile)
       });
     }
   } else {
-    userConfigPath = await search(configOptions.fs, root);
+    userConfigPath = await search(options.fs, options.root);
   }
   return userConfigPath;
 }
-async function openConfig(configOptions) {
-  const root = resolveRoot(configOptions.cwd);
-  const flags = resolveFlags(configOptions.flags || {});
-  const userConfig = await loadConfig(configOptions, root);
-  const astroConfig = await resolveConfig(userConfig, root, flags, configOptions.cmd);
-  return {
-    astroConfig,
-    userConfig,
-    flags,
-    root
-  };
-}
-async function loadConfig(configOptions, root) {
-  const fsMod = configOptions.fsMod ?? fs;
+async function loadConfig(root, configFile, fsMod = fs) {
+  if (configFile === false)
+    return {};
   const configPath = await resolveConfigPath({
-    cwd: configOptions.cwd,
-    flags: configOptions.flags,
+    root,
+    configFile,
     fs: fsMod
   });
   if (!configPath)
     return {};
-  return await loadConfigWithVite({
-    configPath,
-    fs: fsMod,
-    root
-  });
+  try {
+    return await loadConfigWithVite({
+      root,
+      configPath,
+      fs: fsMod
+    });
+  } catch (e) {
+    const configPathText = configFile ? colors.bold(configFile) : "your Astro config";
+    console.error(`${colors.bold(colors.red("[astro]"))} Unable to load ${configPathText}
+`);
+    throw e;
+  }
 }
-async function resolveConfig(userConfig, root, flags = {}, cmd) {
-  const mergedConfig = mergeCLIFlags(userConfig, flags);
-  const validatedConfig = await validateConfig(mergedConfig, root, cmd);
-  return validatedConfig;
+function splitInlineConfig(inlineConfig) {
+  const { configFile, mode, logLevel, ...inlineUserConfig } = inlineConfig;
+  return {
+    inlineUserConfig,
+    inlineOnlyConfig: {
+      configFile,
+      mode,
+      logLevel
+    }
+  };
 }
-function createDefaultDevConfig(userConfig = {}, root = process.cwd()) {
-  return resolveConfig(userConfig, root, void 0, "dev");
+async function resolveConfig(inlineConfig, command, fsMod = fs) {
+  const root = resolveRoot(inlineConfig.root);
+  const { inlineUserConfig, inlineOnlyConfig } = splitInlineConfig(inlineConfig);
+  const userConfig = await loadConfig(root, inlineOnlyConfig.configFile, fsMod);
+  const mergedConfig = mergeConfig(userConfig, inlineUserConfig);
+  const astroConfig = await validateConfig(mergedConfig, root, command);
+  return { userConfig, astroConfig };
 }
 export {
-  LEGACY_ASTRO_CONFIG_KEYS,
-  createDefaultDevConfig,
-  openConfig,
   resolveConfig,
   resolveConfigPath,
   resolveFlags,

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

@@ -1,5 +1,6 @@
-export { createDefaultDevConfig, openConfig, resolveConfigPath, resolveFlags, resolveRoot, validateConfig, } from './config.js';
+export { resolveConfig, resolveConfigPath, resolveFlags, resolveRoot } from './config.js';
+export { createNodeLogging } from './logging.js';
 export { mergeConfig } from './merge.js';
 export type { AstroConfigSchema } from './schema';
-export { createDefaultDevSettings, createSettings } from './settings.js';
+export { createSettings } from './settings.js';
 export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';

package/dist/core/config/index.js

@@ -1,24 +1,16 @@
-import {
-  createDefaultDevConfig,
-  openConfig,
-  resolveConfigPath,
-  resolveFlags,
-  resolveRoot,
-  validateConfig
-} from "./config.js";
+import { resolveConfig, resolveConfigPath, resolveFlags, resolveRoot } from "./config.js";
+import { createNodeLogging } from "./logging.js";
 import { mergeConfig } from "./merge.js";
-import { createDefaultDevSettings, createSettings } from "./settings.js";
+import { createSettings } from "./settings.js";
 import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
-  createDefaultDevConfig,
-  createDefaultDevSettings,
+  createNodeLogging,
   createSettings,
   loadTSConfig,
   mergeConfig,
-  openConfig,
+  resolveConfig,
   resolveConfigPath,
   resolveFlags,
   resolveRoot,
-  updateTSConfigForFramework,
-  validateConfig
+  updateTSConfigForFramework
 };

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

@@ -0,0 +1,3 @@
+import type { AstroInlineConfig } from '../../@types/astro.js';
+import type { LogOptions } from '../logger/core.js';
+export declare function createNodeLogging(inlineConfig: AstroInlineConfig): LogOptions;

package/dist/core/config/logging.js

@@ -0,0 +1,12 @@
+import { nodeLogDestination } from "../logger/node.js";
+function createNodeLogging(inlineConfig) {
+  if (inlineConfig.logging)
+    return inlineConfig.logging;
+  return {
+    dest: nodeLogDestination,
+    level: inlineConfig.logLevel ?? "info"
+  };
+}
+export {
+  createNodeLogging
+};

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

@@ -1,4 +1,3 @@
-import type { AstroConfig, AstroSettings, AstroUserConfig } from '../../@types/astro';
+import type { AstroConfig, AstroSettings } from '../../@types/astro';
 export declare function createBaseSettings(config: AstroConfig): AstroSettings;
 export declare function createSettings(config: AstroConfig, cwd?: string): AstroSettings;
-export declare function createDefaultDevSettings(userConfig?: AstroUserConfig, root?: string | URL): Promise<AstroSettings>;

package/dist/core/config/settings.js

@@ -8,7 +8,6 @@ import { getDefaultClientDirectives } from "../client-directive/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { formatYAMLException, isYAMLException } from "../errors/utils.js";
 import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "./../constants.js";
-import { createDefaultDevConfig } from "./config.js";
 import { AstroTimer } from "./timer.js";
 import { loadTSConfig } from "./tsconfig.js";
 function createBaseSettings(config) {
@@ -103,15 +102,7 @@ function createSettings(config, cwd) {
   settings.watchFiles = watchFiles;
   return settings;
 }
-async function createDefaultDevSettings(userConfig = {}, root) {
-  if (root && typeof root !== "string") {
-    root = fileURLToPath(root);
-  }
-  const config = await createDefaultDevConfig(userConfig, root);
-  return createBaseSettings(config);
-}
 export {
   createBaseSettings,
-  createDefaultDevSettings,
   createSettings
 };

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.9.5";
+const ASTRO_VERSION = "2.9.7";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/container.d.ts

@@ -3,7 +3,7 @@
 /// <reference types="node" />
 import type * as http from 'node:http';
 import type { AddressInfo } from 'node:net';
-import type { AstroSettings, AstroUserConfig } from '../../@types/astro';
+import type { AstroInlineConfig, AstroSettings } from '../../@types/astro';
 import nodeFs from 'node:fs';
 import * as vite from 'vite';
 import type { LogOptions } from '../logger/core.js';
@@ -11,29 +11,19 @@ export interface Container {
     fs: typeof nodeFs;
     logging: LogOptions;
     settings: AstroSettings;
-    viteConfig: vite.InlineConfig;
     viteServer: vite.ViteDevServer;
-    resolvedRoot: string;
-    configFlag: string | undefined;
-    configFlagPath: string | undefined;
+    inlineConfig: AstroInlineConfig;
     restartInFlight: boolean;
     handle: (req: http.IncomingMessage, res: http.ServerResponse) => void;
     close: () => Promise<void>;
 }
 export interface CreateContainerParams {
+    logging: LogOptions;
+    settings: AstroSettings;
+    inlineConfig?: AstroInlineConfig;
     isRestart?: boolean;
-    logging?: LogOptions;
-    userConfig?: AstroUserConfig;
-    settings?: AstroSettings;
     fs?: typeof nodeFs;
-    root?: string | URL;
-    configFlag?: string;
-    configFlagPath?: string;
 }
-export declare function createContainer(params?: CreateContainerParams): Promise<Container>;
+export declare function createContainer({ isRestart, logging, inlineConfig, settings, fs, }: CreateContainerParams): Promise<Container>;
 export declare function startContainer({ settings, viteServer, logging, }: Container): Promise<AddressInfo>;
 export declare function isStarted(container: Container): boolean;
-/**
- * Only used in tests
- */
-export declare function runInContainer(params: CreateContainerParams, callback: (container: Container) => Promise<void> | void): Promise<void>;