astro 1.1.6 → 1.2.0

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, RemarkRehype, ShikiConfig } from '@astrojs/markdown-remark';
 import type * as babel from '@babel/core';
 import type { AddressInfo } from 'net';
@@ -843,7 +844,7 @@ export interface MarkdownInstance<T extends Record<string, any>> {
     getHeaders(): void;
     default: AstroComponentFactory;
 }
-export interface MDXInstance<T> extends Omit<MarkdownInstance<T>, 'rawContent' | 'compiledContent'> {
+export interface MDXInstance<T extends Record<string, any>> extends Omit<MarkdownInstance<T>, 'rawContent' | 'compiledContent'> {
     /** MDX does not support rawContent! If you need to read the Markdown contents to calculate values (ex. reading time), we suggest injecting frontmatter via remark plugins. Learn more on our docs: https://docs.astro.build/en/guides/integrations-guide/mdx/#inject-frontmatter-via-remark-or-rehype-plugins */
     rawContent: never;
     /** MDX does not support compiledContent! If you need to read the HTML contents to calculate values (ex. reading time), we suggest injecting frontmatter via rehype plugins. Learn more on our docs: https://docs.astro.build/en/guides/integrations-guide/mdx/#inject-frontmatter-via-remark-or-rehype-plugins */
@@ -860,7 +861,7 @@ export interface MarkdownLayoutProps<T extends Record<string, any>> {
     rawContent: MarkdownInstance<T>['rawContent'];
     compiledContent: MarkdownInstance<T>['compiledContent'];
 }
-export declare type MDXLayoutProps<T> = Omit<MarkdownLayoutProps<T>, 'rawContent' | 'compiledContent'>;
+export declare type MDXLayoutProps<T extends Record<string, any>> = Omit<MarkdownLayoutProps<T>, 'rawContent' | 'compiledContent'>;
 export declare type GetHydrateCallback = () => Promise<() => void | Promise<void>>;
 /**
  * getStaticPaths() options
@@ -974,6 +975,7 @@ export interface APIContext {
 }
 export interface EndpointOutput {
     body: Body;
+    encoding?: BufferEncoding;
 }
 export declare type APIRoute = (context: APIContext) => EndpointOutput | Response | Promise<EndpointOutput | Response>;
 export interface EndpointHandler {

package/dist/cli/index.js

@@ -1,14 +1,17 @@
 import * as colors from "kleur/colors";
+import { pathToFileURL } from "url";
+import { normalizePath } from "vite";
 import yargs from "yargs-parser";
 import { z } from "zod";
 import add from "../core/add/index.js";
 import build from "../core/build/index.js";
-import { openConfig } from "../core/config.js";
+import { openConfig, resolveConfigPath, resolveFlags, resolveRoot } from "../core/config.js";
 import devServer from "../core/dev/index.js";
 import { collectErrorMetadata } from "../core/errors.js";
-import { debug, info, warn } from "../core/logger/core.js";
+import { debug, error, info } from "../core/logger/core.js";
 import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js";
 import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
+import { appendForwardSlash } from "../core/path.js";
 import preview from "../core/preview/index.js";
 import { ASTRO_VERSION, createSafeError } from "../core/util.js";
 import * as event from "../events/index.js";
@@ -62,6 +65,18 @@ function resolveCommand(flags) {
   }
   return "help";
 }
+async function handleConfigError(e, { cwd, flags, logging }) {
+  const path = await resolveConfigPath({ cwd, flags });
+  if (e instanceof Error) {
+    if (path) {
+      error(logging, "astro", `Unable to load ${colors.bold(path)}
+`);
+    }
+    console.error(
+      formatErrorMessage(collectErrorMetadata(e, path ? pathToFileURL(path) : void 0)) + "\n"
+    );
+  }
+}
 async function runCommand(cmd, flags) {
   var _a;
   const root = flags.root;
@@ -98,39 +113,57 @@ async function runCommand(cmd, flags) {
       return await telemetryHandler.update(subcommand, { flags, telemetry });
     }
   }
-  let { astroConfig, userConfig, userConfigPath } = await openConfig({
+  let { astroConfig, userConfig } = await openConfig({
     cwd: root,
     flags,
     cmd,
     logging
+  }).catch(async (e) => {
+    await handleConfigError(e, { cwd: root, flags, logging });
+    return {};
   });
+  if (!astroConfig)
+    return;
   telemetry.record(event.eventCliSession(cmd, userConfig, flags));
   switch (cmd) {
     case "dev": {
-      async function startDevServer() {
-        const { watcher, stop } = await devServer(astroConfig, { logging, telemetry });
-        watcher.on("change", logRestartServerOnConfigChange);
-        watcher.on("unlink", logRestartServerOnConfigChange);
-        function logRestartServerOnConfigChange(changedFile) {
-          if (userConfigPath === changedFile) {
-            warn(logging, "astro", "Astro config updated. Restart server to see changes!");
-          }
-        }
-        watcher.on("add", async function restartServerOnNewConfigFile(addedFile) {
-          if (!userConfigPath && addedFile.includes("astro.config")) {
-            const addedConfig = await openConfig({ cwd: root, flags, cmd, logging });
-            if (addedConfig.userConfigPath) {
-              info(logging, "astro", "Astro config detected. Restarting server...");
-              astroConfig = addedConfig.astroConfig;
-              userConfig = addedConfig.userConfig;
-              userConfigPath = addedConfig.userConfigPath;
+      async function startDevServer({ isRestart = false } = {}) {
+        const { watcher, stop } = await devServer(astroConfig, { logging, telemetry, isRestart });
+        let restartInFlight = false;
+        const configFlag = resolveFlags(flags).config;
+        const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
+        const resolvedRoot = appendForwardSlash(resolveRoot(root));
+        const handleServerRestart = (logMsg) => async function(changedFile) {
+          if (!restartInFlight && (configFlag ? configFlagPath && normalizePath(configFlagPath) === normalizePath(changedFile) : new RegExp(
+            `${normalizePath(resolvedRoot)}.*astro.config.((mjs)|(cjs)|(js)|(ts))$`
+          ).test(normalizePath(changedFile)))) {
+            restartInFlight = true;
+            console.clear();
+            try {
+              const newConfig = await openConfig({
+                cwd: root,
+                flags,
+                cmd,
+                logging,
+                isConfigReload: true
+              });
+              info(logging, "astro", logMsg + "\n");
+              astroConfig = newConfig.astroConfig;
+              await stop();
+              await startDevServer({ isRestart: true });
+            } catch (e) {
+              await handleConfigError(e, { cwd: root, flags, logging });
               await stop();
-              await startDevServer();
+              info(logging, "astro", "Continuing with previous valid configuration\n");
+              await startDevServer({ isRestart: true });
             }
           }
-        });
+        };
+        watcher.on("change", handleServerRestart("Configuration updated. Restarting..."));
+        watcher.on("unlink", handleServerRestart("Configuration removed. Restarting..."));
+        watcher.on("add", handleServerRestart("Configuration added. Restarting..."));
       }
-      await startDevServer();
+      await startDevServer({ isRestart: false });
       return await new Promise(() => {
       });
     }

package/dist/core/add/index.js

@@ -8,7 +8,7 @@ import path from "path";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { fileURLToPath, pathToFileURL } from "url";
-import { resolveConfigURL } from "../config.js";
+import { resolveConfigPath } from "../config.js";
 import { debug, info } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { printHelp } from "../messages.js";
@@ -80,15 +80,73 @@ async function add(names, { cwd, flags, logging, telemetry }) {
     });
     return;
   }
-  let configURL;
+  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());
-  configURL = await resolveConfigURL({ cwd, flags });
+  root.href = appendForwardSlash(root.href);
+  switch (installResult) {
+    case UpdateResult.updated: {
+      if (integrations.find((integration) => integration.id === "tailwind")) {
+        const possibleConfigFiles = [
+          "./tailwind.config.cjs",
+          "./tailwind.config.mjs",
+          "./tailwind.config.js"
+        ].map((p) => fileURLToPath(new URL(p, root)));
+        let alreadyConfigured = false;
+        for (const possibleConfigPath of possibleConfigFiles) {
+          if (existsSync(possibleConfigPath)) {
+            alreadyConfigured = true;
+            break;
+          }
+        }
+        if (!alreadyConfigured) {
+          info(
+            logging,
+            null,
+            `
+  ${magenta(
+              `Astro will generate a minimal ${bold("./tailwind.config.cjs")} file.`
+            )}
+`
+          );
+          if (await askToContinue({ flags })) {
+            await fs.writeFile(
+              fileURLToPath(new URL("./tailwind.config.cjs", root)),
+              TAILWIND_CONFIG_STUB,
+              { encoding: "utf-8" }
+            );
+            debug("add", `Generated default ./tailwind.config.cjs file`);
+          }
+        } else {
+          debug("add", `Using existing Tailwind configuration`);
+        }
+      }
+      break;
+    }
+    case UpdateResult.cancelled: {
+      info(
+        logging,
+        null,
+        msg.cancelled(
+          `Dependencies ${bold("NOT")} installed.`,
+          `Be sure to install them manually before continuing!`
+        )
+      );
+      break;
+    }
+    case UpdateResult.failure: {
+      throw createPrettyError(new Error(`Unable to install dependencies`));
+    }
+  }
+  const rawConfigPath = await resolveConfigPath({ cwd, flags });
+  let configURL = rawConfigPath ? pathToFileURL(rawConfigPath) : void 0;
   applyPolyfill();
   if (configURL) {
     debug("add", `Found config at ${configURL}`);
   } else {
     info(logging, "add", `Unable to locate a config file, generating one for you.`);
-    configURL = new URL("./astro.config.mjs", appendForwardSlash(root.href));
+    configURL = new URL("./astro.config.mjs", root);
     await fs.writeFile(fileURLToPath(configURL), ASTRO_CONFIG_STUB, { encoding: "utf-8" });
   }
   if (configURL == null ? void 0 : configURL.pathname.endsWith("package.json")) {
@@ -96,8 +154,6 @@ async function add(names, { cwd, flags, logging, telemetry }) {
       `Unable to use "astro add" with package.json configuration. Try migrating to \`astro.config.mjs\` and try again.`
     );
   }
-  const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
-  const integrations = await validateIntegrations(integrationNames);
   let ast = null;
   try {
     ast = await parseAstroConfig(configURL);
@@ -139,7 +195,6 @@ async function add(names, { cwd, flags, logging, telemetry }) {
     throw createPrettyError(err);
   }
   let configResult;
-  let installResult;
   if (ast) {
     try {
       configResult = await updateAstroConfig({
@@ -173,72 +228,18 @@ async function add(names, { cwd, flags, logging, telemetry }) {
         }
       }
       info(logging, null, msg.success(`Configuration up-to-date.`));
-      break;
+      return;
     }
-  }
-  installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logging });
-  switch (installResult) {
-    case UpdateResult.updated: {
-      const len = integrations.length;
-      if (integrations.find((integration) => integration.id === "tailwind")) {
-        const possibleConfigFiles = [
-          "./tailwind.config.cjs",
-          "./tailwind.config.mjs",
-          "./tailwind.config.js"
-        ].map((p) => fileURLToPath(new URL(p, configURL)));
-        let alreadyConfigured = false;
-        for (const possibleConfigPath of possibleConfigFiles) {
-          if (existsSync(possibleConfigPath)) {
-            alreadyConfigured = true;
-            break;
-          }
-        }
-        if (!alreadyConfigured) {
-          info(
-            logging,
-            null,
-            `
-  ${magenta(
-              `Astro will generate a minimal ${bold("./tailwind.config.cjs")} file.`
-            )}
-`
-          );
-          if (await askToContinue({ flags })) {
-            await fs.writeFile(
-              fileURLToPath(new URL("./tailwind.config.cjs", configURL)),
-              TAILWIND_CONFIG_STUB,
-              { encoding: "utf-8" }
-            );
-            debug("add", `Generated default ./tailwind.config.cjs file`);
-          }
-        } else {
-          debug("add", `Using existing Tailwind configuration`);
-        }
-      }
+    default: {
       const list = integrations.map((integration) => `  - ${integration.packageName}`).join("\n");
       info(
         logging,
         null,
         msg.success(
-          `Added the following integration${len === 1 ? "" : "s"} to your project:
+          `Added the following integration${integrations.length === 1 ? "" : "s"} to your project:
 ${list}`
         )
       );
-      return;
-    }
-    case UpdateResult.cancelled: {
-      info(
-        logging,
-        null,
-        msg.cancelled(
-          `Dependencies ${bold("NOT")} installed.`,
-          `Be sure to install them manually before continuing!`
-        )
-      );
-      return;
-    }
-    case UpdateResult.failure: {
-      throw createPrettyError(new Error(`Unable to install dependencies`));
     }
   }
 }
@@ -459,11 +460,11 @@ async function getInstallIntegrationsCommand({
   ).sort();
   switch (pm.name) {
     case "npm":
-      return { pm: "npm", command: "install", flags: ["--save-dev"], dependencies };
+      return { pm: "npm", command: "install", flags: [], dependencies };
     case "yarn":
-      return { pm: "yarn", command: "add", flags: ["--dev"], dependencies };
+      return { pm: "yarn", command: "add", flags: [], dependencies };
     case "pnpm":
-      return { pm: "pnpm", command: "install", flags: ["--save-dev"], dependencies };
+      return { pm: "pnpm", command: "install", flags: [], dependencies };
     default:
       return null;
   }
@@ -478,7 +479,10 @@ async function tryToInstallIntegrations({
   if (installCommand === null) {
     return 0 /* none */;
   } else {
-    const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command} ${installCommand.flags.join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
+    const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
+      "",
+      ...installCommand.flags
+    ].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
     const message = `
 ${boxen(coloredOutput, {
       margin: 0.5,

package/dist/core/build/generate.js

@@ -260,12 +260,14 @@ async function generatePath(pathname, opts, gopts) {
     streaming: true
   };
   let body;
+  let encoding;
   if (pageData.route.type === "endpoint") {
     const result = await callEndpoint(mod, options);
     if (result.type === "response") {
       throw new Error(`Returning a Response from an endpoint is not supported in SSG mode.`);
     }
     body = result.body;
+    encoding = result.encoding;
   } else {
     const response = await render(options);
     if (response.status !== 200 || !response.body) {
@@ -277,7 +279,7 @@ async function generatePath(pathname, opts, gopts) {
   const outFile = getOutFile(astroConfig, outFolder, pathname, pageData.route.type);
   pageData.route.distURL = outFile;
   await fs.promises.mkdir(outFolder, { recursive: true });
-  await fs.promises.writeFile(outFile, body, "utf-8");
+  await fs.promises.writeFile(outFile, body, encoding ?? "utf-8");
 }
 export {
   chunkIsPage,

package/dist/core/build/vite-plugin-analyzer.js

@@ -55,7 +55,7 @@ function vitePluginAnalyzer(internals) {
   }
   return {
     name: "@astro/rollup-plugin-astro-analyzer",
-    generateBundle() {
+    async generateBundle() {
       var _a;
       const hoistScanner = hoistedScriptScanner();
       const ids = this.getModuleIds();
@@ -75,6 +75,12 @@ function vitePluginAnalyzer(internals) {
             const cid = c.resolvedPath ? decodeURI(c.resolvedPath) : c.specifier;
             internals.discoveredClientOnlyComponents.add(cid);
             clientOnlys.push(cid);
+            if (c.resolvedPath === c.specifier) {
+              const resolvedId = await this.resolve(c.specifier, id);
+              if (resolvedId) {
+                clientOnlys.push(resolvedId.id);
+              }
+            }
           }
           for (const [pageInfo] of getTopLevelPages(id, this)) {
             const pageData = getPageDataByViteID(internals, pageInfo.id);

package/dist/{vite-plugin-astro → core/compile}/compile.d.ts

@@ -1,8 +1,6 @@
 import type { TransformResult } from '@astrojs/compiler';
-import type { PluginContext } from 'rollup';
-import type { ViteDevServer } from 'vite';
-import type { AstroConfig } from '../@types/astro';
-import type { TransformStyleWithVite } from './styles';
+import type { AstroConfig } from '../../@types/astro';
+import type { TransformStyle } from './types';
 declare type CompileResult = TransformResult & {
     cssDeps: Set<string>;
     source: string;
@@ -12,10 +10,7 @@ export interface CompileProps {
     filename: string;
     moduleId: string;
     source: string;
-    ssr: boolean;
-    transformStyleWithVite: TransformStyleWithVite;
-    viteDevServer?: ViteDevServer;
-    pluginContext: PluginContext;
+    transformStyle: TransformStyle;
 }
 export declare function isCached(config: AstroConfig, filename: string): boolean;
 export declare function getCachedSource(config: AstroConfig, filename: string): string | null;

package/dist/{vite-plugin-astro → core/compile}/compile.js

@@ -1,35 +1,19 @@
 import { transform } from "@astrojs/compiler";
-import { fileURLToPath } from "url";
-import { AstroErrorCodes } from "../core/errors.js";
-import { prependForwardSlash } from "../core/path.js";
-import { viteID } from "../core/util.js";
+import { AstroErrorCodes } from "../errors.js";
+import { prependForwardSlash } from "../path.js";
+import { AggregateError, viteID } from "../util.js";
+import { createStylePreprocessor } from "./style.js";
 const configCache = /* @__PURE__ */ new WeakMap();
-function getNormalizedID(filename) {
-  try {
-    const filenameURL = new URL(`file://${filename}`);
-    return fileURLToPath(filenameURL);
-  } catch (err) {
-    return filename;
-  }
-}
 async function compile({
   config,
   filename,
   moduleId,
   source,
-  ssr,
-  transformStyleWithVite,
-  viteDevServer,
-  pluginContext
+  transformStyle
 }) {
   var _a;
-  const normalizedID = getNormalizedID(filename);
   let cssDeps = /* @__PURE__ */ new Set();
-  let cssTransformError;
-  if (!pluginContext.addWatchFile) {
-    pluginContext.addWatchFile = () => {
-    };
-  }
+  let cssTransformErrors = [];
   const transformResult = await transform(source, {
     pathname: `/@fs${prependForwardSlash(moduleId)}`,
     projectRoot: config.root.toString(),
@@ -37,47 +21,30 @@ async function compile({
     sourcefile: filename,
     sourcemap: "both",
     internalURL: `/@fs${prependForwardSlash(
-      viteID(new URL("../runtime/server/index.js", import.meta.url))
+      viteID(new URL("../../runtime/server/index.js", import.meta.url))
     )}`,
     experimentalStaticExtraction: true,
-    preprocessStyle: async (value, attrs) => {
-      const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
-      try {
-        const result = await transformStyleWithVite.call(pluginContext, {
-          id: normalizedID,
-          source: value,
-          lang,
-          ssr,
-          viteDevServer
-        });
-        if (!result)
-          return null;
-        for (const dep of result.deps) {
-          cssDeps.add(dep);
-        }
-        let map;
-        if (result.map) {
-          if (typeof result.map === "string") {
-            map = result.map;
-          } else if (result.map.mappings) {
-            map = result.map.toString();
-          }
-        }
-        return { code: result.code, map };
-      } catch (err) {
-        cssTransformError = err;
-        return null;
-      }
-    }
+    preprocessStyle: createStylePreprocessor(transformStyle, cssDeps, cssTransformErrors)
   }).catch((err) => {
     err.code = err.code || AstroErrorCodes.UnknownCompilerError;
     throw err;
   }).then((result) => {
-    if (cssTransformError) {
-      cssTransformError.code = cssTransformError.code || AstroErrorCodes.UnknownCompilerCSSError;
-      throw cssTransformError;
+    switch (cssTransformErrors.length) {
+      case 0:
+        return result;
+      case 1: {
+        let error = cssTransformErrors[0];
+        if (!error.code) {
+          error.code = AstroErrorCodes.UnknownCompilerCSSError;
+        }
+        throw cssTransformErrors[0];
+      }
+      default: {
+        const aggregateError = new AggregateError(cssTransformErrors);
+        aggregateError.code = AstroErrorCodes.UnknownCompilerCSSError;
+        throw aggregateError;
+      }
     }
-    return result;
   });
   const compileResult = Object.create(transformResult, {
     cssDeps: {

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

@@ -0,0 +1,3 @@
+export type { CompileProps } from './compile';
+export { cachedCompilation, getCachedSource, invalidateCompilation, isCached } from './compile.js';
+export type { TransformStyle } from './types';

package/dist/core/compile/index.js

@@ -0,0 +1,7 @@
+import { cachedCompilation, getCachedSource, invalidateCompilation, isCached } from "./compile.js";
+export {
+  cachedCompilation,
+  getCachedSource,
+  invalidateCompilation,
+  isCached
+};

package/dist/core/compile/style.d.ts

@@ -0,0 +1,5 @@
+import type { TransformOptions } from '@astrojs/compiler';
+import type { TransformStyle } from './types';
+declare type PreprocessStyle = TransformOptions['preprocessStyle'];
+export declare function createStylePreprocessor(transformStyle: TransformStyle, cssDeps: Set<string>, errors: Error[]): PreprocessStyle;
+export {};

package/dist/core/compile/style.js

@@ -0,0 +1,31 @@
+function createStylePreprocessor(transformStyle, cssDeps, errors) {
+  const preprocessStyle = async (value, attrs) => {
+    const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
+    try {
+      const result = await transformStyle(value, lang);
+      if (!result)
+        return null;
+      for (const dep of result.deps) {
+        cssDeps.add(dep);
+      }
+      let map;
+      if (result.map) {
+        if (typeof result.map === "string") {
+          map = result.map;
+        } else if (result.map.mappings) {
+          map = result.map.toString();
+        }
+      }
+      return { code: result.code, map };
+    } catch (err) {
+      errors.push(err);
+      return {
+        error: err + ""
+      };
+    }
+  };
+  return preprocessStyle;
+}
+export {
+  createStylePreprocessor
+};

package/dist/core/compile/types.d.ts

@@ -0,0 +1,7 @@
+import type { SourceMap } from 'rollup';
+export declare type TransformStyleResult = null | {
+    code: string;
+    map: SourceMap | null;
+    deps: Set<string>;
+};
+export declare type TransformStyle = (source: string, lang: string) => TransformStyleResult | Promise<TransformStyleResult>;

package/dist/core/config.d.ts

@@ -235,22 +235,26 @@ export declare const AstroConfigSchema: z.ZodObject<{
 }>;
 /** Turn raw config values into normalized values */
 export declare function validateConfig(userConfig: any, root: string, cmd: string, logging: LogOptions): 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): string;
 interface LoadConfigOptions {
     cwd?: string;
     flags?: Flags;
     cmd: string;
     validate?: boolean;
     logging: LogOptions;
+    /** Invalidate when reloading a previously loaded config */
+    isConfigReload?: boolean;
 }
 /**
  * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file
  * Note: currently the same as loadConfig but only returns the `filePath`
  * instead of the resolved config
  */
-export declare function resolveConfigURL(configOptions: Pick<LoadConfigOptions, 'cwd' | 'flags'>): Promise<URL | undefined>;
+export declare function resolveConfigPath(configOptions: Pick<LoadConfigOptions, 'cwd' | 'flags'>): Promise<string | undefined>;
 interface OpenConfigResult {
     userConfig: AstroUserConfig;
-    userConfigPath: string | undefined;
     astroConfig: AstroConfig;
     flags: CLIFlags;
     root: string;