astro 0.25.4 → 0.26.0

package/dist/core/build/index.js

@@ -4,41 +4,39 @@ import { apply as applyPolyfill } from "../polyfill.js";
 import { performance } from "perf_hooks";
 import * as vite from "vite";
 import { createVite } from "../create-vite.js";
-import { debug, defaultLogOptions, info, levels, timerMessage, warn, warnIfUsingExperimentalSSR } from "../logger.js";
+import { debug, info, levels, timerMessage, warnIfUsingExperimentalSSR } from "../logger/core.js";
+import { nodeLogOptions } from "../logger/node.js";
 import { createRouteManifest } from "../routing/index.js";
-import { generateSitemap } from "../render/sitemap.js";
 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";
 import { getTimeStat } from "./util.js";
-async function build(config, options = { logging: defaultLogOptions }) {
+import { createSafeError, isBuildingToSSR } from "../util.js";
+import { fixViteErrorMessage } from "../errors.js";
+async function build(config, options = { logging: nodeLogOptions }) {
+  applyPolyfill();
   const builder = new AstroBuilder(config, options);
-  await builder.build();
+  await builder.run();
 }
 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`);
-    }
-    if (options.mode)
+    if (options.mode) {
       this.mode = options.mode;
+    }
     this.config = config;
-    const port = config.devOptions.port;
     this.logging = options.logging;
     this.routeCache = new RouteCache(this.logging);
-    this.origin = config.buildOptions.site ? new URL(config.buildOptions.site).origin : `http://localhost:${port}`;
+    this.origin = config.site ? new URL(config.site).origin : `http://localhost:${config.server.port}`;
     this.manifest = createRouteManifest({ config }, this.logging);
+    this.timer = {};
   }
-  async build() {
-    info(this.logging, "build", "Initial setup...");
-    const { logging, origin } = this;
-    const timer = {};
-    timer.init = performance.now();
-    timer.viteStart = performance.now();
+  async setup() {
+    debug("build", "Initial setup...");
+    const { logging } = this;
+    this.timer.init = performance.now();
+    this.timer.viteStart = performance.now();
     this.config = await runHookConfigSetup({ config: this.config, command: "build" });
     const viteConfig = await createVite({
       mode: this.mode,
@@ -49,66 +47,55 @@ class AstroBuilder {
     }, { astroConfig: this.config, logging, mode: "build" });
     await runHookConfigDone({ config: this.config });
     warnIfUsingExperimentalSSR(logging, this.config);
-    this.viteConfig = viteConfig;
     const viteServer = await vite.createServer(viteConfig);
-    this.viteServer = viteServer;
-    debug("build", timerMessage("Vite started", timer.viteStart));
+    debug("build", timerMessage("Vite started", this.timer.viteStart));
+    return { viteConfig, viteServer };
+  }
+  async build({ viteConfig, viteServer }) {
+    const { origin } = this;
     const buildConfig = {
-      client: new URL("./client/", this.config.dist),
-      server: new URL("./server/", this.config.dist),
+      client: new URL("./client/", this.config.outDir),
+      server: new URL("./server/", this.config.outDir),
       serverEntry: "entry.mjs",
       staticMode: void 0
     };
     await runHookBuildStart({ config: this.config, buildConfig });
-    info(this.logging, "build", "Collecting page data...");
-    timer.loadStart = performance.now();
+    info(this.logging, "build", "Collecting build information...");
+    this.timer.loadStart = performance.now();
     const { assets, allPages } = await collectPagesData({
       astroConfig: this.config,
       logging: this.logging,
       manifest: this.manifest,
       origin,
       routeCache: this.routeCache,
-      viteServer: this.viteServer,
-      ssr: this.config.buildOptions.experimentalSsr
+      viteServer,
+      ssr: isBuildingToSSR(this.config)
     });
     Object.entries(allPages).forEach(([page, data]) => {
       if ("frontmatter" in data.preload[1]) {
         const frontmatter = data.preload[1].frontmatter;
-        if (Boolean(frontmatter.draft) && !this.config.buildOptions.drafts) {
-          debug("build", timerMessage(`Skipping draft page ${page}`, timer.loadStart));
+        if (Boolean(frontmatter.draft) && !this.config.markdown.drafts) {
+          debug("build", timerMessage(`Skipping draft page ${page}`, this.timer.loadStart));
           delete allPages[page];
         }
       }
     });
-    debug("build", timerMessage("All pages loaded", timer.loadStart));
+    debug("build", timerMessage("All pages loaded", this.timer.loadStart));
     const pageNames = [];
-    timer.buildStart = performance.now();
-    info(this.logging, "build", colors.dim(`Completed in ${getTimeStat(timer.init, performance.now())}`));
-    if (!this.config.buildOptions.legacyBuild) {
-      await staticBuild({
-        allPages,
-        astroConfig: this.config,
-        logging: this.logging,
-        manifest: this.manifest,
-        origin: this.origin,
-        pageNames,
-        routeCache: this.routeCache,
-        viteConfig: this.viteConfig,
-        buildConfig
-      });
-    } else {
-      await scanBasedBuild({
-        allPages,
-        astroConfig: this.config,
-        logging: this.logging,
-        origin: this.origin,
-        pageNames,
-        routeCache: this.routeCache,
-        viteConfig: this.viteConfig,
-        viteServer: this.viteServer
-      });
-    }
-    timer.assetsStart = performance.now();
+    this.timer.buildStart = performance.now();
+    info(this.logging, "build", colors.dim(`Completed in ${getTimeStat(this.timer.init, performance.now())}.`));
+    await staticBuild({
+      allPages,
+      astroConfig: this.config,
+      logging: this.logging,
+      manifest: this.manifest,
+      origin: this.origin,
+      pageNames,
+      routeCache: this.routeCache,
+      viteConfig,
+      buildConfig
+    });
+    this.timer.assetsStart = performance.now();
     Object.keys(assets).map((k) => {
       if (!assets[k])
         return;
@@ -117,21 +104,21 @@ class AstroBuilder {
       fs.writeFileSync(filePath, assets[k], "utf8");
       delete assets[k];
     });
-    debug("build", timerMessage("Additional assets copied", timer.assetsStart));
-    if (this.config.buildOptions.sitemap && this.config.buildOptions.site) {
-      timer.sitemapStart = performance.now();
-      const sitemapFilter = this.config.buildOptions.sitemapFilter ? this.config.buildOptions.sitemapFilter : void 0;
-      const sitemap = generateSitemap(pageNames.map((pageName) => new URL(pageName, this.config.buildOptions.site).href), sitemapFilter);
-      const sitemapPath = new URL("./sitemap.xml", this.config.dist);
-      await fs.promises.mkdir(new URL("./", sitemapPath), { recursive: true });
-      await fs.promises.writeFile(sitemapPath, sitemap, "utf8");
-      debug("build", timerMessage("Sitemap built", timer.sitemapStart));
-    }
+    debug("build", timerMessage("Additional assets copied", this.timer.assetsStart));
     await viteServer.close();
     await runHookBuildDone({ config: this.config, pages: pageNames, routes: Object.values(allPages).map((pd) => pd.route) });
-    if (logging.level && levels[logging.level] <= levels["info"]) {
-      const buildMode = this.config.buildOptions.experimentalSsr ? "ssr" : "static";
-      await this.printStats({ logging, timeStart: timer.init, pageCount: pageNames.length, buildMode });
+    if (this.logging.level && levels[this.logging.level] <= levels["info"]) {
+      const buildMode = isBuildingToSSR(this.config) ? "ssr" : "static";
+      await this.printStats({ logging: this.logging, timeStart: this.timer.init, pageCount: pageNames.length, buildMode });
+    }
+  }
+  async run() {
+    const setupData = await this.setup();
+    try {
+      await this.build(setupData);
+    } catch (_err) {
+      debugger;
+      throw fixViteErrorMessage(createSafeError(_err), setupData.viteServer);
     }
   }
   async printStats({ logging, timeStart, pageCount, buildMode }) {
@@ -139,14 +126,12 @@ class AstroBuilder {
     const total = getTimeStat(timeStart, performance.now());
     let messages = [];
     if (buildMode === "static") {
-      const timePerPage = Math.round(buildTime / pageCount);
-      const perPageMsg = colors.dim(`(${colors.bold(`${timePerPage}ms`)} avg per page + resources)`);
-      messages = [`${pageCount} pages built in`, colors.bold(total), perPageMsg];
+      messages = [`${pageCount} page(s) built in`, colors.bold(total)];
     } else {
       messages = ["Server built in", colors.bold(total)];
     }
     info(logging, "build", messages.join(" "));
-    info(logging, "build", `\u{1F680} ${colors.cyan(colors.bold("Done"))}`);
+    info(logging, "build", `${colors.bold("Complete!")}`);
   }
 }
 export {

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

@@ -1,16 +1,17 @@
-import { info } from "../logger.js";
+import { info } from "../logger/core.js";
 import { fileURLToPath } from "url";
 import * as colors from "kleur/colors";
-import { debug } from "../logger.js";
+import { debug } from "../logger/core.js";
 import { preload as ssrPreload } from "../render/dev/index.js";
 import { generateRssFunction } from "../render/rss.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
+import { isBuildingToSSR } from "../util.js";
 async function collectPagesData(opts) {
   var _a;
   const { astroConfig, logging, manifest, origin, routeCache, viteServer } = opts;
   const assets = {};
   const allPages = {};
-  const buildMode = astroConfig.buildOptions.experimentalSsr ? "ssr" : "static";
+  const buildMode = isBuildingToSSR(astroConfig) ? "ssr" : "static";
   const dataCollectionLogTimeout = setInterval(() => {
     info(opts.logging, "build", "The data collection step may take longer for larger projects...");
     clearInterval(dataCollectionLogTimeout);
@@ -31,7 +32,7 @@ async function collectPagesData(opts) {
         scripts: /* @__PURE__ */ new Set(),
         preload: await ssrPreload({
           astroConfig,
-          filePath: new URL(`./${route.component}`, astroConfig.projectRoot),
+          filePath: new URL(`./${route.component}`, astroConfig.root),
           viteServer
         }).then((routes) => {
           clearInterval(routeCollectionLogTimeout);
@@ -58,13 +59,13 @@ async function collectPagesData(opts) {
       debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.red("\u2717"))} ${route.component}`);
       throw err;
     });
-    const rssFn = generateRssFunction(astroConfig.buildOptions.site, route);
+    const rssFn = generateRssFunction(astroConfig.site, route);
     for (const rssCallArg of result.rss) {
       const rssResult = rssFn(rssCallArg);
       if (rssResult.xml) {
         const { url, content } = rssResult.xml;
         if (content) {
-          const rssFile = new URL(url.replace(/^\/?/, "./"), astroConfig.dist);
+          const rssFile = new URL(url.replace(/^\/?/, "./"), astroConfig.outDir);
           if (assets[fileURLToPath(rssFile)]) {
             throw new Error(`[getStaticPaths] RSS feed ${url} already exists.
 Use \`rss(data, {url: '...'})\` to choose a unique, custom URL. (${route.component})`);
@@ -74,7 +75,7 @@ Use \`rss(data, {url: '...'})\` to choose a unique, custom URL. (${route.compone
       }
       if ((_a = rssResult.xsl) == null ? void 0 : _a.content) {
         const { url, content } = rssResult.xsl;
-        const stylesheetFile = new URL(url.replace(/^\/?/, "./"), astroConfig.dist);
+        const stylesheetFile = new URL(url.replace(/^\/?/, "./"), astroConfig.outDir);
         if (assets[fileURLToPath(stylesheetFile)]) {
           throw new Error(`[getStaticPaths] RSS feed stylesheet ${url} already exists.
 Use \`rss(data, {stylesheet: '...'})\` to choose a unique, custom URL. (${route.component})`);
@@ -93,7 +94,7 @@ Use \`rss(data, {stylesheet: '...'})\` to choose a unique, custom URL. (${route.
       scripts: /* @__PURE__ */ new Set(),
       preload: await ssrPreload({
         astroConfig,
-        filePath: new URL(`./${route.component}`, astroConfig.projectRoot),
+        filePath: new URL(`./${route.component}`, astroConfig.root),
         viteServer
       })
     };
@@ -105,7 +106,7 @@ async function getStaticPathsForRoute(opts, route) {
   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 filePath = new URL(`./${route.component}`, astroConfig.root);
   const mod = await viteServer.ssrLoadModule(fileURLToPath(filePath));
   const result = await callGetStaticPaths({ mod, route, isValidate: false, logging, ssr });
   routeCache.set(route, result);

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

@@ -24,8 +24,8 @@ import npath from "path";
 import { fileURLToPath } from "url";
 import * as vite from "vite";
 import { createBuildInternals } from "../../core/build/internal.js";
-import { info } from "../../core/logger.js";
-import { appendForwardSlash, prependForwardSlash } from "../../core/path.js";
+import { info } from "../logger/core.js";
+import { prependForwardSlash } from "../../core/path.js";
 import { emptyDir, removeDir } from "../../core/util.js";
 import { rollupPluginAstroBuildCSS } from "../../vite-plugin-build-css/index.js";
 import { vitePluginHoistedScripts } from "./vite-plugin-hoisted-scripts.js";
@@ -35,6 +35,7 @@ import { vitePluginPages } from "./vite-plugin-pages.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { isBuildingToSSR } from "../util.js";
+import { runHookBuildSetup } from "../../integrations/index.js";
 import { getTimeStat } from "./util.js";
 async function staticBuild(opts) {
   const { allPages, astroConfig } = opts;
@@ -44,9 +45,8 @@ async function staticBuild(opts) {
   const internals = createBuildInternals();
   const timer = {};
   timer.buildStart = performance.now();
-  info(opts.logging, "build", "Discovering entrypoints...");
   for (const [component, pageData] of Object.entries(allPages)) {
-    const astroModuleURL = new URL("./" + component, astroConfig.projectRoot);
+    const astroModuleURL = new URL("./" + component, astroConfig.root);
     const astroModuleId = prependForwardSlash(component);
     trackPageData(internals, component, pageData, astroModuleId, astroModuleURL);
     if (pageData.route.type === "page") {
@@ -71,13 +71,13 @@ async function staticBuild(opts) {
     pageInput.add(astroModuleId);
     facadeIdToPageDataMap.set(fileURLToPath(astroModuleURL), pageData);
   }
-  emptyDir(astroConfig.dist, new Set(".git"));
+  emptyDir(astroConfig.outDir, new Set(".git"));
   timer.clientBuild = performance.now();
   await clientBuild(opts, internals, jsInput);
   timer.ssr = performance.now();
   info(opts.logging, "build", "Building for SSR...");
   const ssrResult = await ssrBuild(opts, internals, pageInput);
-  info(opts.logging, "build", dim(`Completed in ${getTimeStat(timer.ssr, performance.now())}`));
+  info(opts.logging, "build", dim(`Completed in ${getTimeStat(timer.ssr, performance.now())}.`));
   timer.generate = performance.now();
   if (opts.buildConfig.staticMode) {
     await generatePages(ssrResult, opts, internals, facadeIdToPageDataMap);
@@ -88,14 +88,12 @@ ${bgMagenta(black(" finalizing server assets "))}
 `);
     await ssrMoveAssets(opts);
   }
-  info(opts.logging, null, dim(`Completed in ${getTimeStat(timer.generate, performance.now())}
-`));
 }
 async function ssrBuild(opts, internals, input) {
   const { astroConfig, viteConfig } = opts;
-  const ssr = astroConfig.buildOptions.experimentalSsr;
-  const out = ssr ? opts.buildConfig.server : astroConfig.dist;
-  return await vite.build({
+  const ssr = isBuildingToSSR(astroConfig);
+  const out = ssr ? opts.buildConfig.server : astroConfig.outDir;
+  const viteBuildConfig = {
     logLevel: "error",
     mode: "production",
     css: viteConfig.css,
@@ -103,7 +101,6 @@ async function ssrBuild(opts, internals, input) {
       emptyOutDir: false,
       manifest: false,
       outDir: fileURLToPath(out),
-      ssr: true,
       rollupOptions: {
         input: [],
         output: {
@@ -113,6 +110,7 @@ async function ssrBuild(opts, internals, input) {
           assetFileNames: "assets/asset.[hash][extname]"
         }
       },
+      ssr: true,
       target: "esnext",
       minify: false,
       polyfillModulePreload: false,
@@ -132,21 +130,27 @@ async function ssrBuild(opts, internals, input) {
     root: viteConfig.root,
     envPrefix: "PUBLIC_",
     server: viteConfig.server,
-    base: astroConfig.buildOptions.site ? new URL(astroConfig.buildOptions.site).pathname : "/",
-    ssr: viteConfig.ssr
-  });
+    base: astroConfig.site ? new URL(astroConfig.site).pathname : "/",
+    ssr: viteConfig.ssr,
+    resolve: viteConfig.resolve
+  };
+  await runHookBuildSetup({ config: astroConfig, vite: viteBuildConfig, target: "server" });
+  return await vite.build(viteBuildConfig);
 }
 async function clientBuild(opts, internals, input) {
   const { astroConfig, viteConfig } = opts;
   const timer = performance.now();
+  const ssr = isBuildingToSSR(astroConfig);
+  const out = ssr ? opts.buildConfig.client : astroConfig.outDir;
   if (!input.size) {
+    if (ssr) {
+      await copyFiles(astroConfig.publicDir, out);
+    }
     return null;
   }
   info(opts.logging, null, `
-${bgGreen(black(" building resources "))}
-`);
-  const out = isBuildingToSSR(astroConfig) ? opts.buildConfig.client : astroConfig.dist;
-  const buildResult = await vite.build({
+${bgGreen(black(" building client "))}`);
+  const viteBuildConfig = {
     logLevel: "info",
     mode: "production",
     css: viteConfig.css,
@@ -179,21 +183,34 @@ ${bgGreen(black(" building resources "))}
     root: viteConfig.root,
     envPrefix: "PUBLIC_",
     server: viteConfig.server,
-    base: appendForwardSlash(astroConfig.buildOptions.site ? new URL(astroConfig.buildOptions.site).pathname : "/")
-  });
-  info(opts.logging, null, dim(`Completed in ${getTimeStat(timer, performance.now())}
+    base: astroConfig.base
+  };
+  await runHookBuildSetup({ config: astroConfig, vite: viteBuildConfig, target: "client" });
+  const buildResult = await vite.build(viteBuildConfig);
+  info(opts.logging, null, dim(`Completed in ${getTimeStat(timer, performance.now())}.
 `));
   return buildResult;
 }
 async function cleanSsrOutput(opts) {
   const files = await glob("**/*.mjs", {
-    cwd: fileURLToPath(opts.astroConfig.dist)
+    cwd: fileURLToPath(opts.astroConfig.outDir)
   });
   await Promise.all(files.map(async (filename) => {
-    const url = new URL(filename, opts.astroConfig.dist);
+    const url = new URL(filename, opts.astroConfig.outDir);
     await fs.promises.rm(url);
   }));
 }
+async function copyFiles(fromFolder, toFolder) {
+  const files = await glob("**/*", {
+    cwd: fileURLToPath(fromFolder)
+  });
+  await fs.promises.mkdir(toFolder, { recursive: true });
+  await Promise.all(files.map(async (filename) => {
+    const from = new URL(filename, fromFolder);
+    const to = new URL(filename, toFolder);
+    return fs.promises.copyFile(from, to);
+  }));
+}
 async function ssrMoveAssets(opts) {
   info(opts.logging, "build", "Rearranging server assets...");
   const serverRoot = opts.buildConfig.staticMode ? opts.buildConfig.client : opts.buildConfig.server;

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

@@ -28,7 +28,7 @@ function vitePluginHoistedScripts(astroConfig, internals) {
         if (output.type === "chunk" && output.facadeModuleId && virtualHoistedEntry(output.facadeModuleId)) {
           const facadeId = output.facadeModuleId;
           const pathname = facadeId.slice(0, facadeId.length - "/hoisted.js".length);
-          const vid = viteID(new URL("." + pathname, astroConfig.projectRoot));
+          const vid = viteID(new URL("." + pathname, astroConfig.root));
           const pageInfo = getPageDataByViteID(internals, vid);
           if (pageInfo) {
             pageInfo.hoistedScript = id;

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

@@ -1,3 +1,4 @@
+import astroRemark from "@astrojs/markdown-remark";
 import { serializeRouteData } from "../routing/index.js";
 import { eachPageData } from "./internal.js";
 import { addRollupInput } from "./add-rollup-input.js";
@@ -9,6 +10,7 @@ const manifestReplace = "@@ASTRO_MANIFEST_REPLACE@@";
 function vitePluginSSR(buildOpts, internals, adapter) {
   return {
     name: "@astrojs/vite-plugin-astro-ssr",
+    enforce: "post",
     options(opts) {
       return addRollupInput(opts, [virtualModuleId]);
     },
@@ -73,9 +75,9 @@ function buildManifest(opts, internals) {
   entryModules[BEFORE_HYDRATION_SCRIPT_ID] = "data:text/javascript;charset=utf-8,//[no before-hydration script]";
   const ssrManifest = {
     routes,
-    site: astroConfig.buildOptions.site,
+    site: astroConfig.site,
     markdown: {
-      render: astroConfig.markdownOptions.render
+      render: [astroRemark, astroConfig.markdown]
     },
     pageMap: null,
     renderers: [],