astro 0.24.3 → 0.25.0-next.0

package/dist/cli/index.js

@@ -39,7 +39,7 @@ function printHelp() {
     console.log();
   }
   function headline(name, tagline) {
-    console.log(`  ${colors.bgGreen(colors.black(` ${name} `))} ${colors.green(`v${"0.24.3"}`)} ${tagline}`);
+    console.log(`  ${colors.bgGreen(colors.black(` ${name} `))} ${colors.green(`v${"0.25.0-next.0"}`)} ${tagline}`);
   }
   function title(label) {
     console.log(`  ${colors.bgWhite(colors.black(` ${label} `))}`);
@@ -65,7 +65,7 @@ function printHelp() {
   }
 }
 async function printVersion() {
-  const version = "0.24.3";
+  const version = "0.25.0-next.0";
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${version}`)}`);
 }

package/dist/core/app/index.js

@@ -1,3 +1,22 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -26,7 +45,6 @@ import { matchRoute } from "../routing/match.js";
 import { render } from "../render/core.js";
 import { RouteCache } from "../render/route-cache.js";
 import { createLinkStylesheetElementSet, createModuleScriptElementWithSrcSet } from "../render/ssr-element.js";
-import { createRenderer } from "../render/renderer.js";
 import { prependForwardSlash } from "../path.js";
 class App {
   constructor(manifest, rootFolder) {
@@ -47,22 +65,27 @@ class App {
     __privateSet(this, _routeCache, new RouteCache(defaultLogOptions));
     __privateSet(this, _renderersPromise, __privateMethod(this, _loadRenderers, loadRenderers_fn).call(this));
   }
-  match({ pathname }) {
-    return matchRoute(pathname, __privateGet(this, _manifestData));
+  match(request) {
+    const url = new URL(request.url);
+    return matchRoute(url.pathname, __privateGet(this, _manifestData));
   }
-  async render(url, routeData) {
+  async render(request, routeData) {
     if (!routeData) {
-      routeData = this.match(url);
+      routeData = this.match(request);
       if (!routeData) {
-        return "Not found";
+        return new Response(null, {
+          status: 404,
+          statusText: "Not found"
+        });
       }
     }
     const manifest = __privateGet(this, _manifest);
     const info = __privateGet(this, _routeDataToRouteInfo).get(routeData);
     const [mod, renderers] = await Promise.all([__privateMethod(this, _loadModule, loadModule_fn).call(this, info.file), __privateGet(this, _renderersPromise)]);
+    const url = new URL(request.url);
     const links = createLinkStylesheetElementSet(info.links, manifest.site);
     const scripts = createModuleScriptElementWithSrcSet(info.scripts, manifest.site);
-    return render({
+    const result = await render({
       legacyBuild: false,
       links,
       logging: defaultLogOptions,
@@ -81,7 +104,17 @@ class App {
       },
       route: routeData,
       routeCache: __privateGet(this, _routeCache),
-      site: __privateGet(this, _manifest).site
+      site: __privateGet(this, _manifest).site,
+      ssr: true,
+      method: info.routeData.type === "endpoint" ? "" : "GET",
+      headers: request.headers
+    });
+    if (result.type === "response") {
+      return result.response;
+    }
+    let html = result.html;
+    return new Response(html, {
+      status: 200
     });
   }
 }
@@ -93,16 +126,9 @@ _routeCache = new WeakMap();
 _renderersPromise = new WeakMap();
 _loadRenderers = new WeakSet();
 loadRenderers_fn = async function() {
-  const rendererNames = __privateGet(this, _manifest).renderers;
-  return await Promise.all(rendererNames.map(async (rendererName) => {
-    return createRenderer(rendererName, {
-      renderer(name) {
-        return import(name);
-      },
-      server(entry) {
-        return import(entry);
-      }
-    });
+  return await Promise.all(__privateGet(this, _manifest).renderers.map(async (renderer) => {
+    const mod = await import(renderer.serverEntrypoint);
+    return __spreadProps(__spreadValues({}, renderer), { ssr: mod.default });
   }));
 };
 _loadModule = new WeakSet();

package/dist/core/app/node.js

@@ -1,15 +1,21 @@
 import * as fs from "fs";
 import { App } from "./index.js";
 import { deserializeManifest } from "./common.js";
-function createURLFromRequest(req) {
-  return new URL(`http://${req.headers.host}${req.url}`);
+function createRequestFromNodeRequest(req) {
+  let url = `http://${req.headers.host}${req.url}`;
+  const entries = Object.entries(req.headers);
+  let request = new Request(url, {
+    method: req.method || "GET",
+    headers: new Headers(entries)
+  });
+  return request;
 }
 class NodeApp extends App {
   match(req) {
-    return super.match(req instanceof URL ? req : createURLFromRequest(req));
+    return super.match(req instanceof Request ? req : createRequestFromNodeRequest(req));
   }
   render(req) {
-    return super.render(req instanceof URL ? req : createURLFromRequest(req));
+    return super.render(req instanceof Request ? req : createRequestFromNodeRequest(req));
   }
 }
 async function loadManifest(rootFolder) {

package/dist/core/build/index.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import * as colors from "kleur/colors";
-import { polyfill } from "@astrojs/webapi";
+import { apply as applyPolyfill } from "../polyfill.js";
 import { performance } from "perf_hooks";
 import * as vite from "vite";
 import { createVite } from "../create-vite.js";
@@ -11,16 +11,15 @@ import { collectPagesData } from "./page-data.js";
 import { build as scanBasedBuild } from "./scan-based-build.js";
 import { staticBuild } from "./static-build.js";
 import { RouteCache } from "../render/route-cache.js";
+import { runHookBuildDone, runHookBuildStart, runHookConfigDone, runHookConfigSetup } from "../../integrations/index.js";
 async function build(config, options = { logging: defaultLogOptions }) {
-  polyfill(globalThis, {
-    exclude: "window document"
-  });
   const builder = new AstroBuilder(config, options);
   await builder.build();
 }
 class AstroBuilder {
   constructor(config, options) {
     this.mode = "production";
+    applyPolyfill();
     if (!config.buildOptions.site && config.buildOptions.sitemap !== false) {
       warn(options.logging, "config", `Set "buildOptions.site" to generate correct canonical URLs and sitemap`);
     }
@@ -38,17 +37,20 @@ class AstroBuilder {
     const timer = {};
     timer.init = performance.now();
     timer.viteStart = performance.now();
-    const viteConfig = await createVite(vite.mergeConfig({
+    this.config = await runHookConfigSetup({ config: this.config, command: "build" });
+    const viteConfig = await createVite({
       mode: this.mode,
       server: {
         hmr: false,
         middlewareMode: "ssr"
       }
-    }, this.config.vite || {}), { astroConfig: this.config, logging, mode: "build" });
+    }, { astroConfig: this.config, logging, mode: "build" });
+    await runHookConfigDone({ config: this.config });
     this.viteConfig = viteConfig;
     const viteServer = await vite.createServer(viteConfig);
     this.viteServer = viteServer;
     debug("build", timerMessage("Vite started", timer.viteStart));
+    await runHookBuildStart({ config: this.config });
     timer.loadStart = performance.now();
     const { assets, allPages } = await collectPagesData({
       astroConfig: this.config,
@@ -56,7 +58,8 @@ class AstroBuilder {
       manifest: this.manifest,
       origin,
       routeCache: this.routeCache,
-      viteServer: this.viteServer
+      viteServer: this.viteServer,
+      ssr: this.config.buildOptions.experimentalSsr
     });
     Object.entries(allPages).forEach(([page, data]) => {
       if ("frontmatter" in data.preload[1]) {
@@ -114,6 +117,7 @@ class AstroBuilder {
       debug("build", timerMessage("Sitemap built", timer.sitemapStart));
     }
     await viteServer.close();
+    await runHookBuildDone({ config: this.config, pages: pageNames });
     if (logging.level && levels[logging.level] <= levels["info"]) {
       await this.printStats({ logging, timeStart: timer.init, pageCount: pageNames.length });
     }

package/dist/core/build/page-data.js

@@ -75,12 +75,12 @@ Use \`rss(data, {stylesheet: '...'})\` to choose a unique, custom URL. (${route.
   return { assets, allPages };
 }
 async function getStaticPathsForRoute(opts, route) {
-  const { astroConfig, logging, routeCache, viteServer } = opts;
+  const { astroConfig, logging, routeCache, ssr, viteServer } = opts;
   if (!viteServer)
     throw new Error(`vite.createServer() not called!`);
   const filePath = new URL(`./${route.component}`, astroConfig.projectRoot);
   const mod = await viteServer.ssrLoadModule(fileURLToPath(filePath));
-  const result = await callGetStaticPaths(mod, route, false, logging);
+  const result = await callGetStaticPaths({ mod, route, isValidate: false, logging, ssr });
   routeCache.set(route, result);
   return result;
 }

package/dist/core/build/static-build.js

@@ -17,20 +17,21 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import glob from "fast-glob";
 import fs from "fs";
 import npath from "path";
 import { fileURLToPath } from "url";
-import glob from "fast-glob";
 import * as vite from "vite";
+import { createBuildInternals } from "../../core/build/internal.js";
 import { debug, error } from "../../core/logger.js";
-import { prependForwardSlash, appendForwardSlash } from "../../core/path.js";
+import { appendForwardSlash, prependForwardSlash } from "../../core/path.js";
 import { emptyDir, removeDir, resolveDependency } from "../../core/util.js";
-import { createBuildInternals } from "../../core/build/internal.js";
 import { rollupPluginAstroBuildCSS } from "../../vite-plugin-build-css/index.js";
-import { vitePluginHoistedScripts } from "./vite-plugin-hoisted-scripts.js";
-import { serializeRouteData } from "../routing/index.js";
+import { call as callEndpoint } from "../endpoint/index.js";
 import { render } from "../render/core.js";
 import { createLinkStylesheetElementSet, createModuleScriptElementWithSrcSet } from "../render/ssr-element.js";
+import { serializeRouteData } from "../routing/index.js";
+import { vitePluginHoistedScripts } from "./vite-plugin-hoisted-scripts.js";
 const MAX_CONCURRENT_RENDERS = 1;
 const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
 function addPageName(pathname, opts) {
@@ -76,12 +77,6 @@ async function staticBuild(opts) {
   const pageInput = /* @__PURE__ */ new Set();
   const jsInput = /* @__PURE__ */ new Set();
   const facadeIdToPageDataMap = /* @__PURE__ */ new Map();
-  const polyfills = getRenderers(opts).flatMap((renderer) => {
-    return (renderer.polyfills || []).concat(renderer.hydrationPolyfills || []);
-  });
-  for (const polyfill of polyfills) {
-    jsInput.add(polyfill);
-  }
   const internals = createBuildInternals();
   for (const [component, pageData] of Object.entries(allPages)) {
     const astroModuleURL = new URL("./" + component, astroConfig.projectRoot);
@@ -93,7 +88,7 @@ async function staticBuild(opts) {
         ...metadata.hydratedComponentPaths(),
         ...metadata.clientOnlyComponentPaths(),
         ...metadata.hydrationDirectiveSpecifiers(),
-        ...renderers.filter((renderer) => !!renderer.source).map((renderer) => renderer.source)
+        ...renderers.filter((renderer) => !!renderer.clientEntrypoint).map((renderer) => renderer.clientEntrypoint)
       ]);
       const hoistedScripts = new Set(metadata.hoistedScriptPaths());
       if (hoistedScripts.size) {
@@ -124,8 +119,9 @@ async function ssrBuild(opts, internals, input) {
   const ssr = astroConfig.buildOptions.experimentalSsr;
   const out = ssr ? getServerRoot(astroConfig) : getOutRoot(astroConfig);
   return await vite.build({
-    logLevel: "warn",
+    logLevel: "error",
     mode: "production",
+    css: viteConfig.css,
     build: __spreadProps(__spreadValues({}, viteConfig.build), {
       emptyOutDir: false,
       manifest: ssr,
@@ -167,8 +163,9 @@ async function clientBuild(opts, internals, input) {
   }
   const out = astroConfig.buildOptions.experimentalSsr ? getClientRoot(astroConfig) : getOutRoot(astroConfig);
   return await vite.build({
-    logLevel: "warn",
+    logLevel: "error",
     mode: "production",
+    css: viteConfig.css,
     build: {
       emptyOutDir: false,
       minify: "esbuild",
@@ -200,26 +197,16 @@ async function clientBuild(opts, internals, input) {
     base: appendForwardSlash(astroConfig.buildOptions.site ? new URL(astroConfig.buildOptions.site).pathname : "/")
   });
 }
-function getRenderers(opts) {
-  const pageData = Object.values(opts.allPages)[0];
-  const viteLoadedRenderers = pageData.preload[0];
-  return viteLoadedRenderers;
+async function loadRenderer(renderer, config) {
+  const mod = await import(resolveDependency(renderer.serverEntrypoint, config));
+  return __spreadProps(__spreadValues({}, renderer), { ssr: mod.default });
 }
-async function collectRenderers(opts) {
-  const viteLoadedRenderers = getRenderers(opts);
-  const renderers = await Promise.all(viteLoadedRenderers.map(async (r) => {
-    const mod = await import(resolveDependency(r.serverEntry, opts.astroConfig));
-    return Object.create(r, {
-      ssr: {
-        value: mod.default
-      }
-    });
-  }));
-  return renderers;
+async function loadRenderers(config) {
+  return Promise.all(config._ctx.renderers.map((r) => loadRenderer(r, config)));
 }
 async function generatePages(result, opts, internals, facadeIdToPageDataMap) {
   debug("build", "Finish build. Begin generating.");
-  const renderers = await collectRenderers(opts);
+  const renderers = await loadRenderers(opts.astroConfig);
   for (let output of result.output) {
     if (chunkIsPage(opts.astroConfig, output, internals)) {
       await generatePage(output, opts, internals, facadeIdToPageDataMap, renderers);
@@ -264,8 +251,16 @@ async function generatePath(pathname, opts, gopts) {
   const site = astroConfig.buildOptions.site;
   const links = createLinkStylesheetElementSet(linkIds.reverse(), site);
   const scripts = createModuleScriptElementWithSrcSet(hoistedId ? [hoistedId] : [], site);
+  for (const script of astroConfig._ctx.scripts) {
+    if (script.stage === "head-inline") {
+      scripts.add({
+        props: {},
+        children: script.content
+      });
+    }
+  }
   try {
-    const html = await render({
+    const options = {
       legacyBuild: false,
       links,
       logging,
@@ -278,20 +273,40 @@ async function generatePath(pathname, opts, gopts) {
       async resolve(specifier) {
         const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
         if (typeof hashedFilePath !== "string") {
+          if (specifier === "astro:scripts/before-hydration.js") {
+            return "data:text/javascript;charset=utf-8,//[no before-hydration script]";
+          }
           throw new Error(`Cannot find the built path for ${specifier}`);
         }
         const relPath = npath.posix.relative(pathname, "/" + hashedFilePath);
         const fullyRelativePath = relPath[0] === "." ? relPath : "./" + relPath;
         return fullyRelativePath;
       },
+      method: "GET",
+      headers: new Headers(),
       route: pageData.route,
       routeCache,
-      site: astroConfig.buildOptions.site
-    });
+      site: astroConfig.buildOptions.site,
+      ssr: opts.astroConfig.buildOptions.experimentalSsr
+    };
+    let body;
+    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;
+    } else {
+      const result = await render(options);
+      if (result.type !== "html") {
+        return;
+      }
+      body = result.html;
+    }
     const outFolder = getOutFolder(astroConfig, pathname, pageData.route.type);
     const outFile = getOutFile(astroConfig, outFolder, pathname, pageData.route.type);
     await fs.promises.mkdir(outFolder, { recursive: true });
-    await fs.promises.writeFile(outFile, html, "utf-8");
+    await fs.promises.writeFile(outFile, body, "utf-8");
   } catch (err) {
     error(opts.logging, "build", `Error rendering:`, err);
   }
@@ -336,7 +351,7 @@ async function generateManifest(result, opts, internals) {
     markdown: {
       render: astroConfig.markdownOptions.render
     },
-    renderers: astroConfig.renderers,
+    renderers: astroConfig._ctx.renderers,
     entryModules: Object.fromEntries(internals.entrySpecifierToBundleMap.entries())
   };
   const outputManifestJSON = JSON.stringify(ssrManifest, null, "  ");
@@ -456,8 +471,8 @@ function vitePluginNewBuild(input, internals, ext) {
       }
       await Promise.all(promises);
       for (const [, chunk] of Object.entries(bundle)) {
-        if (chunk.type === "chunk" && chunk.facadeModuleId && mapping.has(chunk.facadeModuleId)) {
-          const specifier = mapping.get(chunk.facadeModuleId);
+        if (chunk.type === "chunk" && chunk.facadeModuleId) {
+          const specifier = mapping.get(chunk.facadeModuleId) || chunk.facadeModuleId;
           internals.entrySpecifierToBundleMap.set(specifier, chunk.fileName);
         }
       }

package/dist/core/config.js

@@ -1,17 +1,69 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import * as colors from "kleur/colors";
 import path from "path";
 import { pathToFileURL, fileURLToPath } from "url";
+import { mergeConfig as mergeViteConfig } from "vite";
 import { z } from "zod";
 import load from "@proload/core";
 import loadTypeScript from "@proload/plugin-tsm";
+import postcssrc from "postcss-load-config";
+import { arraify, isObject } from "./util.js";
 load.use([loadTypeScript]);
+async function resolvePostcssConfig(inlineOptions, root) {
+  if (isObject(inlineOptions)) {
+    const options = __spreadValues({}, 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 AstroConfigSchema = z.object({
   projectRoot: z.string().optional().default(".").transform((val) => new URL(val)),
   src: z.string().optional().default("./src").transform((val) => new URL(val)),
   pages: z.string().optional().default("./src/pages").transform((val) => new URL(val)),
   public: z.string().optional().default("./public").transform((val) => new URL(val)),
   dist: z.string().optional().default("./dist").transform((val) => new URL(val)),
-  renderers: z.array(z.string()).optional().default(["@astrojs/renderer-svelte", "@astrojs/renderer-vue", "@astrojs/renderer-react", "@astrojs/renderer-preact"]),
+  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([]).refine((arr) => arr.every((integration) => integration.name.startsWith("@astrojs/")), {
+    message: `Astro integrations are still experimental, and only official integrations are currently supported`
+  })),
+  styleOptions: z.object({
+    postcss: z.object({
+      options: z.any(),
+      plugins: z.array(z.any())
+    }).optional().default({ options: {}, plugins: [] })
+  }).optional().default({}),
   markdownOptions: z.object({
     render: z.any().optional().default(["@astrojs/markdown-remark", {}])
   }).strict().optional().default({}),
@@ -35,14 +87,48 @@ const AstroConfigSchema = z.object({
 });
 async function validateConfig(userConfig, root) {
   const fileProtocolRoot = pathToFileURL(root + path.sep);
+  if (userConfig.hasOwnProperty("renderers")) {
+    console.error('Astro "renderers" are now "integrations"!');
+    console.error("Update your configuration and install new dependencies:");
+    try {
+      const rendererKeywords = userConfig.renderers.map((r) => r.replace("@astrojs/renderer-", ""));
+      const rendererImports = rendererKeywords.map((r) => `  import ${r} from '@astrojs/${r}';`).join("\n");
+      const rendererIntegrations = rendererKeywords.map((r) => `    ${r}(),`).join("\n");
+      console.error("");
+      console.error(colors.dim("  // astro.config.js"));
+      if (rendererImports.length > 0) {
+        console.error(colors.green(rendererImports));
+      }
+      console.error("");
+      console.error(colors.dim("  // ..."));
+      if (rendererIntegrations.length > 0) {
+        console.error(colors.green("  integrations: ["));
+        console.error(colors.green(rendererIntegrations));
+        console.error(colors.green("  ],"));
+      } else {
+        console.error(colors.green("  integrations: [],"));
+      }
+      console.error("");
+    } catch (err) {
+    }
+    process.exit(1);
+  }
   const AstroConfigRelativeSchema = AstroConfigSchema.extend({
     projectRoot: z.string().default(".").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
     src: z.string().default("./src").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
     pages: z.string().default("./src/pages").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
     public: z.string().default("./public").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
-    dist: z.string().default("./dist").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot))
+    dist: z.string().default("./dist").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
+    styleOptions: z.object({
+      postcss: z.preprocess((val) => resolvePostcssConfig(val, fileProtocolRoot), z.object({
+        options: z.any(),
+        plugins: z.array(z.any())
+      }).optional().default({ options: {}, plugins: [] }))
+    }).optional().default({})
+  });
+  return __spreadProps(__spreadValues({}, await AstroConfigRelativeSchema.parseAsync(userConfig)), {
+    _ctx: { scripts: [], renderers: [] }
   });
-  return AstroConfigRelativeSchema.parseAsync(userConfig);
 }
 function addTrailingSlash(str) {
   return str.replace(/\/*$/, "/");
@@ -102,6 +188,9 @@ async function loadConfig(configOptions) {
   if (config) {
     userConfig = config.value;
   }
+  return resolveConfig(userConfig, root, flags);
+}
+async function resolveConfig(userConfig, root, flags = {}) {
   const mergedConfig = mergeCLIFlags(userConfig, flags);
   const validatedConfig = await validateConfig(mergedConfig, root);
   return validatedConfig;
@@ -111,9 +200,42 @@ function formatConfigError(err) {
   return `${colors.red("[config]")} Astro found issue(s) with your configuration:
 ${errorList.join("\n")}`;
 }
+function mergeConfigRecursively(defaults, overrides, rootPath) {
+  const merged = __spreadValues({}, defaults);
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
+    }
+    const existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "vite" && rootPath === "") {
+      merged[key] = mergeViteConfig(existing, value);
+      continue;
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
+      continue;
+    }
+    if (isObject(existing) && isObject(value)) {
+      merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function mergeConfig(defaults, overrides, isRoot = true) {
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
+}
 export {
   AstroConfigSchema,
   formatConfigError,
   loadConfig,
+  mergeConfig,
+  resolveConfig,
   validateConfig
 };

package/dist/core/create-vite.js

@@ -9,7 +9,8 @@ import configAliasVitePlugin from "../vite-plugin-config-alias/index.js";
 import markdownVitePlugin from "../vite-plugin-markdown/index.js";
 import jsxVitePlugin from "../vite-plugin-jsx/index.js";
 import envVitePlugin from "../vite-plugin-env/index.js";
-import { resolveDependency } from "./util.js";
+import astroScriptsPlugin from "../vite-plugin-scripts/index.js";
+import astroIntegrationsContainerPlugin from "../vite-plugin-integrations-container/index.js";
 const ALWAYS_EXTERNAL = /* @__PURE__ */ new Set([
   ...builtinModules.map((name) => `node:${name}`),
   "@sveltejs/vite-plugin-svelte",
@@ -25,9 +26,9 @@ const ALWAYS_EXTERNAL = /* @__PURE__ */ new Set([
 const ALWAYS_NOEXTERNAL = /* @__PURE__ */ new Set([
   "astro"
 ]);
-async function createVite(inlineConfig, { astroConfig, logging, mode }) {
+async function createVite(commandConfig, { astroConfig, logging, mode }) {
   const astroPackages = await getAstroPackages(astroConfig);
-  let viteConfig = {
+  const commonConfig = {
     cacheDir: fileURLToPath(new URL("./node_modules/.vite/", astroConfig.projectRoot)),
     clearScreen: false,
     logLevel: "warn",
@@ -37,11 +38,13 @@ async function createVite(inlineConfig, { astroConfig, logging, mode }) {
     plugins: [
       configAliasVitePlugin({ config: astroConfig }),
       astroVitePlugin({ config: astroConfig, logging }),
+      astroScriptsPlugin({ config: astroConfig }),
       mode === "dev" && astroViteServerPlugin({ config: astroConfig, logging }),
       envVitePlugin({ config: astroConfig }),
       markdownVitePlugin({ config: astroConfig }),
       jsxVitePlugin({ config: astroConfig, logging }),
-      astroPostprocessVitePlugin({ config: astroConfig })
+      astroPostprocessVitePlugin({ config: astroConfig }),
+      astroIntegrationsContainerPlugin({ config: astroConfig })
     ],
     publicDir: fileURLToPath(astroConfig.public),
     root: fileURLToPath(astroConfig.projectRoot),
@@ -51,29 +54,18 @@ async function createVite(inlineConfig, { astroConfig, logging, mode }) {
       hmr: process.env.NODE_ENV === "test" || process.env.NODE_ENV === "production" ? false : void 0,
       proxy: {}
     },
+    css: {
+      postcss: astroConfig.styleOptions.postcss || {}
+    },
     ssr: {
       external: [...ALWAYS_EXTERNAL],
       noExternal: [...ALWAYS_NOEXTERNAL, ...astroPackages]
     }
   };
-  for (const name of astroConfig.renderers) {
-    try {
-      const { default: renderer } = await import(resolveDependency(name, astroConfig));
-      if (!renderer)
-        continue;
-      if (renderer.viteConfig) {
-        if (typeof renderer.viteConfig !== "function") {
-          throw new Error(`${name}: viteConfig(options) must be a function! Got ${typeof renderer.viteConfig}.`);
-        }
-        const rendererConfig = await renderer.viteConfig({ mode: inlineConfig.mode, command: inlineConfig.mode === "production" ? "build" : "serve" });
-        viteConfig = vite.mergeConfig(viteConfig, rendererConfig);
-      }
-    } catch (err) {
-      throw new Error(`${name}: ${err}`);
-    }
-  }
-  viteConfig = vite.mergeConfig(viteConfig, inlineConfig);
-  return viteConfig;
+  let result = commonConfig;
+  result = vite.mergeConfig(result, astroConfig.vite || {});
+  result = vite.mergeConfig(result, commandConfig);
+  return result;
 }
 async function getAstroPackages({ projectRoot }) {
   const pkgUrl = new URL("./package.json", projectRoot);