astro 1.2.5 → 1.2.7

package/dist/core/config/tsconfig.js

@@ -0,0 +1,13 @@
+import * as tsr from "tsconfig-resolver";
+function loadTSConfig(cwd) {
+  for (const searchName of ["tsconfig.json", "jsconfig.json"]) {
+    const config = tsr.tsconfigResolverSync({ cwd, searchName });
+    if (config.exists) {
+      return config;
+    }
+  }
+  return void 0;
+}
+export {
+  loadTSConfig
+};

package/dist/core/create-vite.d.ts

@@ -1,14 +1,14 @@
-import type { AstroConfig } from '../@types/astro';
+import type { AstroSettings } from '../@types/astro';
 import type { LogOptions } from './logger/core';
 import * as vite from 'vite';
 export declare type ViteConfigWithSSR = vite.InlineConfig & {
     ssr?: vite.SSROptions;
 };
 interface CreateViteOptions {
-    astroConfig: AstroConfig;
+    settings: AstroSettings;
     logging: LogOptions;
     mode: 'dev' | 'build' | string;
 }
 /** Return a common starting point for all Vite actions */
-export declare function createVite(commandConfig: ViteConfigWithSSR, { astroConfig, logging, mode }: CreateViteOptions): Promise<ViteConfigWithSSR>;
+export declare function createVite(commandConfig: ViteConfigWithSSR, { settings, logging, mode }: CreateViteOptions): Promise<ViteConfigWithSSR>;
 export {};

package/dist/core/create-vite.js

@@ -34,10 +34,10 @@ function getSsrNoExternalDeps(projectRoot) {
   }
   return noExternalDeps;
 }
-async function createVite(commandConfig, { astroConfig, logging, mode }) {
-  const thirdPartyAstroPackages = await getAstroPackages(astroConfig);
+async function createVite(commandConfig, { settings, logging, mode }) {
+  const thirdPartyAstroPackages = await getAstroPackages(settings);
   const commonConfig = {
-    cacheDir: fileURLToPath(new URL("./node_modules/.vite/", astroConfig.root)),
+    cacheDir: fileURLToPath(new URL("./node_modules/.vite/", settings.config.root)),
     clearScreen: false,
     logLevel: "warn",
     appType: "custom",
@@ -46,23 +46,23 @@ async function createVite(commandConfig, { astroConfig, logging, mode }) {
       exclude: ["node-fetch"]
     },
     plugins: [
-      configAliasVitePlugin({ config: astroConfig }),
-      astroVitePlugin({ config: astroConfig, logging }),
-      astroScriptsPlugin({ config: astroConfig }),
-      mode !== "build" && astroViteServerPlugin({ config: astroConfig, logging }),
-      envVitePlugin({ config: astroConfig }),
-      astroConfig.legacy.astroFlavoredMarkdown ? legacyMarkdownVitePlugin({ config: astroConfig, logging }) : markdownVitePlugin({ config: astroConfig, logging }),
+      configAliasVitePlugin({ settings }),
+      astroVitePlugin({ settings, logging }),
+      astroScriptsPlugin({ settings }),
+      mode !== "build" && astroViteServerPlugin({ settings, logging }),
+      envVitePlugin({ settings }),
+      settings.config.legacy.astroFlavoredMarkdown ? legacyMarkdownVitePlugin({ settings, logging }) : markdownVitePlugin({ settings, logging }),
       htmlVitePlugin(),
-      jsxVitePlugin({ config: astroConfig, logging }),
-      astroPostprocessVitePlugin({ config: astroConfig }),
-      astroIntegrationsContainerPlugin({ config: astroConfig, logging }),
-      astroScriptsPageSSRPlugin({ config: astroConfig })
+      jsxVitePlugin({ settings, logging }),
+      astroPostprocessVitePlugin({ settings }),
+      astroIntegrationsContainerPlugin({ settings, logging }),
+      astroScriptsPageSSRPlugin({ settings })
     ],
-    publicDir: fileURLToPath(astroConfig.publicDir),
-    root: fileURLToPath(astroConfig.root),
+    publicDir: fileURLToPath(settings.config.publicDir),
+    root: fileURLToPath(settings.config.root),
     envPrefix: "PUBLIC_",
     define: {
-      "import.meta.env.SITE": astroConfig.site ? `'${astroConfig.site}'` : "undefined"
+      "import.meta.env.SITE": settings.config.site ? `'${settings.config.site}'` : "undefined"
     },
     server: {
       hmr: process.env.NODE_ENV === "test" || process.env.NODE_ENV === "production" ? false : void 0,
@@ -72,7 +72,7 @@ async function createVite(commandConfig, { astroConfig, logging, mode }) {
       }
     },
     css: {
-      postcss: astroConfig.style.postcss || {}
+      postcss: settings.config.style.postcss || {}
     },
     resolve: {
       alias: [
@@ -88,11 +88,11 @@ async function createVite(commandConfig, { astroConfig, logging, mode }) {
       conditions: ["astro"]
     },
     ssr: {
-      noExternal: [...getSsrNoExternalDeps(astroConfig.root), ...thirdPartyAstroPackages]
+      noExternal: [...getSsrNoExternalDeps(settings.config.root), ...thirdPartyAstroPackages]
     }
   };
   let result = commonConfig;
-  result = vite.mergeConfig(result, astroConfig.vite || {});
+  result = vite.mergeConfig(result, settings.config.vite || {});
   result = vite.mergeConfig(result, commandConfig);
   if (result.plugins) {
     sortPlugins(result.plugins);
@@ -117,8 +117,8 @@ function sortPlugins(pluginOptions) {
   pluginOptions.splice(mdxPluginIndex, 1);
   pluginOptions.splice(jsxPluginIndex, 0, mdxPlugin);
 }
-async function getAstroPackages({ root }) {
-  const { astroPackages } = new DependencyWalker(root);
+async function getAstroPackages(settings) {
+  const { astroPackages } = new DependencyWalker(settings.config.root);
   return astroPackages;
 }
 class DependencyWalker {

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

@@ -2,7 +2,7 @@
 import type { AstroTelemetry } from '@astrojs/telemetry';
 import type { AddressInfo } from 'net';
 import * as vite from 'vite';
-import type { AstroConfig } from '../../@types/astro';
+import type { AstroSettings } from '../../@types/astro';
 import { LogOptions } from '../logger/core.js';
 export interface DevOptions {
     logging: LogOptions;
@@ -15,4 +15,4 @@ export interface DevServer {
     stop(): Promise<void>;
 }
 /** `astro dev` */
-export default function dev(config: AstroConfig, options: DevOptions): Promise<DevServer>;
+export default function dev(settings: AstroSettings, options: DevOptions): Promise<DevServer>;

package/dist/core/dev/index.js

@@ -11,15 +11,15 @@ import { createVite } from "../create-vite.js";
 import { info, warn } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { apply as applyPolyfill } from "../polyfill.js";
-async function dev(config, options) {
+async function dev(settings, options) {
   var _a, _b, _c;
   const devStart = performance.now();
   applyPolyfill();
   await options.telemetry.record([]);
-  config = await runHookConfigSetup({ config, command: "dev", logging: options.logging });
-  const { host, port } = config.server;
+  settings = await runHookConfigSetup({ settings, command: "dev", logging: options.logging });
+  const { host, port } = settings.config.server;
   const { isRestart = false } = options;
-  const rendererClientEntries = config._ctx.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
+  const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
   const viteConfig = await createVite(
     {
       mode: "development",
@@ -28,34 +28,38 @@ async function dev(config, options) {
         include: rendererClientEntries
       }
     },
-    { astroConfig: config, logging: options.logging, mode: "dev" }
+    { settings, logging: options.logging, mode: "dev" }
   );
-  await runHookConfigDone({ config, logging: options.logging });
+  await runHookConfigDone({ settings, logging: options.logging });
   const viteServer = await vite.createServer(viteConfig);
-  runHookServerSetup({ config, server: viteServer, logging: options.logging });
+  runHookServerSetup({ config: settings.config, server: viteServer, logging: options.logging });
   await viteServer.listen(port);
   const devServerAddressInfo = viteServer.httpServer.address();
-  const site = config.site ? new URL(config.base, config.site) : void 0;
+  const site = settings.config.site ? new URL(settings.config.base, settings.config.site) : void 0;
   info(
     options.logging,
     null,
     msg.devStart({
       startupTime: performance.now() - devStart,
-      config,
+      config: settings.config,
       devServerAddressInfo,
       site,
       https: !!((_a = viteConfig.server) == null ? void 0 : _a.https),
       isRestart
     })
   );
-  const currentVersion = "1.2.5";
+  const currentVersion = "1.2.7";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }
   if (((_c = (_b = viteConfig.server) == null ? void 0 : _b.fs) == null ? void 0 : _c.strict) === false) {
     warn(options.logging, null, msg.fsStrictWarning());
   }
-  await runHookServerStart({ config, address: devServerAddressInfo, logging: options.logging });
+  await runHookServerStart({
+    config: settings.config,
+    address: devServerAddressInfo,
+    logging: options.logging
+  });
   return {
     address: devServerAddressInfo,
     get watcher() {
@@ -63,7 +67,7 @@ async function dev(config, options) {
     },
     stop: async () => {
       await viteServer.close();
-      await runHookServerDone({ config, logging: options.logging });
+      await runHookServerDone({ config: settings.config, logging: options.logging });
     }
   };
 }

package/dist/core/endpoint/dev/index.js

@@ -4,7 +4,7 @@ async function call(ssrOpts) {
   const [, mod] = await preload(ssrOpts);
   return await callEndpoint(mod, {
     ...ssrOpts,
-    ssr: ssrOpts.astroConfig.output === "server"
+    ssr: ssrOpts.settings.config.output === "server"
   });
 }
 export {

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function devStart({
   site,
   isRestart = false
 }) {
-  const version = "1.2.5";
+  const version = "1.2.7";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -226,7 +226,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.2.5"}`
+        `v${"1.2.7"}`
       )} ${headline}`
     );
   }

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { AstroTelemetry } from '@astrojs/telemetry';
-import type { AstroConfig } from '../../@types/astro';
+import type { AstroSettings } from '../../@types/astro';
 import type { LogOptions } from '../logger/core';
 import http from 'http';
 interface PreviewOptions {
@@ -15,5 +15,5 @@ export interface PreviewServer {
     stop(): Promise<void>;
 }
 /** The primary dev action */
-export default function preview(config: AstroConfig, { logging }: PreviewOptions): Promise<PreviewServer>;
+export default function preview(settings: AstroSettings, { logging }: PreviewOptions): Promise<PreviewServer>;
 export {};

package/dist/core/preview/index.js

@@ -8,17 +8,17 @@ import { error, info } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { getResolvedHostForHttpServer } from "./util.js";
 const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
-async function preview(config, { logging }) {
-  if (config.output === "server") {
+async function preview(settings, { logging }) {
+  if (settings.config.output === "server") {
     throw new Error(
       `[preview] 'output: server' not supported. Use your deploy platform's preview command directly instead, if one exists. (ex: 'netlify dev', 'vercel dev', 'wrangler', etc.)`
     );
   }
   const startServerTime = performance.now();
   const defaultOrigin = "http://localhost";
-  const trailingSlash = config.trailingSlash;
-  let baseURL = new URL(config.base, new URL(config.site || "/", defaultOrigin));
-  const staticFileServer = sirv(fileURLToPath(config.outDir), {
+  const trailingSlash = settings.config.trailingSlash;
+  let baseURL = new URL(settings.config.base, new URL(settings.config.site || "/", defaultOrigin));
+  const staticFileServer = sirv(fileURLToPath(settings.config.outDir), {
     dev: true,
     etag: true,
     maxAge: 0
@@ -48,7 +48,7 @@ async function preview(config, { logging }) {
       default: {
         req.url = "/" + ((_a = req.url) == null ? void 0 : _a.replace(baseURL.pathname, ""));
         staticFileServer(req, res, () => {
-          const errorPagePath = fileURLToPath(config.outDir + "/404.html");
+          const errorPagePath = fileURLToPath(settings.config.outDir + "/404.html");
           if (fs.existsSync(errorPagePath)) {
             res.statusCode = 404;
             res.setHeader("Content-Type", "text/html;charset=utf-8");
@@ -63,8 +63,8 @@ async function preview(config, { logging }) {
       }
     }
   });
-  let { port } = config.server;
-  const host = getResolvedHostForHttpServer(config.server.host);
+  let { port } = settings.config.server;
+  const host = getResolvedHostForHttpServer(settings.config.server.host);
   let httpServer;
   function startServer(timerStart) {
     let showedPortTakenMsg = false;
@@ -79,7 +79,7 @@ async function preview(config, { logging }) {
               null,
               msg.devStart({
                 startupTime: performance.now() - timerStart,
-                config,
+                config: settings.config,
                 devServerAddressInfo,
                 https: false,
                 site: baseURL

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

@@ -1,10 +1,10 @@
 import type { ViteDevServer } from 'vite';
-import type { AstroConfig, ComponentInstance, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../../@types/astro';
+import type { AstroSettings, ComponentInstance, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../../@types/astro';
 import { LogOptions } from '../../logger/core.js';
 import { RouteCache } from '../route-cache.js';
 export interface SSROptions {
-    /** an instance of the AstroConfig */
-    astroConfig: AstroConfig;
+    /** an instance of the AstroSettings */
+    settings: AstroSettings;
     /** location of file on disk */
     filePath: URL;
     /** logging options */
@@ -25,8 +25,8 @@ export interface SSROptions {
     request: Request;
 }
 export declare type ComponentPreload = [SSRLoadedRenderer[], ComponentInstance];
-export declare function loadRenderers(viteServer: ViteDevServer, astroConfig: AstroConfig): Promise<SSRLoadedRenderer[]>;
-export declare function preload({ astroConfig, filePath, viteServer, }: Pick<SSROptions, 'astroConfig' | 'filePath' | 'viteServer'>): Promise<ComponentPreload>;
+export declare function loadRenderers(viteServer: ViteDevServer, settings: AstroSettings): Promise<SSRLoadedRenderer[]>;
+export declare function preload({ settings, filePath, viteServer, }: Pick<SSROptions, 'settings' | 'filePath' | 'viteServer'>): Promise<ComponentPreload>;
 /** use Vite to SSR */
 export declare function render(renderers: SSRLoadedRenderer[], mod: ComponentInstance, ssrOpts: SSROptions): Promise<Response>;
 export declare function ssr(preloadedComponent: ComponentPreload, ssrOpts: SSROptions): Promise<Response>;

package/dist/core/render/dev/index.js

@@ -11,15 +11,15 @@ async function loadRenderer(viteServer, renderer) {
   const mod = await viteServer.ssrLoadModule(renderer.serverEntrypoint);
   return { ...renderer, ssr: mod.default };
 }
-async function loadRenderers(viteServer, astroConfig) {
-  return Promise.all(astroConfig._ctx.renderers.map((r) => loadRenderer(viteServer, r)));
+async function loadRenderers(viteServer, settings) {
+  return Promise.all(settings.renderers.map((r) => loadRenderer(viteServer, r)));
 }
 async function preload({
-  astroConfig,
+  settings,
   filePath,
   viteServer
 }) {
-  const renderers = await loadRenderers(viteServer, astroConfig);
+  const renderers = await loadRenderers(viteServer, settings);
   const mod = await viteServer.ssrLoadModule(fileURLToPath(filePath));
   if (viteServer.config.mode === "development" || !(mod == null ? void 0 : mod.$$metadata)) {
     return [renderers, mod];
@@ -33,7 +33,7 @@ async function preload({
 async function render(renderers, mod, ssrOpts) {
   var _a;
   const {
-    astroConfig,
+    settings,
     filePath,
     logging,
     mode,
@@ -44,8 +44,8 @@ async function render(renderers, mod, ssrOpts) {
     routeCache,
     viteServer
   } = ssrOpts;
-  const scripts = await getScriptsForURL(filePath, astroConfig, viteServer);
-  if (isPage(filePath, astroConfig) && mode === "development") {
+  const scripts = await getScriptsForURL(filePath, viteServer);
+  if (isPage(filePath, settings) && mode === "development") {
     scripts.add({
       props: { type: "module", src: "/@vite/client" },
       children: ""
@@ -58,13 +58,13 @@ async function render(renderers, mod, ssrOpts) {
       children: ""
     });
   }
-  for (const script of astroConfig._ctx.scripts) {
+  for (const script of settings.scripts) {
     if (script.stage === "head-inline") {
       scripts.add({
         props: {},
         children: script.content
       });
-    } else if (script.stage === "page" && isPage(filePath, astroConfig)) {
+    } else if (script.stage === "page" && isPage(filePath, settings)) {
       scripts.add({
         props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
         children: ""
@@ -97,13 +97,13 @@ async function render(renderers, mod, ssrOpts) {
     });
   });
   let response = await coreRender({
-    adapterName: (_a = astroConfig.adapter) == null ? void 0 : _a.name,
+    adapterName: (_a = settings.config.adapter) == null ? void 0 : _a.name,
     links,
     styles,
     logging,
     markdown: {
-      ...astroConfig.markdown,
-      isAstroFlavoredMd: astroConfig.legacy.astroFlavoredMarkdown
+      ...settings.config.markdown,
+      isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
     },
     mod,
     mode,
@@ -120,8 +120,8 @@ async function render(renderers, mod, ssrOpts) {
     request,
     route,
     routeCache,
-    site: astroConfig.site ? new URL(astroConfig.base, astroConfig.site).toString() : void 0,
-    ssr: astroConfig.output === "server",
+    site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : void 0,
+    ssr: settings.config.output === "server",
     streaming: true
   });
   return response;

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

@@ -1,3 +1,3 @@
 import vite from 'vite';
-import type { AstroConfig, SSRElement } from '../../../@types/astro';
-export declare function getScriptsForURL(filePath: URL, astroConfig: AstroConfig, viteServer: vite.ViteDevServer): Promise<Set<SSRElement>>;
+import type { SSRElement } from '../../../@types/astro';
+export declare function getScriptsForURL(filePath: URL, viteServer: vite.ViteDevServer): Promise<Set<SSRElement>>;

package/dist/core/render/dev/scripts.js

@@ -1,24 +1,21 @@
-import slash from "slash";
-import { fileURLToPath } from "url";
 import { viteID } from "../../util.js";
 import { createModuleScriptElementWithSrc } from "../ssr-element.js";
 import { crawlGraph } from "./vite.js";
-async function getScriptsForURL(filePath, astroConfig, viteServer) {
+async function getScriptsForURL(filePath, viteServer) {
   const elements = /* @__PURE__ */ new Set();
   const rootID = viteID(filePath);
-  let rootProjectFolder = slash(fileURLToPath(astroConfig.root));
   const modInfo = viteServer.pluginContainer.getModuleInfo(rootID);
-  addHoistedScripts(elements, modInfo, rootProjectFolder);
+  addHoistedScripts(elements, modInfo);
   for await (const moduleNode of crawlGraph(viteServer, rootID, true)) {
     const id = moduleNode.id;
     if (id) {
       const info = viteServer.pluginContainer.getModuleInfo(id);
-      addHoistedScripts(elements, info, rootProjectFolder);
+      addHoistedScripts(elements, info);
     }
   }
   return elements;
 }
-function addHoistedScripts(set, info, rootProjectFolder) {
+function addHoistedScripts(set, info) {
   var _a, _b;
   if (!((_a = info == null ? void 0 : info.meta) == null ? void 0 : _a.astro)) {
     return;

package/dist/core/routing/manifest/create.d.ts

@@ -1,7 +1,7 @@
-import type { AstroConfig, ManifestData } from '../../../@types/astro';
+import type { AstroSettings, ManifestData } from '../../../@types/astro';
 import type { LogOptions } from '../../logger/core';
 /** Create manifest of all static routes */
-export declare function createRouteManifest({ config, cwd }: {
-    config: AstroConfig;
+export declare function createRouteManifest({ settings, cwd }: {
+    settings: AstroSettings;
     cwd?: string;
 }, logging: LogOptions): ManifestData;

package/dist/core/routing/manifest/create.js

@@ -122,21 +122,17 @@ function injectedRouteToItem({ config, cwd }, { pattern, entryPoint }) {
     routeSuffix: pattern.slice(pattern.indexOf("."), -ext.length)
   };
 }
-function createRouteManifest({ config, cwd }, logging) {
-  var _a, _b, _c, _d;
+function createRouteManifest({ settings, cwd }, logging) {
+  var _a;
   const components = [];
   const routes = [];
-  const validPageExtensions = /* @__PURE__ */ new Set([
-    ".astro",
-    ".md",
-    ...config._ctx.pageExtensions
-  ]);
+  const validPageExtensions = /* @__PURE__ */ new Set([".astro", ".md", ...settings.pageExtensions]);
   const validEndpointExtensions = /* @__PURE__ */ new Set([".js", ".ts"]);
   function walk(dir, parentSegments, parentParams) {
     let items = [];
     fs.readdirSync(dir).forEach((basename) => {
       const resolved = path.join(dir, basename);
-      const file = slash(path.relative(cwd || fileURLToPath(config.root), resolved));
+      const file = slash(path.relative(cwd || fileURLToPath(settings.config.root), resolved));
       const isDir = fs.statSync(resolved).isDirectory();
       const ext = path.extname(basename);
       const name = ext ? basename.slice(0, -ext.length) : basename;
@@ -202,7 +198,7 @@ function createRouteManifest({ config, cwd }, logging) {
       } else {
         components.push(item.file);
         const component = item.file;
-        const trailingSlash = item.isPage ? config.trailingSlash : "never";
+        const trailingSlash = item.isPage ? settings.config.trailingSlash : "never";
         const pattern = getPattern(segments, trailingSlash);
         const generate = getRouteGenerator(segments, trailingSlash);
         const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
@@ -220,14 +216,15 @@ function createRouteManifest({ config, cwd }, logging) {
       }
     });
   }
+  const { config } = settings;
   const pages = resolvePages(config);
   if (fs.existsSync(pages)) {
     walk(fileURLToPath(pages), [], []);
-  } else if (((_b = (_a = config == null ? void 0 : config._ctx) == null ? void 0 : _a.injectedRoutes) == null ? void 0 : _b.length) === 0) {
-    const pagesDirRootRelative = pages.href.slice(config.root.href.length);
+  } else if (settings.injectedRoutes.length === 0) {
+    const pagesDirRootRelative = pages.href.slice(settings.config.root.href.length);
     warn(logging, "astro", `Missing pages directory: ${pagesDirRootRelative}`);
   }
-  (_d = (_c = config == null ? void 0 : config._ctx) == null ? void 0 : _c.injectedRoutes) == null ? void 0 : _d.sort(
+  (_a = settings.injectedRoutes) == null ? void 0 : _a.sort(
     (a, b) => comparator(injectedRouteToItem({ config, cwd }, a), injectedRouteToItem({ config, cwd }, b))
   ).reverse().forEach(({ pattern: name, entryPoint }) => {
     const resolved = require2.resolve(entryPoint, { paths: [cwd || fileURLToPath(config.root)] });

package/dist/core/util.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { ErrorPayload, ViteDevServer } from 'vite';
-import type { AstroConfig, RouteType } from '../@types/astro';
+import type { AstroConfig, AstroSettings, RouteType } from '../@types/astro';
 export declare const ASTRO_VERSION: string;
 /** Returns true if argument is an object of any prototype/class (but not null). */
 export declare function isObject(value: unknown): value is Record<string, any>;
@@ -37,8 +37,8 @@ export declare function unwrapId(id: string): string;
 export declare function removeDir(_dir: URL): void;
 export declare function emptyDir(_dir: URL, skip?: Set<string>): void;
 export declare function resolvePages(config: AstroConfig): URL;
-export declare function isPage(file: URL, config: AstroConfig): boolean;
-export declare function isModeServerWithNoAdapter(config: AstroConfig): boolean;
+export declare function isPage(file: URL, settings: AstroSettings): boolean;
+export declare function isModeServerWithNoAdapter(settings: AstroSettings): boolean;
 export declare function relativeToSrcDir(config: AstroConfig, idOrUrl: URL | string): string;
 export declare function emoji(char: string, fallback: string): string;
 export declare function getLocalAddress(serverAddress: string, host: string | boolean): string;

package/dist/core/util.js

@@ -5,7 +5,7 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.2.5";
+const ASTRO_VERSION = "1.2.7";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }
@@ -124,22 +124,22 @@ function isPublicRoute(file, config) {
   }
   return true;
 }
-function endsWithPageExt(file, config) {
-  for (const ext of config._ctx.pageExtensions) {
+function endsWithPageExt(file, settings) {
+  for (const ext of settings.pageExtensions) {
     if (file.toString().endsWith(ext))
       return true;
   }
   return false;
 }
-function isPage(file, config) {
-  if (!isInPagesDir(file, config))
+function isPage(file, settings) {
+  if (!isInPagesDir(file, settings.config))
     return false;
-  if (!isPublicRoute(file, config))
+  if (!isPublicRoute(file, settings.config))
     return false;
-  return endsWithPageExt(file, config);
+  return endsWithPageExt(file, settings);
 }
-function isModeServerWithNoAdapter(config) {
-  return config.output === "server" && !config._ctx.adapter;
+function isModeServerWithNoAdapter(settings) {
+  return settings.config.output === "server" && !settings.adapter;
 }
 function relativeToSrcDir(config, idOrUrl) {
   let id;

package/dist/integrations/index.d.ts

@@ -1,18 +1,18 @@
 /// <reference types="node" />
 import type { AddressInfo } from 'net';
 import type { ViteDevServer } from 'vite';
-import { AstroConfig, BuildConfig, RouteData } from '../@types/astro.js';
+import { AstroConfig, AstroSettings, BuildConfig, RouteData } from '../@types/astro.js';
 import type { SerializedSSRManifest } from '../core/app/types';
 import type { PageBuildData } from '../core/build/types';
 import type { ViteConfigWithSSR } from '../core/create-vite.js';
 import { LogOptions } from '../core/logger/core.js';
-export declare function runHookConfigSetup({ config: _config, command, logging, }: {
-    config: AstroConfig;
+export declare function runHookConfigSetup({ settings, command, logging, }: {
+    settings: AstroSettings;
     command: 'dev' | 'build';
     logging: LogOptions;
-}): Promise<AstroConfig>;
-export declare function runHookConfigDone({ config, logging, }: {
-    config: AstroConfig;
+}): Promise<AstroSettings>;
+export declare function runHookConfigDone({ settings, logging, }: {
+    settings: AstroSettings;
     logging: LogOptions;
 }): Promise<void>;
 export declare function runHookServerSetup({ config, server, logging, }: {