astro 2.9.6 → 2.10.0

package/components/ViewTransitions.astro

@@ -34,6 +34,7 @@ const { fallback = 'animate' } = Astro.props as Props;
 		!!document.querySelector('[name="astro-view-transitions-enabled"]');
 	const triggerEvent = (name: Events) => document.dispatchEvent(new Event(name));
 	const onload = () => triggerEvent('astro:load');
+	const PERSIST_ATTR = 'data-astro-transition-persist';
 
 	const throttle = (cb: (...args: any[]) => any, delay: number) => {
 		let wait = false;
@@ -86,8 +87,50 @@ const { fallback = 'animate' } = Astro.props as Props;
 	async function updateDOM(dir: Direction, html: string, state?: State, fallback?: Fallback) {
 		const doc = parser.parseFromString(html, 'text/html');
 		doc.documentElement.dataset.astroTransition = dir;
+
+		// Check for a head element that should persist, either because it has the data
+		// attribute or is a link el.
+		const persistedHeadElement = (el: Element): Element | null => {
+			const id = el.getAttribute(PERSIST_ATTR);
+			const newEl = id && doc.head.querySelector(`[${PERSIST_ATTR}="${id}"]`);
+			if (newEl) {
+				return newEl;
+			}
+			if (el.matches('link[rel=stylesheet]')) {
+				const href = el.getAttribute('href');
+				return doc.head.querySelector(`link[rel=stylesheet][href="${href}"]`);
+			}
+			return null;
+		};
+
 		const swap = () => {
-			document.documentElement.replaceWith(doc.documentElement);
+			// Swap head
+			for (const el of Array.from(document.head.children)) {
+				const newEl = persistedHeadElement(el);
+				// If the element exists in the document already, remove it
+				// from the new document and leave the current node alone
+				if (newEl) {
+					newEl.remove();
+				} else {
+					// Otherwise remove the element in the head. It doesn't exist in the new page.
+					el.remove();
+				}
+			}
+			// Everything left in the new head is new, append it all.
+			document.head.append(...doc.head.children);
+
+			// Move over persist stuff in the body
+			const oldBody = document.body;
+			document.body.replaceWith(doc.body);
+			for (const el of oldBody.querySelectorAll(`[${PERSIST_ATTR}]`)) {
+				const id = el.getAttribute(PERSIST_ATTR);
+				const newEl = document.querySelector(`[${PERSIST_ATTR}="${id}"]`);
+				if (newEl) {
+					// The element exists in the new page, replace it with the element
+					// from the old page so that state is preserved.
+					newEl.replaceWith(el);
+				}
+			}
 
 			if (state?.scrollY != null) {
 				scrollTo(0, state.scrollY);
@@ -97,17 +140,27 @@ const { fallback = 'animate' } = Astro.props as Props;
 		};
 
 		// Wait on links to finish, to prevent FOUC
-		const links = Array.from(doc.querySelectorAll('head link[rel=stylesheet]')).map(
-			(link) =>
-				new Promise((resolve) => {
-					const c = link.cloneNode();
-					['load', 'error'].forEach((evName) => c.addEventListener(evName, resolve));
-					document.head.append(c);
-				})
-		);
-		if (links.length) {
-			await Promise.all(links);
+		const links: Promise<any>[] = [];
+		for (const el of doc.querySelectorAll('head link[rel=stylesheet]')) {
+			// Do not preload links that are already on the page.
+			if (
+				!document.querySelector(
+					`[${PERSIST_ATTR}="${el.getAttribute(PERSIST_ATTR)}"], link[rel=stylesheet]`
+				)
+			) {
+				const c = document.createElement('link');
+				c.setAttribute('rel', 'preload');
+				c.setAttribute('as', 'style');
+				c.setAttribute('href', el.getAttribute('href')!);
+				links.push(
+					new Promise<any>((resolve) => {
+						['load', 'error'].forEach((evName) => c.addEventListener(evName, resolve));
+						document.head.append(c);
+					})
+				);
+			}
 		}
+		links.length && (await Promise.all(links));
 
 		if (fallback === 'animate') {
 			let isAnimating = false;
@@ -187,7 +240,7 @@ const { fallback = 'animate' } = Astro.props as Props;
 				transitionEnabledOnThisPage()
 			) {
 				ev.preventDefault();
-				navigate('forward', link.href);
+				navigate('forward', link.href, { index: currentHistoryIndex, scrollY: 0 });
 				currentHistoryIndex++;
 				const newState: State = { index: currentHistoryIndex, scrollY };
 				persistState({ index: currentHistoryIndex - 1, scrollY });

package/dist/@types/astro.d.ts

@@ -14,7 +14,7 @@ import type { PageBuildData } from '../core/build/types';
 import type { AstroConfigSchema } from '../core/config';
 import type { AstroTimer } from '../core/config/timer';
 import type { AstroCookies } from '../core/cookies';
-import type { LogOptions } from '../core/logger/core';
+import type { LogOptions, LoggerLevel } from '../core/logger/core';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
@@ -55,6 +55,7 @@ export interface AstroBuiltinAttributes {
     'is:raw'?: boolean;
     'transition:animate'?: 'morph' | 'slide' | 'fade' | TransitionDirectionalAnimations;
     'transition:name'?: string;
+    'transition:persist'?: boolean | string;
 }
 export interface AstroDefineVarsAttribute {
     'define:vars'?: any;
@@ -1227,6 +1228,17 @@ export interface InjectedRoute {
 export interface AstroConfig extends z.output<typeof AstroConfigSchema> {
     integrations: AstroIntegration[];
 }
+export interface AstroInlineConfig extends AstroUserConfig, AstroInlineOnlyConfig {
+}
+export interface AstroInlineOnlyConfig {
+    configFile?: string | false;
+    mode?: RuntimeMode;
+    logLevel?: LoggerLevel;
+    /**
+     * @internal for testing only
+     */
+    logging?: LogOptions;
+}
 export type ContentEntryModule = {
     id: string;
     collection: string;

package/dist/assets/vite-plugin-assets.js

@@ -122,7 +122,7 @@ function assets({
         if (s) {
           return {
             code: s.toString(),
-            map: resolvedConfig.build.sourcemap ? s.generateMap({ hires: true }) : null
+            map: resolvedConfig.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
           };
         } else {
           return null;

package/dist/cli/add/index.d.ts

@@ -1,7 +1,5 @@
 import type yargs from 'yargs-parser';
-import { type LogOptions } from '../../core/logger/core.js';
 interface AddOptions {
-    logging: LogOptions;
     flags: yargs.Arguments;
 }
 interface IntegrationInfo {
@@ -10,6 +8,6 @@ interface IntegrationInfo {
     dependencies: [name: string, version: string][];
     type: 'integration' | 'adapter';
 }
-export declare function add(names: string[], { flags, logging }: AddOptions): Promise<void>;
+export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
 export declare function validateIntegrations(integrations: string[]): Promise<IntegrationInfo[]>;
 export {};

package/dist/cli/add/index.js

@@ -8,7 +8,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import ora from "ora";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
-import { loadTSConfig, resolveConfigPath } from "../../core/config/index.js";
+import { loadTSConfig, resolveConfigPath, resolveRoot } from "../../core/config/index.js";
 import {
   defaultTSConfig,
   presets,
@@ -21,6 +21,7 @@ import { appendForwardSlash } from "../../core/path.js";
 import { apply as applyPolyfill } from "../../core/polyfill.js";
 import { parseNpmName } from "../../core/util.js";
 import { eventCliSession, telemetry } from "../../events/index.js";
+import { createLoggingFromFlags } from "../flags.js";
 import { generate, parse, t, visit } from "./babel.js";
 import { ensureImport } from "./imports.js";
 import { wrapDefaultExport } from "./wrapper.js";
@@ -66,7 +67,7 @@ async function getRegistry() {
     return "https://registry.npmjs.org";
   }
 }
-async function add(names, { flags, logging }) {
+async function add(names, { flags }) {
   var _a;
   telemetry.record(eventCliSession("add"));
   applyPolyfill();
@@ -109,10 +110,12 @@ async function add(names, { flags, logging }) {
     return;
   }
   const cwd = flags.root;
+  const logging = createLoggingFromFlags(flags);
   const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
   const integrations = await validateIntegrations(integrationNames);
   let installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logging });
-  const root = pathToFileURL(cwd ? path.resolve(cwd) : process.cwd());
+  const rootPath = resolveRoot(cwd);
+  const root = pathToFileURL(rootPath);
   root.href = appendForwardSlash(root.href);
   switch (installResult) {
     case 1 /* updated */: {
@@ -170,7 +173,11 @@ async function add(names, { flags, logging }) {
       throw createPrettyError(new Error(`Unable to install dependencies`));
     }
   }
-  const rawConfigPath = await resolveConfigPath({ cwd, flags, fs: fsMod });
+  const rawConfigPath = await resolveConfigPath({
+    root: rootPath,
+    configFile: flags.config,
+    fs: fsMod
+  });
   let configURL = rawConfigPath ? pathToFileURL(rawConfigPath) : void 0;
   if (configURL) {
     debug("add", `Found config at ${configURL}`);

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import type { LogOptions } from '../../core/logger/core.js';
 interface BuildOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function build({ flags, logging }: BuildOptions): Promise<void>;
+export declare function build({ flags }: BuildOptions): Promise<void>;
 export {};

package/dist/cli/build/index.js

@@ -1,14 +1,24 @@
 import _build from "../../core/build/index.js";
-import { loadSettings } from "../load-settings.js";
-async function build({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "build", flags, logging });
-  if (!settings)
+import { printHelp } from "../../core/messages.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function build({ flags }) {
+  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.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;
-  await _build(settings, {
-    flags,
-    logging,
-    teardownCompiler: true,
-    mode: flags.mode
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  await _build(inlineConfig, {
+    teardownCompiler: true
   });
 }
 export {

package/dist/cli/check/index.d.ts

@@ -4,16 +4,12 @@ import fs from 'node:fs';
 import type { Arguments as Flags } from 'yargs-parser';
 import type { AstroSettings } from '../../@types/astro';
 import type { LogOptions } from '../../core/logger/core.js';
-import type { ProcessExit, SyncOptions } from '../../core/sync';
+import type { syncInternal } from '../../core/sync';
 export type CheckPayload = {
     /**
      * Flags passed via CLI
      */
     flags: Flags;
-    /**
-     * Logging options
-     */
-    logging: LogOptions;
 };
 /**
  *
@@ -43,13 +39,12 @@ export declare enum CheckResult {
  *
  * @param {CheckPayload} options Options passed {@link AstroChecker}
  * @param {Flags} options.flags Flags coming from the CLI
- * @param {LogOptions} options.logging Logging options
  */
-export declare function check({ logging, flags }: CheckPayload): Promise<AstroChecker | undefined>;
+export declare function check({ flags }: CheckPayload): Promise<AstroChecker | undefined>;
 type CheckerConstructor = {
     diagnosticChecker: AstroCheck;
     isWatchMode: boolean;
-    syncCli: (settings: AstroSettings, options: SyncOptions) => Promise<ProcessExit>;
+    syncInternal: typeof syncInternal;
     settings: Readonly<AstroSettings>;
     logging: Readonly<LogOptions>;
     fileSystem: typeof fs;
@@ -62,7 +57,7 @@ type CheckerConstructor = {
  */
 export declare class AstroChecker {
     #private;
-    constructor({ diagnosticChecker, isWatchMode, syncCli, settings, fileSystem, logging, }: CheckerConstructor);
+    constructor({ diagnosticChecker, isWatchMode, syncInternal, settings, fileSystem, logging, }: CheckerConstructor);
     /**
      * Check all `.astro` files once and then finishes the operation.
      */

package/dist/cli/check/index.js

@@ -9,9 +9,14 @@ import fs from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import ora from "ora";
+import { resolveConfig } from "../../core/config/config.js";
+import { createNodeLogging } from "../../core/config/logging.js";
+import { createSettings } from "../../core/config/settings.js";
 import { debug, info } from "../../core/logger/core.js";
 import { printHelp } from "../../core/messages.js";
-import { loadSettings } from "../load-settings.js";
+import { eventCliSession, telemetry } from "../../events/index.js";
+import { runHookConfigSetup } from "../../integrations/index.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
 import { printDiagnostic } from "./print.js";
 var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
   CheckResult2[CheckResult2["ExitWithSuccess"] = 0] = "ExitWithSuccess";
@@ -20,7 +25,7 @@ var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
   return CheckResult2;
 })(CheckResult || {});
 const ASTRO_GLOB_PATTERN = "**/*.astro";
-async function check({ logging, flags }) {
+async function check({ flags }) {
   if (flags.help || flags.h) {
     printHelp({
       commandName: "astro check",
@@ -35,16 +40,18 @@ async function check({ logging, flags }) {
     });
     return;
   }
-  const settings = await loadSettings({ cmd: "check", flags, logging });
-  if (!settings)
-    return;
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  const logging = createNodeLogging(inlineConfig);
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "check");
+  telemetry.record(eventCliSession("check", userConfig, flags));
+  const settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const checkFlags = parseFlags(flags);
   if (checkFlags.watch) {
     info(logging, "check", "Checking files in watch mode");
   } else {
     info(logging, "check", "Checking files");
   }
-  const { syncCli } = await import("../../core/sync/index.js");
+  const { syncInternal } = await import("../../core/sync/index.js");
   const root = settings.config.root;
   const require2 = createRequire(import.meta.url);
   const diagnosticChecker = new AstroCheck(
@@ -54,7 +61,7 @@ async function check({ logging, flags }) {
     })
   );
   return new AstroChecker({
-    syncCli,
+    syncInternal,
     settings,
     fileSystem: fs,
     logging,
@@ -65,7 +72,7 @@ async function check({ logging, flags }) {
 class AstroChecker {
   #diagnosticsChecker;
   #shouldWatch;
-  #syncCli;
+  #syncInternal;
   #settings;
   #logging;
   #fs;
@@ -75,14 +82,14 @@ class AstroChecker {
   constructor({
     diagnosticChecker,
     isWatchMode,
-    syncCli,
+    syncInternal,
     settings,
     fileSystem,
     logging
   }) {
     this.#diagnosticsChecker = diagnosticChecker;
     this.#shouldWatch = isWatchMode;
-    this.#syncCli = syncCli;
+    this.#syncInternal = syncInternal;
     this.#logging = logging;
     this.#settings = settings;
     this.#fs = fileSystem;
@@ -131,7 +138,12 @@ class AstroChecker {
    * @param openDocuments Whether the operation should open all `.astro` files
    */
   async #checkAllFiles(openDocuments) {
-    const processExit = await this.#syncCli(this.#settings, {
+    const syncSettings = await runHookConfigSetup({
+      settings: this.#settings,
+      logging: this.#logging,
+      command: "build"
+    });
+    const processExit = await this.#syncInternal(syncSettings, {
       logging: this.#logging,
       fs: this.#fs
     });

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import { type LogOptions } from '../../core/logger/core.js';
 interface DevOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function dev({ flags, logging }: DevOptions): Promise<import("../../core/dev/dev.js").DevServer | undefined>;
+export declare function dev({ flags }: DevOptions): Promise<import("../../core/dev/dev.js").DevServer | undefined>;
 export {};

package/dist/cli/dev/index.js

@@ -1,25 +1,29 @@
-import fs from "node:fs";
-import { resolveConfigPath, resolveFlags } from "../../core/config/index.js";
+import { cyan } from "kleur/colors";
 import devServer from "../../core/dev/index.js";
-import { info } from "../../core/logger/core.js";
-import { handleConfigError, loadSettings } from "../load-settings.js";
-async function dev({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "dev", flags, logging });
-  if (!settings)
+import { printHelp } from "../../core/messages.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function dev({ flags }) {
+  if (flags.help || flags.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;
-  const root = flags.root;
-  const configFlag = resolveFlags(flags).config;
-  const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags, fs }) : void 0;
-  return await devServer(settings, {
-    configFlag,
-    configFlagPath,
-    flags,
-    logging,
-    handleConfigError(e) {
-      handleConfigError(e, { cmd: "dev", cwd: root, flags, logging });
-      info(logging, "astro", "Continuing with previous valid configuration\n");
-    }
-  });
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  return await devServer(inlineConfig);
 }
 export {
   dev

package/dist/cli/flags.d.ts

@@ -0,0 +1,9 @@
+import type { Arguments as Flags } from 'yargs-parser';
+import type { AstroInlineConfig } from '../@types/astro.js';
+import type { LogOptions } from '../core/logger/core.js';
+export declare function flagsToAstroInlineConfig(flags: Flags): AstroInlineConfig;
+/**
+ * The `logging` is usually created from an `AstroInlineConfig`, but some flows like `add`
+ * doesn't read the AstroConfig directly, so we create a `logging` object from the CLI flags instead.
+ */
+export declare function createLoggingFromFlags(flags: Flags): LogOptions;

package/dist/cli/flags.js

@@ -0,0 +1,40 @@
+import { nodeLogDestination } from "../core/logger/node.js";
+function flagsToAstroInlineConfig(flags) {
+  return {
+    // Inline-only configs
+    configFile: typeof flags.config === "string" ? flags.config : void 0,
+    mode: typeof flags.mode === "string" ? flags.mode : void 0,
+    logLevel: flags.verbose ? "debug" : flags.silent ? "silent" : void 0,
+    // Astro user configs
+    root: typeof flags.root === "string" ? flags.root : void 0,
+    site: typeof flags.site === "string" ? flags.site : void 0,
+    base: typeof flags.base === "string" ? flags.base : void 0,
+    markdown: {
+      drafts: typeof flags.drafts === "boolean" ? flags.drafts : void 0
+    },
+    server: {
+      port: typeof flags.port === "number" ? flags.port : void 0,
+      host: typeof flags.host === "string" || typeof flags.host === "boolean" ? flags.host : void 0,
+      open: typeof flags.open === "boolean" ? flags.open : void 0
+    },
+    experimental: {
+      assets: typeof flags.experimentalAssets === "boolean" ? flags.experimentalAssets : void 0
+    }
+  };
+}
+function createLoggingFromFlags(flags) {
+  const logging = {
+    dest: nodeLogDestination,
+    level: "info"
+  };
+  if (flags.verbose) {
+    logging.level = "debug";
+  } else if (flags.silent) {
+    logging.level = "silent";
+  }
+  return logging;
+}
+export {
+  createLoggingFromFlags,
+  flagsToAstroInlineConfig
+};

package/dist/cli/index.js

@@ -82,16 +82,9 @@ async function runCommand(cmd, flags) {
       return;
     }
   }
-  const { enableVerboseLogging, nodeLogDestination } = await import("../core/logger/node.js");
-  const logging = {
-    dest: nodeLogDestination,
-    level: "info"
-  };
   if (flags.verbose) {
-    logging.level = "debug";
+    const { enableVerboseLogging } = await import("../core/logger/node.js");
     enableVerboseLogging();
-  } else if (flags.silent) {
-    logging.level = "silent";
   }
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = cmd === "dev" ? "development" : "production";
@@ -100,12 +93,12 @@ async function runCommand(cmd, flags) {
     case "add": {
       const { add } = await import("./add/index.js");
       const packages = flags._.slice(3);
-      await add(packages, { flags, logging });
+      await add(packages, { flags });
       return;
     }
     case "dev": {
       const { dev } = await import("./dev/index.js");
-      const server = await dev({ flags, logging });
+      const server = await dev({ flags });
       if (server) {
         return await new Promise(() => {
         });
@@ -114,12 +107,12 @@ async function runCommand(cmd, flags) {
     }
     case "build": {
       const { build } = await import("./build/index.js");
-      await build({ flags, logging });
+      await build({ flags });
       return;
     }
     case "preview": {
       const { preview } = await import("./preview/index.js");
-      const server = await preview({ flags, logging });
+      const server = await preview({ flags });
       if (server) {
         return await server.closed();
       }
@@ -127,7 +120,7 @@ async function runCommand(cmd, flags) {
     }
     case "check": {
       const { check } = await import("./check/index.js");
-      const checkServer = await check({ flags, logging });
+      const checkServer = await check({ flags });
       if (checkServer) {
         if (checkServer.isWatchMode) {
           await checkServer.watch();
@@ -142,7 +135,7 @@ async function runCommand(cmd, flags) {
     }
     case "sync": {
       const { sync } = await import("./sync/index.js");
-      const exitCode = await sync({ flags, logging });
+      const exitCode = await sync({ flags });
       return process.exit(exitCode);
     }
   }

package/dist/cli/info/index.js

@@ -1,10 +1,12 @@
 import * as colors from "kleur/colors";
 import { arch, platform } from "node:os";
 import whichPm from "which-pm";
-import { openConfig } from "../../core/config/index.js";
+import { resolveConfig } from "../../core/config/index.js";
 import { ASTRO_VERSION } from "../../core/constants.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
 async function printInfo({ flags }) {
   var _a;
+  const inlineConfig = flagsToAstroInlineConfig(flags);
   const packageManager = await whichPm(process.cwd());
   let adapter = "Couldn't determine.";
   let integrations = [];
@@ -14,11 +16,7 @@ async function printInfo({ flags }) {
     console.log(`${colors.bold(label)}` + " ".repeat(padding) + `${colors.green(value)}`);
   }
   try {
-    const { userConfig } = await openConfig({
-      cwd: flags.root,
-      flags,
-      cmd: "info"
-    });
+    const { userConfig } = await resolveConfig(inlineConfig, "info");
     if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
       adapter = userConfig.adapter.name;
     }

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import type { LogOptions } from '../../core/logger/core.js';
 interface PreviewOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function preview({ flags, logging }: PreviewOptions): Promise<import("../../@types/astro.js").PreviewServer | undefined>;
+export declare function preview({ flags }: PreviewOptions): Promise<import("../../@types/astro.js").PreviewServer | undefined>;
 export {};

package/dist/cli/preview/index.js

@@ -1,10 +1,26 @@
+import { cyan } from "kleur/colors";
+import { printHelp } from "../../core/messages.js";
 import previewServer from "../../core/preview/index.js";
-import { loadSettings } from "../load-settings.js";
-async function preview({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "preview", flags, logging });
-  if (!settings)
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function preview({ 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;
-  return await previewServer(settings, { flags, logging });
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  return await previewServer(inlineConfig);
 }
 export {
   preview