astro 1.2.5 → 1.2.7

package/dist/core/build/vite-plugin-css.d.ts

@@ -1,4 +1,3 @@
-import type { AstroConfig } from '../../@types/astro';
 import type { BuildInternals } from './internal';
 import type { StaticBuildOptions } from './types';
 import { Plugin as VitePlugin } from 'vite';
@@ -6,7 +5,6 @@ interface PluginOptions {
     internals: BuildInternals;
     buildOptions: StaticBuildOptions;
     target: 'client' | 'server';
-    astroConfig: AstroConfig;
 }
 export declare function rollupPluginAstroBuildCSS(options: PluginOptions): VitePlugin[];
 export {};

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

@@ -14,10 +14,10 @@ import {
 const MAX_NAME_LENGTH = 70;
 function rollupPluginAstroBuildCSS(options) {
   const { internals, buildOptions } = options;
-  const { astroConfig } = buildOptions;
+  const { settings } = buildOptions;
   let resolvedConfig;
   function nameifyPage(id) {
-    let rel = relativeToSrcDir(astroConfig, id);
+    let rel = relativeToSrcDir(settings.config, id);
     if (rel.startsWith("pages/")) {
       rel = rel.slice(6);
     }
@@ -163,7 +163,7 @@ function rollupPluginAstroBuildCSS(options) {
           for (const [, output] of Object.entries(bundle)) {
             if (output.type === "asset") {
               if (((_a = output.name) == null ? void 0 : _a.endsWith(".css")) && typeof output.source === "string") {
-                const cssTarget = (_b = options.astroConfig.vite.build) == null ? void 0 : _b.cssTarget;
+                const cssTarget = (_b = settings.config.vite.build) == null ? void 0 : _b.cssTarget;
                 const { code: minifiedCSS } = await esbuild.transform(output.source, {
                   loader: "css",
                   minify: true,

package/dist/core/build/vite-plugin-hoisted-scripts.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin as VitePlugin } from 'vite';
-import type { AstroConfig } from '../../@types/astro';
+import type { AstroSettings } from '../../@types/astro';
 import type { BuildInternals } from '../../core/build/internal.js';
-export declare function vitePluginHoistedScripts(astroConfig: AstroConfig, internals: BuildInternals): VitePlugin;
+export declare function vitePluginHoistedScripts(settings: AstroSettings, internals: BuildInternals): VitePlugin;

package/dist/core/build/vite-plugin-hoisted-scripts.js

@@ -3,7 +3,7 @@ import { getPageDataByViteID } from "./internal.js";
 function virtualHoistedEntry(id) {
   return id.startsWith("/astro/hoisted.js?q=");
 }
-function vitePluginHoistedScripts(astroConfig, internals) {
+function vitePluginHoistedScripts(settings, internals) {
   return {
     name: "@astro/rollup-plugin-astro-hoisted-scripts",
     resolveId(id) {
@@ -29,7 +29,7 @@ function vitePluginHoistedScripts(astroConfig, internals) {
     },
     async generateBundle(_options, bundle) {
       var _a, _b;
-      let assetInlineLimit = ((_b = (_a = astroConfig.vite) == null ? void 0 : _a.build) == null ? void 0 : _b.assetsInlineLimit) || 4096;
+      let assetInlineLimit = ((_b = (_a = settings.config.vite) == null ? void 0 : _a.build) == null ? void 0 : _b.assetsInlineLimit) || 4096;
       for (const [id, output] of Object.entries(bundle)) {
         if (output.type === "chunk" && output.facadeModuleId && virtualHoistedEntry(output.facadeModuleId)) {
           const canBeInlined = output.imports.length === 0 && output.dynamicImports.length === 0 && Buffer.byteLength(output.code) <= assetInlineLimit;
@@ -37,7 +37,7 @@ function vitePluginHoistedScripts(astroConfig, internals) {
           const facadeId = output.facadeModuleId;
           const pages = internals.hoistedScriptIdToPagesMap.get(facadeId);
           for (const pathname of pages) {
-            const vid = viteID(new URL("." + pathname, astroConfig.root));
+            const vid = viteID(new URL("." + pathname, settings.config.root));
             const pageInfo = getPageDataByViteID(internals, vid);
             if (pageInfo) {
               if (canBeInlined) {

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

@@ -5,7 +5,7 @@ function vitePluginPages(opts, internals) {
   return {
     name: "@astro/plugin-build-pages",
     options(options) {
-      if (opts.astroConfig.output === "static") {
+      if (opts.settings.config.output === "static") {
         return addRollupInput(options, [pagesVirtualModuleId]);
       }
     },
@@ -27,7 +27,7 @@ function vitePluginPages(opts, internals) {
         }
         i = 0;
         let rendererItems = "";
-        for (const renderer of opts.astroConfig._ctx.renderers) {
+        for (const renderer of opts.settings.renderers) {
           const variable = `_renderer${i}`;
           imports.unshift(`import ${variable} from '${renderer.serverEntrypoint}';`);
           rendererItems += `Object.assign(${JSON.stringify(renderer)}, { ssr: ${variable} }),`;

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

@@ -83,7 +83,11 @@ async function injectManifest(buildOpts, internals) {
   }
   const staticFiles = internals.staticFiles;
   const manifest = buildManifest(buildOpts, internals, Array.from(staticFiles));
-  await runHookBuildSsr({ config: buildOpts.astroConfig, manifest, logging: buildOpts.logging });
+  await runHookBuildSsr({
+    config: buildOpts.settings.config,
+    manifest,
+    logging: buildOpts.logging
+  });
   const chunk = internals.ssrEntryChunk;
   const code = chunk.code;
   chunk.code = code.replace(replaceExp, () => {
@@ -94,10 +98,10 @@ async function injectManifest(buildOpts, internals) {
   await fs.promises.writeFile(serverEntryURL, chunk.code, "utf-8");
 }
 function buildManifest(opts, internals, staticFiles) {
-  const { astroConfig } = opts;
+  const { settings } = opts;
   const routes = [];
   const entryModules = Object.fromEntries(internals.entrySpecifierToBundleMap.entries());
-  if (astroConfig._ctx.scripts.some((script) => script.stage === "page")) {
+  if (settings.scripts.some((script) => script.stage === "page")) {
     staticFiles.push(entryModules[PAGE_SCRIPT_ID]);
   }
   for (const pageData of eachPageData(internals)) {
@@ -105,7 +109,7 @@ function buildManifest(opts, internals, staticFiles) {
     if (pageData.hoistedScript) {
       scripts.unshift(pageData.hoistedScript);
     }
-    if (astroConfig._ctx.scripts.some((script) => script.stage === "page")) {
+    if (settings.scripts.some((script) => script.stage === "page")) {
       scripts.push({ type: "external", value: entryModules[PAGE_SCRIPT_ID] });
     }
     routes.push({
@@ -113,22 +117,22 @@ function buildManifest(opts, internals, staticFiles) {
       links: sortedCSS(pageData),
       scripts: [
         ...scripts,
-        ...astroConfig._ctx.scripts.filter((script) => script.stage === "head-inline").map(({ stage, content }) => ({ stage, children: content }))
+        ...settings.scripts.filter((script) => script.stage === "head-inline").map(({ stage, content }) => ({ stage, children: content }))
       ],
-      routeData: serializeRouteData(pageData.route, astroConfig.trailingSlash)
+      routeData: serializeRouteData(pageData.route, settings.config.trailingSlash)
     });
   }
   if (!(BEFORE_HYDRATION_SCRIPT_ID in entryModules)) {
     entryModules[BEFORE_HYDRATION_SCRIPT_ID] = "";
   }
   const ssrManifest = {
-    adapterName: opts.astroConfig._ctx.adapter.name,
+    adapterName: opts.settings.adapter.name,
     routes,
-    site: astroConfig.site,
-    base: astroConfig.base,
+    site: settings.config.site,
+    base: settings.config.base,
     markdown: {
-      ...astroConfig.markdown,
-      isAstroFlavoredMd: astroConfig.legacy.astroFlavoredMarkdown
+      ...settings.config.markdown,
+      isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
     },
     pageMap: null,
     renderers: [],

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

@@ -0,0 +1,41 @@
+import type { Arguments as Flags } from 'yargs-parser';
+import type { AstroConfig, AstroUserConfig, CLIFlags } from '../../@types/astro';
+import { LogOptions } from '../logger/core.js';
+export declare const LEGACY_ASTRO_CONFIG_KEYS: Set<string>;
+/** Turn raw config values into normalized values */
+export declare function validateConfig(userConfig: any, root: string, cmd: string, 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 resolveConfigPath(configOptions: Pick<LoadConfigOptions, 'cwd' | 'flags'>): Promise<string | undefined>;
+interface OpenConfigResult {
+    userConfig: AstroUserConfig;
+    astroConfig: AstroConfig;
+    flags: CLIFlags;
+    root: string;
+}
+/** Load a configuration file, returning both the userConfig and astroConfig */
+export declare function openConfig(configOptions: LoadConfigOptions): Promise<OpenConfigResult>;
+/**
+ * Attempt to load an `astro.config.mjs` file
+ * @deprecated
+ */
+export declare function loadConfig(configOptions: LoadConfigOptions): Promise<AstroConfig>;
+/** Attempt to resolve an Astro configuration object. Normalize, validate, and return. */
+export declare function resolveConfig(userConfig: AstroUserConfig, root: string, flags: CLIFlags | undefined, cmd: string, logging: LogOptions): Promise<AstroConfig>;
+export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;
+export {};

package/dist/core/{config.js → config/config.js}

@@ -1,73 +1,14 @@
-import fs from "fs";
 import load, { ProloadError, resolve } from "@proload/core";
 import loadTypeScript from "@proload/plugin-tsm";
+import fs from "fs";
 import * as colors from "kleur/colors";
 import path from "path";
-import postcssrc from "postcss-load-config";
-import { BUNDLED_THEMES } from "shiki";
-import * as tsr from "tsconfig-resolver";
 import { fileURLToPath, pathToFileURL } from "url";
 import * as vite from "vite";
 import { mergeConfig as mergeViteConfig } from "vite";
-import { z } from "zod";
-import jsxRenderer from "../jsx/renderer.js";
-import { appendForwardSlash, prependForwardSlash, trimSlashes } from "./path.js";
-import { arraify, isObject } from "./util.js";
+import { arraify, isObject } from "../util.js";
+import { createRelativeSchema } from "./schema.js";
 load.use([loadTypeScript]);
-const ASTRO_CONFIG_DEFAULTS = {
-  root: ".",
-  srcDir: "./src",
-  publicDir: "./public",
-  outDir: "./dist",
-  base: "/",
-  trailingSlash: "ignore",
-  build: { format: "directory" },
-  server: {
-    host: false,
-    port: 3e3,
-    streaming: true
-  },
-  style: { postcss: { options: {}, plugins: [] } },
-  integrations: [],
-  markdown: {
-    drafts: false,
-    syntaxHighlight: "shiki",
-    shikiConfig: {
-      langs: [],
-      theme: "github-dark",
-      wrap: false
-    },
-    remarkPlugins: [],
-    rehypePlugins: [],
-    remarkRehype: {}
-  },
-  vite: {},
-  legacy: {
-    astroFlavoredMarkdown: false
-  }
-};
-async function resolvePostcssConfig(inlineOptions, root) {
-  if (isObject(inlineOptions)) {
-    const options = { ...inlineOptions };
-    delete options.plugins;
-    return {
-      options,
-      plugins: inlineOptions.plugins || []
-    };
-  }
-  const searchPath = typeof inlineOptions === "string" ? inlineOptions : fileURLToPath(root);
-  try {
-    return await postcssrc({}, searchPath);
-  } catch (err) {
-    if (!/No PostCSS Config found/.test(err.message)) {
-      throw err;
-    }
-    return {
-      options: {},
-      plugins: []
-    };
-  }
-}
 const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "projectRoot",
   "src",
@@ -79,64 +20,6 @@ const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "buildOptions",
   "devOptions"
 ]);
-const AstroConfigSchema = z.object({
-  root: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.root).transform((val) => new URL(val)),
-  srcDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => new URL(val)),
-  publicDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.publicDir).transform((val) => new URL(val)),
-  outDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.outDir).transform((val) => new URL(val)),
-  site: z.string().url().optional().transform((val) => val ? appendForwardSlash(val) : val),
-  base: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.base).transform((val) => prependForwardSlash(appendForwardSlash(trimSlashes(val)))),
-  trailingSlash: z.union([z.literal("always"), z.literal("never"), z.literal("ignore")]).optional().default(ASTRO_CONFIG_DEFAULTS.trailingSlash),
-  output: z.union([z.literal("static"), z.literal("server")]).optional().default("static"),
-  adapter: z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) }).optional(),
-  integrations: z.preprocess(
-    (val) => Array.isArray(val) ? val.flat(Infinity).filter(Boolean) : val,
-    z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default(ASTRO_CONFIG_DEFAULTS.integrations)
-  ),
-  build: z.object({
-    format: z.union([z.literal("file"), z.literal("directory")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format)
-  }).optional().default({}),
-  server: z.preprocess(
-    (val) => typeof val === "function" ? val({ command: "error" }) : val,
-    z.object({
-      host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
-      port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port)
-    }).optional().default({})
-  ),
-  style: z.object({
-    postcss: z.object({
-      options: z.any(),
-      plugins: z.array(z.any())
-    }).optional().default(ASTRO_CONFIG_DEFAULTS.style.postcss)
-  }).optional().default({}),
-  markdown: z.object({
-    drafts: z.boolean().default(false),
-    syntaxHighlight: z.union([z.literal("shiki"), z.literal("prism"), z.literal(false)]).default(ASTRO_CONFIG_DEFAULTS.markdown.syntaxHighlight),
-    shikiConfig: z.object({
-      langs: z.custom().array().default([]),
-      theme: z.enum(BUNDLED_THEMES).or(z.custom()).default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.theme),
-      wrap: z.boolean().or(z.null()).default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.wrap)
-    }).default({}),
-    remarkPlugins: z.union([
-      z.string(),
-      z.tuple([z.string(), z.any()]),
-      z.custom((data) => typeof data === "function"),
-      z.tuple([z.custom((data) => typeof data === "function"), z.any()])
-    ]).array().default(ASTRO_CONFIG_DEFAULTS.markdown.remarkPlugins),
-    rehypePlugins: z.union([
-      z.string(),
-      z.tuple([z.string(), z.any()]),
-      z.custom((data) => typeof data === "function"),
-      z.tuple([z.custom((data) => typeof data === "function"), z.any()])
-    ]).array().default(ASTRO_CONFIG_DEFAULTS.markdown.rehypePlugins),
-    remarkRehype: z.custom((data) => data instanceof Object && !Array.isArray(data)).optional().default(ASTRO_CONFIG_DEFAULTS.markdown.remarkRehype),
-    extendDefaultPlugins: z.boolean().default(false)
-  }).default({}),
-  vite: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.vite),
-  legacy: z.object({
-    astroFlavoredMarkdown: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.legacy.astroFlavoredMarkdown)
-  }).optional().default({})
-});
 async function validateConfig(userConfig, root, cmd, logging) {
   const fileProtocolRoot = pathToFileURL(root + path.sep);
   if (userConfig.hasOwnProperty("renderers")) {
@@ -181,42 +64,8 @@ Please update your configuration to the new format!
 See https://astro.build/config for more information.`
     );
   }
-  const AstroConfigRelativeSchema = AstroConfigSchema.extend({
-    root: z.string().default(ASTRO_CONFIG_DEFAULTS.root).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
-    srcDir: z.string().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
-    publicDir: z.string().default(ASTRO_CONFIG_DEFAULTS.publicDir).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
-    outDir: z.string().default(ASTRO_CONFIG_DEFAULTS.outDir).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
-    server: z.preprocess(
-      (val) => typeof val === "function" ? val({ command: cmd === "dev" ? "dev" : "preview" }) : val,
-      z.object({
-        host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
-        port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
-        streaming: z.boolean().optional().default(true)
-      }).optional().default({})
-    ),
-    style: z.object({
-      postcss: z.preprocess(
-        (val) => resolvePostcssConfig(val, fileProtocolRoot),
-        z.object({
-          options: z.any(),
-          plugins: z.array(z.any())
-        }).optional().default(ASTRO_CONFIG_DEFAULTS.style.postcss)
-      )
-    }).optional().default({})
-  });
-  const tsconfig = loadTSConfig(root);
-  const result = {
-    ...await AstroConfigRelativeSchema.parseAsync(userConfig),
-    _ctx: {
-      pageExtensions: [".astro", ".md", ".html"],
-      tsConfig: tsconfig == null ? void 0 : tsconfig.config,
-      tsConfigPath: tsconfig == null ? void 0 : tsconfig.path,
-      scripts: [],
-      renderers: [jsxRenderer],
-      injectedRoutes: [],
-      adapter: void 0
-    }
-  };
+  const AstroConfigRelativeSchema = createRelativeSchema(cmd, fileProtocolRoot);
+  const result = await AstroConfigRelativeSchema.parseAsync(userConfig);
   return result;
 }
 function resolveFlags(flags) {
@@ -350,15 +199,6 @@ async function tryLoadConfig(configOptions, flags, root) {
     await finallyCleanup();
   }
 }
-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;
-}
 async function loadConfig(configOptions) {
   const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
@@ -406,7 +246,6 @@ function mergeConfig(defaults, overrides, isRoot = true) {
   return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
 }
 export {
-  AstroConfigSchema,
   LEGACY_ASTRO_CONFIG_KEYS,
   loadConfig,
   mergeConfig,

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

@@ -0,0 +1,4 @@
+export { openConfig, resolveConfigPath, resolveFlags, resolveRoot, validateConfig, } from './config.js';
+export type { AstroConfigSchema } from './schema';
+export { createSettings } from './settings.js';
+export { loadTSConfig } from './tsconfig.js';

package/dist/core/config/index.js

@@ -0,0 +1,18 @@
+import {
+  openConfig,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot,
+  validateConfig
+} from "./config.js";
+import { createSettings } from "./settings.js";
+import { loadTSConfig } from "./tsconfig.js";
+export {
+  createSettings,
+  loadTSConfig,
+  openConfig,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot,
+  validateConfig
+};