astro 2.9.6 → 2.10.0

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.6";
+const ASTRO_VERSION = "2.10.0";
 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,18 @@ 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>;

package/dist/core/dev/container.js

@@ -7,22 +7,15 @@ import {
   runHookServerDone,
   runHookServerStart
 } from "../../integrations/index.js";
-import { createDefaultDevSettings, resolveRoot } from "../config/index.js";
 import { createVite } from "../create-vite.js";
-import { nodeLogDestination } from "../logger/node.js";
-import { appendForwardSlash } from "../path.js";
 import { apply as applyPolyfill } from "../polyfill.js";
-const defaultLogging = {
-  dest: nodeLogDestination,
-  level: "error"
-};
-async function createContainer(params = {}) {
-  let {
-    isRestart = false,
-    logging = defaultLogging,
-    settings = await createDefaultDevSettings(params.userConfig, params.root),
-    fs = nodeFs
-  } = params;
+async function createContainer({
+  isRestart = false,
+  logging,
+  inlineConfig,
+  settings,
+  fs = nodeFs
+}) {
   applyPolyfill();
   settings = await runHookConfigSetup({
     settings,
@@ -48,14 +41,11 @@ async function createContainer(params = {}) {
   await runHookConfigDone({ settings, logging });
   const viteServer = await vite.createServer(viteConfig);
   const container = {
-    configFlag: params.configFlag,
-    configFlagPath: params.configFlagPath,
+    inlineConfig: inlineConfig ?? {},
     fs,
     logging,
-    resolvedRoot: appendForwardSlash(resolveRoot(params.root)),
     restartInFlight: false,
     settings,
-    viteConfig,
     viteServer,
     handle(req, res) {
       viteServer.middlewares.handle(req, res, Function.prototype);
@@ -89,21 +79,7 @@ async function startContainer({
   });
   return devServerAddressInfo;
 }
-function isStarted(container) {
-  var _a;
-  return !!((_a = container.viteServer.httpServer) == null ? void 0 : _a.listening);
-}
-async function runInContainer(params, callback) {
-  const container = await createContainer(params);
-  try {
-    await callback(container);
-  } finally {
-    await container.close();
-  }
-}
 export {
   createContainer,
-  isStarted,
-  runInContainer,
   startContainer
 };

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

@@ -3,17 +3,7 @@
 import type http from 'node:http';
 import type { AddressInfo } from 'node:net';
 import type * as vite from 'vite';
-import type yargs from 'yargs-parser';
-import type { AstroSettings } from '../../@types/astro';
-import { type LogOptions } from '../logger/core.js';
-export interface DevOptions {
-    configFlag: string | undefined;
-    configFlagPath: string | undefined;
-    flags?: yargs.Arguments;
-    logging: LogOptions;
-    handleConfigError: (error: Error) => void;
-    isRestart?: boolean;
-}
+import type { AstroInlineConfig } from '../../@types/astro';
 export interface DevServer {
     address: AddressInfo;
     handle: (req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) => void;
@@ -21,4 +11,4 @@ export interface DevServer {
     stop(): Promise<void>;
 }
 /** `astro dev` */
-export default function dev(settings: AstroSettings, options: DevOptions): Promise<DevServer | undefined>;
+export default function dev(inlineConfig: AstroInlineConfig): Promise<DevServer>;

package/dist/core/dev/dev.js

@@ -1,65 +1,34 @@
-import { cyan } from "kleur/colors";
+import fs from "node:fs";
 import { performance } from "perf_hooks";
 import { attachContentServerListeners } from "../../content/index.js";
 import { telemetry } from "../../events/index.js";
 import { info, warn } from "../logger/core.js";
 import * as msg from "../messages.js";
-import { printHelp } from "../messages.js";
 import { startContainer } from "./container.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
-async function dev(settings, options) {
-  var _a, _b, _c, _d, _e;
-  if (((_a = options.flags) == null ? void 0 : _a.help) || ((_b = options.flags) == null ? void 0 : _b.h)) {
-    printHelp({
-      commandName: "astro dev",
-      usage: "[...flags]",
-      tables: {
-        Flags: [
-          ["--port", `Specify which port to run on. Defaults to 3000.`],
-          ["--host", `Listen on all addresses, including LAN and public addresses.`],
-          ["--host <custom-address>", `Expose on a network IP address at <custom-address>`],
-          ["--open", "Automatically open the app in the browser on server start"],
-          ["--help (-h)", "See all available flags."]
-        ]
-      },
-      description: `Check ${cyan(
-        "https://docs.astro.build/en/reference/cli-reference/#astro-dev"
-      )} for more information.`
-    });
-    return;
-  }
+async function dev(inlineConfig) {
+  var _a, _b;
   const devStart = performance.now();
   await telemetry.record([]);
-  const restart = await createContainerWithAutomaticRestart({
-    flags: options.flags ?? {},
-    handleConfigError: options.handleConfigError,
-    // eslint-disable-next-line no-console
-    beforeRestart: () => console.clear(),
-    params: {
-      settings,
-      root: (_c = options.flags) == null ? void 0 : _c.root,
-      logging: options.logging,
-      isRestart: options.isRestart
-    }
-  });
+  const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
+  const logging = restart.container.logging;
   const devServerAddressInfo = await startContainer(restart.container);
   info(
-    options.logging,
+    logging,
     null,
     msg.serverStart({
       startupTime: performance.now() - devStart,
       resolvedUrls: restart.container.viteServer.resolvedUrls || { local: [], network: [] },
-      host: settings.config.server.host,
-      base: settings.config.base,
-      isRestart: options.isRestart
+      host: restart.container.settings.config.server.host,
+      base: restart.container.settings.config.base
     })
   );
-  const currentVersion = "2.9.6";
+  const currentVersion = "2.10.0";
   if (currentVersion.includes("-")) {
-    warn(options.logging, null, msg.prerelease({ currentVersion }));
+    warn(logging, null, msg.prerelease({ currentVersion }));
   }
-  if (((_e = (_d = restart.container.viteConfig.server) == null ? void 0 : _d.fs) == null ? void 0 : _e.strict) === false) {
-    warn(options.logging, null, msg.fsStrictWarning());
+  if (((_b = (_a = restart.container.viteServer.config.server) == null ? void 0 : _a.fs) == null ? void 0 : _b.strict) === false) {
+    warn(logging, null, msg.fsStrictWarning());
   }
   await attachContentServerListeners(restart.container);
   return {

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

@@ -1,3 +1,3 @@
-export { createContainer, isStarted, runInContainer, startContainer } from './container.js';
+export { createContainer, startContainer } from './container.js';
 export { default } from './dev.js';
 export { createContainerWithAutomaticRestart } from './restart.js';

package/dist/core/dev/index.js

@@ -1,11 +1,9 @@
-import { createContainer, isStarted, runInContainer, startContainer } from "./container.js";
+import { createContainer, startContainer } from "./container.js";
 import { default as default2 } from "./dev.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
 export {
   createContainer,
   createContainerWithAutomaticRestart,
   default2 as default,
-  isStarted,
-  runInContainer,
   startContainer
 };

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

@@ -1,25 +1,16 @@
-import type { Container, CreateContainerParams } from './container';
-export declare function shouldRestartContainer({ settings, configFlag, configFlagPath, restartInFlight }: Container, changedFile: string): boolean;
-interface RestartContainerParams {
-    container: Container;
-    flags: any;
-    logMsg: string;
-    handleConfigError: (err: Error) => Promise<void> | void;
-    beforeRestart?: () => void;
-}
-export declare function restartContainer({ container, flags, logMsg, handleConfigError, beforeRestart, }: RestartContainerParams): Promise<{
-    container: Container;
-    error: Error | null;
-}>;
+/// <reference types="node" />
+import nodeFs from 'node:fs';
+import type { AstroInlineConfig } from '../../@types/astro';
+import type { Container } from './container';
+export declare function shouldRestartContainer({ settings, inlineConfig, restartInFlight }: Container, changedFile: string): boolean;
+export declare function restartContainer(container: Container): Promise<Container | Error>;
 export interface CreateContainerWithAutomaticRestart {
-    flags: any;
-    params: CreateContainerParams;
-    handleConfigError?: (error: Error) => void | Promise<void>;
-    beforeRestart?: () => void;
+    inlineConfig?: AstroInlineConfig;
+    fs: typeof nodeFs;
 }
 interface Restart {
     container: Container;
     restarted: () => Promise<Error | null>;
 }
-export declare function createContainerWithAutomaticRestart({ flags, handleConfigError, beforeRestart, params, }: CreateContainerWithAutomaticRestart): Promise<Restart>;
+export declare function createContainerWithAutomaticRestart({ inlineConfig, fs, }: CreateContainerWithAutomaticRestart): Promise<Restart>;
 export {};

package/dist/core/dev/restart.js

@@ -1,32 +1,31 @@
+import { fileURLToPath } from "node:url";
 import * as vite from "vite";
-import { createSettings, openConfig } from "../config/index.js";
+import { eventCliSession, telemetry } from "../../events/index.js";
+import { createNodeLogging, createSettings, resolveConfig } from "../config/index.js";
+import { collectErrorMetadata } from "../errors/dev/utils.js";
+import { isAstroConfigZodError } from "../errors/errors.js";
 import { createSafeError } from "../errors/index.js";
-import { info } from "../logger/core.js";
-import { createContainer, isStarted, startContainer } from "./container.js";
-async function createRestartedContainer(container, settings, needsStart) {
-  const { logging, fs, resolvedRoot, configFlag, configFlagPath } = container;
+import { info, error as logError } from "../logger/core.js";
+import { formatErrorMessage } from "../messages.js";
+import { createContainer, startContainer } from "./container.js";
+async function createRestartedContainer(container, settings) {
+  const { logging, fs, inlineConfig } = container;
   const newContainer = await createContainer({
     isRestart: true,
     logging,
     settings,
-    fs,
-    root: resolvedRoot,
-    configFlag,
-    configFlagPath
+    inlineConfig,
+    fs
   });
-  if (needsStart) {
-    await startContainer(newContainer);
-  }
+  await startContainer(newContainer);
   return newContainer;
 }
-function shouldRestartContainer({ settings, configFlag, configFlagPath, restartInFlight }, changedFile) {
+function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
   if (restartInFlight)
     return false;
   let shouldRestart = false;
-  if (configFlag) {
-    if (!!configFlagPath) {
-      shouldRestart = vite.normalizePath(configFlagPath) === vite.normalizePath(changedFile);
-    }
+  if (inlineConfig.configFile) {
+    shouldRestart = vite.normalizePath(inlineConfig.configFile) === vite.normalizePath(changedFile);
   } else {
     const exp = new RegExp(`.*astro.config.((mjs)|(cjs)|(js)|(ts))$`);
     const normalizedChangedFile = vite.normalizePath(changedFile);
@@ -39,54 +38,40 @@ function shouldRestartContainer({ settings, configFlag, configFlagPath, restartI
   }
   return shouldRestart;
 }
-async function restartContainer({
-  container,
-  flags,
-  logMsg,
-  handleConfigError,
-  beforeRestart
-}) {
-  const { logging, close, resolvedRoot, settings: existingSettings } = container;
+async function restartContainer(container) {
+  const { logging, close, settings: existingSettings } = container;
   container.restartInFlight = true;
-  if (beforeRestart) {
-    beforeRestart();
-  }
-  const needsStart = isStarted(container);
   try {
-    const newConfig = await openConfig({
-      cwd: resolvedRoot,
-      flags,
-      cmd: "dev",
-      isRestart: true,
-      fsMod: container.fs
-    });
-    info(logging, "astro", logMsg + "\n");
-    let astroConfig = newConfig.astroConfig;
-    const settings = createSettings(astroConfig, resolvedRoot);
+    const { astroConfig } = await resolveConfig(container.inlineConfig, "dev", container.fs);
+    const settings = createSettings(astroConfig, fileURLToPath(existingSettings.config.root));
     await close();
-    return {
-      container: await createRestartedContainer(container, settings, needsStart),
-      error: null
-    };
+    return await createRestartedContainer(container, settings);
   } catch (_err) {
     const error = createSafeError(_err);
-    await handleConfigError(error);
-    await close();
+    if (!isAstroConfigZodError(_err)) {
+      logError(logging, "config", formatErrorMessage(collectErrorMetadata(error)) + "\n");
+    }
+    container.viteServer.ws.send({
+      type: "error",
+      err: {
+        message: error.message,
+        stack: error.stack || ""
+      }
+    });
+    container.restartInFlight = false;
     info(logging, "astro", "Continuing with previous valid configuration\n");
-    return {
-      container: await createRestartedContainer(container, existingSettings, needsStart),
-      error
-    };
+    return error;
   }
 }
 async function createContainerWithAutomaticRestart({
-  flags,
-  handleConfigError = () => {
-  },
-  beforeRestart,
-  params
+  inlineConfig,
+  fs
 }) {
-  const initialContainer = await createContainer(params);
+  const logging = createNodeLogging(inlineConfig ?? {});
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "dev", fs);
+  telemetry.record(eventCliSession("dev", userConfig));
+  const settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
+  const initialContainer = await createContainer({ settings, logging, inlineConfig, fs });
   let resolveRestart;
   let restartComplete = new Promise((resolve) => {
     resolveRestart = resolve;
@@ -98,26 +83,16 @@ async function createContainerWithAutomaticRestart({
     }
   };
   async function handleServerRestart(logMsg) {
+    info(logging, "astro", logMsg + "\n");
     const container = restart.container;
-    const { container: newContainer, error } = await restartContainer({
-      beforeRestart,
-      container,
-      flags,
-      logMsg,
-      async handleConfigError(err) {
-        await handleConfigError(err);
-        container.viteServer.ws.send({
-          type: "error",
-          err: {
-            message: err.message,
-            stack: err.stack || ""
-          }
-        });
-      }
-    });
-    restart.container = newContainer;
-    addWatches();
-    resolveRestart(error);
+    const result = await restartContainer(container);
+    if (result instanceof Error) {
+      resolveRestart(result);
+    } else {
+      restart.container = result;
+      addWatches();
+      resolveRestart(null);
+    }
     restartComplete = new Promise((resolve) => {
       resolveRestart = resolve;
     });

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

@@ -1,3 +1,4 @@
+import type { ZodError } from 'zod';
 interface ErrorProperties {
     title?: string;
     name?: string;
@@ -53,6 +54,15 @@ export declare class AggregateError extends AstroError {
     }, ...params: any);
     static is(err: unknown): err is AggregateError;
 }
+/**
+ * Check if an error is a ZodError from an AstroConfig validation.
+ * Used to suppress formatting a ZodError if needed.
+ */
+export declare function isAstroConfigZodError(error: unknown): error is ZodError;
+/**
+ * Track that a ZodError comes from an AstroConfig validation.
+ */
+export declare function trackAstroConfigZodError(error: ZodError): void;
 /**
  * Generic object representing an error with all possible data
  * Compatible with both Astro's and Vite's errors

package/dist/core/errors/errors.js

@@ -93,6 +93,13 @@ class AggregateError extends AstroError {
     return err.type === "AggregateError";
   }
 }
+const astroConfigZodErrors = /* @__PURE__ */ new WeakSet();
+function isAstroConfigZodError(error) {
+  return astroConfigZodErrors.has(error);
+}
+function trackAstroConfigZodError(error) {
+  astroConfigZodErrors.add(error);
+}
 export {
   AggregateError,
   AstroError,
@@ -100,5 +107,7 @@ export {
   CompilerError,
   InternalError,
   MarkdownError,
-  isAstroError
+  isAstroConfigZodError,
+  isAstroError,
+  trackAstroConfigZodError
 };

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.9.6";
+  const version = "2.10.0";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.9.6"}`
+        `v${"2.10.0"}`
       )} ${headline}`
     );
   }

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

@@ -1,10 +1,3 @@
-import type { Arguments } from 'yargs-parser';
-import type { AstroSettings, PreviewServer } from '../../@types/astro';
-import type { LogOptions } from '../logger/core';
-interface PreviewOptions {
-    logging: LogOptions;
-    flags?: Arguments;
-}
+import type { AstroInlineConfig, PreviewServer } from '../../@types/astro';
 /** The primary dev action */
-export default function preview(_settings: AstroSettings, { logging, flags }: PreviewOptions): Promise<PreviewServer | undefined>;
-export {};
+export default function preview(inlineConfig: AstroInlineConfig): Promise<PreviewServer | undefined>;

package/dist/core/preview/index.js

@@ -1,27 +1,18 @@
-import { cyan } from "kleur/colors";
-import { createRequire } from "module";
-import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { telemetry } from "../../events/index.js";
+import { eventCliSession } from "../../events/session.js";
 import { runHookConfigDone, runHookConfigSetup } from "../../integrations/index.js";
-import { printHelp } from "../messages.js";
+import { resolveConfig } from "../config/config.js";
+import { createNodeLogging } from "../config/logging.js";
+import { createSettings } from "../config/settings.js";
 import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
-async function preview(_settings, { logging, flags }) {
-  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
-    printHelp({
-      commandName: "astro preview",
-      usage: "[...flags]",
-      tables: {
-        Flags: [
-          ["--open", "Automatically open the app in the browser on server start"],
-          ["--help (-h)", "See all available flags."]
-        ]
-      },
-      description: `Starts a local server to serve your static dist/ directory. Check ${cyan(
-        "https://docs.astro.build/en/reference/cli-reference/#astro-preview"
-      )} for more information.`
-    });
-    return;
-  }
+async function preview(inlineConfig) {
+  const logging = createNodeLogging(inlineConfig);
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "preview");
+  telemetry.record(eventCliSession("preview", userConfig));
+  const _settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const settings = await runHookConfigSetup({
     settings: _settings,
     command: "preview",

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

@@ -1,27 +1,31 @@
 /// <reference types="node" />
-import type fsMod from 'node:fs';
-import type { Arguments } from 'yargs-parser';
-import type { AstroSettings } from '../../@types/astro';
+import fsMod from 'node:fs';
+import type { AstroInlineConfig, AstroSettings } from '../../@types/astro';
 import { type LogOptions } from '../logger/core.js';
 export type ProcessExit = 0 | 1;
 export type SyncOptions = {
-    logging: LogOptions;
-    fs: typeof fsMod;
+    /**
+     * Only used for testing
+     * @internal
+     */
+    fs?: typeof fsMod;
 };
-export declare function syncCli(settings: AstroSettings, { logging, fs, flags }: {
+export type SyncInternalOptions = SyncOptions & {
     logging: LogOptions;
-    fs: typeof fsMod;
-    flags?: Arguments;
-}): Promise<ProcessExit>;
+};
+export declare function sync(inlineConfig: AstroInlineConfig, options?: SyncOptions): Promise<ProcessExit>;
 /**
  * Generate content collection types, and then returns the process exit signal.
  *
  * A non-zero process signal is emitted in case there's an error while generating content collection types.
  *
+ * This should only be used when the callee already has an `AstroSetting`, otherwise use `sync()` instead.
+ * @internal
+ *
  * @param {SyncOptions} options
  * @param {AstroSettings} settings Astro settings
  * @param {typeof fsMod} options.fs The file system
  * @param {LogOptions} options.logging Logging options
  * @return {Promise<ProcessExit>}
  */
-export declare function sync(settings: AstroSettings, { logging, fs }: SyncOptions): Promise<ProcessExit>;
+export declare function syncInternal(settings: AstroSettings, { logging, fs }: SyncInternalOptions): Promise<ProcessExit>;