astro 0.25.4 → 0.26.0

package/dist/cli/check.js

@@ -42,13 +42,13 @@ function offsetAt({ line, character }, text) {
   }
   return i;
 }
-function pad(str, len) {
+function generateString(str, len) {
   return Array.from({ length: len }, () => str).join("");
 }
 async function run() {
 }
 async function check(astroConfig) {
-  const root = astroConfig.projectRoot;
+  const root = astroConfig.root;
   let checker = new AstroCheck(root.toString());
   await openAllDocuments(root, [], checker);
   let diagnostics = await checker.getDiagnostics();
@@ -67,8 +67,8 @@ async function check(astroConfig) {
           const lineNumStr = d.range.start.line.toString();
           const lineNumLen = lineNumStr.length;
           console.error(`${bgWhite(black(lineNumStr))}  ${str}`);
-          let tildes = pad("~", d.range.end.character - d.range.start.character);
-          let spaces = pad(" ", d.range.start.character + lineNumLen - 1);
+          let tildes = generateString("~", d.range.end.character - d.range.start.character);
+          let spaces = generateString(" ", d.range.start.character + lineNumLen - 1);
           console.error(`   ${spaces}${bold(red(tildes))}
 `);
           result.errors++;

package/dist/cli/index.js

@@ -1,15 +1,15 @@
-import { enableVerboseLogging } from "../core/logger.js";
 import * as colors from "kleur/colors";
 import yargs from "yargs-parser";
 import { z } from "zod";
-import { defaultLogDestination } from "../core/logger.js";
+import { nodeLogDestination, enableVerboseLogging } from "../core/logger/node.js";
 import build from "../core/build/index.js";
 import add from "../core/add/index.js";
 import devServer from "../core/dev/index.js";
 import preview from "../core/preview/index.js";
 import { check } from "./check.js";
-import { formatConfigError, loadConfig } from "../core/config.js";
-import { printHelp } from "../core/messages.js";
+import { loadConfig } from "../core/config.js";
+import { printHelp, formatErrorMessage, formatConfigErrorMessage } from "../core/messages.js";
+import { createSafeError } from "../core/util.js";
 function printAstroHelp() {
   printHelp({
     commandName: "astro",
@@ -26,10 +26,9 @@ function printAstroHelp() {
     flags: [
       ["--host [optional IP]", "Expose server on network"],
       ["--config <path>", "Specify the path to the Astro config file."],
-      ["--project-root <path>", "Specify the path to the project root folder."],
-      ["--no-sitemap", "Disable sitemap generation (build only)."],
+      ["--root <path>", "Specify the path to the project root folder."],
       ["--legacy-build", "Use the build strategy prior to 0.24.0"],
-      ["--experimental-ssr", "Enable SSR compilation."],
+      ["--experimental-ssr", "Enable SSR compilation fot 3rd-party adapters."],
       ["--drafts", "Include markdown draft pages in the build."],
       ["--verbose", "Enable verbose logging"],
       ["--silent", "Disable logging"]
@@ -37,7 +36,7 @@ function printAstroHelp() {
   });
 }
 async function printVersion() {
-  const version = "0.25.4";
+  const version = "0.26.0";
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${version}`)}`);
 }
@@ -58,7 +57,7 @@ function resolveCommand(flags) {
 async function cli(args) {
   const flags = yargs(args);
   const cmd = resolveCommand(flags);
-  const projectRoot = flags.projectRoot;
+  const root = flags.root;
   switch (cmd) {
     case "help":
       printAstroHelp();
@@ -68,7 +67,7 @@ async function cli(args) {
       return process.exit(0);
   }
   let logging = {
-    dest: defaultLogDestination,
+    dest: nodeLogDestination,
     level: "info"
   };
   if (flags.verbose) {
@@ -79,40 +78,34 @@ async function cli(args) {
   }
   let config;
   try {
-    config = await loadConfig({ cwd: projectRoot, flags });
+    config = await loadConfig({ cwd: root, flags, cmd });
   } catch (err) {
-    throwAndExit(err);
-    return;
+    return throwAndExit(err);
   }
   switch (cmd) {
     case "add": {
       try {
         const packages = flags._.slice(3);
-        await add(packages, { cwd: projectRoot, flags, logging });
-        process.exit(0);
+        return await add(packages, { cwd: root, flags, logging });
       } catch (err) {
-        throwAndExit(err);
+        return throwAndExit(err);
       }
-      return;
     }
     case "dev": {
       try {
         await devServer(config, { logging });
-        await new Promise(() => {
+        return await new Promise(() => {
         });
       } catch (err) {
-        throwAndExit(err);
+        return throwAndExit(err);
       }
-      return;
     }
     case "build": {
       try {
-        await build(config, { logging });
-        process.exit(0);
+        return await build(config, { logging });
       } catch (err) {
-        throwAndExit(err);
+        return throwAndExit(err);
       }
-      return;
     }
     case "check": {
       const ret = await check(config);
@@ -120,11 +113,10 @@ async function cli(args) {
     }
     case "preview": {
       try {
-        await preview(config, { logging });
+        return await preview(config, { logging });
       } catch (err) {
-        throwAndExit(err);
+        return throwAndExit(err);
       }
-      return;
     }
     default: {
       throw new Error(`Error running ${cmd}`);
@@ -133,12 +125,9 @@ async function cli(args) {
 }
 function throwAndExit(err) {
   if (err instanceof z.ZodError) {
-    console.error(formatConfigError(err));
-  } else if (err.stack) {
-    const [mainMsg, ...stackMsg] = err.stack.split("\n");
-    console.error(colors.red(mainMsg) + "\n" + colors.dim(stackMsg.join("\n")));
+    console.error(formatConfigErrorMessage(err));
   } else {
-    console.error(colors.red(err.toString() || err));
+    console.error(formatErrorMessage(createSafeError(err)));
   }
   process.exit(1);
 }

package/dist/core/add/index.js

@@ -9,11 +9,11 @@ import preferredPM from "preferred-pm";
 import ora from "ora";
 import { resolveConfigURL } from "../config.js";
 import { apply as applyPolyfill } from "../polyfill.js";
-import { error, info, debug } from "../logger.js";
+import { error, info, debug } from "../logger/core.js";
 import { printHelp } from "../messages.js";
 import * as msg from "../messages.js";
 import * as CONSTS from "./consts.js";
-import { dim, red, cyan, green, magenta, bold } from "kleur/colors";
+import { dim, cyan, green, magenta, bold } from "kleur/colors";
 import { parseNpmName } from "../util.js";
 import { wrapDefaultExport } from "./wrapper.js";
 import { ensureImport } from "./imports.js";
@@ -54,18 +54,11 @@ async function add(names, { cwd, flags, logging }) {
         choices: CONSTS.FIRST_PARTY_ADDONS
       }
     ]);
-    if (!response.frameworks && !response.addons) {
-      info(logging, null, msg.cancelled(`Integrations skipped.`, `You can always run ${cyan("astro add")} later!`));
-      return;
-    }
-    const selected = [response.frameworks ?? [], response.addons ?? []].flat(1);
-    if (selected.length === 0) {
-      error(logging, null, `
-${red("No integrations specified!")}
-${dim("Try running")} astro add again.`);
-      return;
-    }
-    names = selected;
+    names = [...response.frameworks ?? [], ...response.addons ?? []];
+  }
+  if (names.length === 0) {
+    error(logging, null, `No integrations specified.`);
+    return;
   }
   names = names.map((name) => CONSTS.ALIASES.has(name) ? CONSTS.ALIASES.get(name) : name);
   if (configURL) {

package/dist/core/app/index.js

@@ -20,9 +20,9 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _manifest, _manifestData, _routeDataToRouteInfo, _routeCache, _encoder, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
+var _manifest, _manifestData, _routeDataToRouteInfo, _routeCache, _encoder, _logging, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
-import { defaultLogOptions } from "../logger.js";
+import { consoleLogDestination } from "../logger/console.js";
 import { deserializeManifest } from "./common.js";
 import { matchRoute } from "../routing/match.js";
 import { render } from "../render/core.js";
@@ -39,12 +39,16 @@ class App {
     __privateAdd(this, _routeDataToRouteInfo, void 0);
     __privateAdd(this, _routeCache, void 0);
     __privateAdd(this, _encoder, new TextEncoder());
+    __privateAdd(this, _logging, {
+      dest: consoleLogDestination,
+      level: "info"
+    });
     __privateSet(this, _manifest, manifest);
     __privateSet(this, _manifestData, {
       routes: manifest.routes.map((route) => route.routeData)
     });
     __privateSet(this, _routeDataToRouteInfo, new Map(manifest.routes.map((route) => [route.routeData, route])));
-    __privateSet(this, _routeCache, new RouteCache(defaultLogOptions));
+    __privateSet(this, _routeCache, new RouteCache(__privateGet(this, _logging)));
   }
   match(request) {
     const url = new URL(request.url);
@@ -75,6 +79,7 @@ _manifestData = new WeakMap();
 _routeDataToRouteInfo = new WeakMap();
 _routeCache = new WeakMap();
 _encoder = new WeakMap();
+_logging = new WeakMap();
 _renderPage = new WeakSet();
 renderPage_fn = async function(request, routeData, mod) {
   const url = new URL(request.url);
@@ -86,7 +91,7 @@ renderPage_fn = async function(request, routeData, mod) {
   const result = await render({
     legacyBuild: false,
     links,
-    logging: defaultLogOptions,
+    logging: __privateGet(this, _logging),
     markdownRender: manifest.markdown.render,
     mod,
     origin: url.origin,
@@ -104,8 +109,7 @@ renderPage_fn = async function(request, routeData, mod) {
     routeCache: __privateGet(this, _routeCache),
     site: __privateGet(this, _manifest).site,
     ssr: true,
-    method: info.routeData.type === "endpoint" ? "" : "GET",
-    headers: request.headers
+    request
   });
   if (result.type === "response") {
     return result.response;
@@ -121,15 +125,14 @@ renderPage_fn = async function(request, routeData, mod) {
   });
 };
 _callEndpoint = new WeakSet();
-callEndpoint_fn = async function(request, routeData, mod) {
+callEndpoint_fn = async function(request, _routeData, mod) {
   const url = new URL(request.url);
   const handler = mod;
   const result = await callEndpoint(handler, {
-    headers: request.headers,
-    logging: defaultLogOptions,
-    method: request.method,
+    logging: __privateGet(this, _logging),
     origin: url.origin,
     pathname: url.pathname,
+    request,
     routeCache: __privateGet(this, _routeCache),
     ssr: true
   });

package/dist/core/build/common.js

@@ -2,7 +2,7 @@ import npath from "path";
 import { appendForwardSlash } from "../../core/path.js";
 const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
 function getOutRoot(astroConfig) {
-  return new URL("./", astroConfig.dist);
+  return new URL("./", astroConfig.outDir);
 }
 function getOutFolder(astroConfig, pathname, routeType) {
   const outRoot = getOutRoot(astroConfig);
@@ -10,7 +10,7 @@ function getOutFolder(astroConfig, pathname, routeType) {
     case "endpoint":
       return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
     case "page":
-      switch (astroConfig.buildOptions.pageUrlFormat) {
+      switch (astroConfig.build.format) {
         case "directory": {
           if (STATUS_CODE_PAGES.has(pathname)) {
             return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
@@ -28,7 +28,7 @@ function getOutFile(astroConfig, outFolder, pathname, routeType) {
     case "endpoint":
       return new URL(npath.basename(pathname), outFolder);
     case "page":
-      switch (astroConfig.buildOptions.pageUrlFormat) {
+      switch (astroConfig.build.format) {
         case "directory": {
           if (STATUS_CODE_PAGES.has(pathname)) {
             const baseName = npath.basename(pathname);
@@ -45,6 +45,5 @@ function getOutFile(astroConfig, outFolder, pathname, routeType) {
 }
 export {
   getOutFile,
-  getOutFolder,
-  getOutRoot
+  getOutFolder
 };

package/dist/core/build/generate.js

@@ -1,16 +1,19 @@
+import astroRemark from "@astrojs/markdown-remark";
 import fs from "fs";
+import { bgGreen, black, cyan, dim, green, magenta } from "kleur/colors";
 import npath from "path";
 import { fileURLToPath } from "url";
-import { debug, error, info } from "../../core/logger.js";
+import { debug, info } from "../logger/core.js";
 import { prependForwardSlash } from "../../core/path.js";
 import { BEFORE_HYDRATION_SCRIPT_ID } from "../../vite-plugin-scripts/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 { getOutputFilename, isBuildingToSSR } from "../util.js";
 import { getOutFile, getOutFolder } from "./common.js";
-import { getPageDataByComponent, eachPageData } from "./internal.js";
-import { bgMagenta, black, cyan, dim, magenta } from "kleur/colors";
+import { eachPageData, getPageDataByComponent } from "./internal.js";
 import { getTimeStat } from "./util.js";
+import { createRequest } from "../request.js";
 const MAX_CONCURRENT_RENDERS = 1;
 function* throttle(max, inPaths) {
   let tmp = [];
@@ -30,7 +33,7 @@ function* throttle(max, inPaths) {
   }
 }
 function rootRelativeFacadeId(facadeId, astroConfig) {
-  return facadeId.slice(fileURLToPath(astroConfig.projectRoot).length);
+  return facadeId.slice(fileURLToPath(astroConfig.root).length);
 }
 function chunkIsPage(astroConfig, output, internals) {
   if (output.type !== "chunk") {
@@ -44,18 +47,19 @@ function chunkIsPage(astroConfig, output, internals) {
   return false;
 }
 async function generatePages(result, opts, internals, facadeIdToPageDataMap) {
-  var _a;
+  const timer = performance.now();
   info(opts.logging, null, `
-${bgMagenta(black(" generating static routes "))}
-`);
-  const ssr = !!((_a = opts.astroConfig._ctx.adapter) == null ? void 0 : _a.serverEntrypoint);
+${bgGreen(black(" generating static routes "))}`);
+  const ssr = isBuildingToSSR(opts.astroConfig);
   const serverEntry = opts.buildConfig.serverEntry;
-  const outFolder = ssr ? opts.buildConfig.server : opts.astroConfig.dist;
+  const outFolder = ssr ? opts.buildConfig.server : opts.astroConfig.outDir;
   const ssrEntryURL = new URL("./" + serverEntry + `?time=${Date.now()}`, outFolder);
   const ssrEntry = await import(ssrEntryURL.toString());
   for (const pageData of eachPageData(internals)) {
     await generatePage(opts, internals, pageData, ssrEntry);
   }
+  info(opts.logging, null, dim(`Completed in ${getTimeStat(timer, performance.now())}.
+`));
 }
 async function generatePage(opts, internals, pageData, ssrEntry) {
   let timeStart = performance.now();
@@ -75,24 +79,17 @@ async function generatePage(opts, internals, pageData, ssrEntry) {
     mod: pageModule,
     renderers
   };
-  const icon = pageData.route.type === "page" ? cyan("</>") : magenta("{-}");
+  const icon = pageData.route.type === "page" ? green("\u25B6") : magenta("\u03BB");
   info(opts.logging, null, `${icon} ${pageData.route.component}`);
-  const renderPromises = [];
-  for (const paths of throttle(MAX_CONCURRENT_RENDERS, pageData.paths)) {
-    for (const path of paths) {
-      renderPromises.push(generatePath(path, opts, generationOptions));
-    }
-    await Promise.all(renderPromises);
+  for (let i = 0; i < pageData.paths.length; i++) {
+    const path = pageData.paths[i];
+    await generatePath(path, opts, generationOptions);
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
-    let shouldLogTimeChange = !getTimeStat(timeStart, timeEnd).startsWith("0");
-    for (const path of paths) {
-      const timeIncrease = shouldLogTimeChange ? ` ${dim(`+${timeChange}`)}` : "";
-      info(opts.logging, null, `    ${dim("\u2503")} ${path}${timeIncrease}`);
-      shouldLogTimeChange = false;
-    }
-    timeStart = performance.now();
-    renderPromises.length = 0;
+    const timeIncrease = `(+${timeChange})`;
+    const filePath = getOutputFilename(opts.astroConfig, path);
+    const lineIcon = i === pageData.paths.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+    info(opts.logging, null, `  ${cyan(lineIcon)} ${dim(filePath)} ${dim(timeIncrease)}`);
   }
 }
 function addPageName(pathname, opts) {
@@ -105,7 +102,7 @@ async function generatePath(pathname, opts, gopts) {
     addPageName(pathname, opts);
   }
   debug("build", `Generating: ${pathname}`);
-  const site = astroConfig.buildOptions.site;
+  const site = astroConfig.site;
   const links = createLinkStylesheetElementSet(linkIds.reverse(), site);
   const scripts = createModuleScriptElementWithSrcSet(hoistedId ? [hoistedId] : [], site);
   for (const script of astroConfig._ctx.scripts) {
@@ -116,57 +113,53 @@ async function generatePath(pathname, opts, gopts) {
       });
     }
   }
-  try {
-    const options = {
-      legacyBuild: false,
-      links,
-      logging,
-      markdownRender: astroConfig.markdownOptions.render,
-      mod,
-      origin,
-      pathname,
-      scripts,
-      renderers,
-      async resolve(specifier) {
-        const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
-        if (typeof hashedFilePath !== "string") {
-          if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
-            return "data:text/javascript;charset=utf-8,//[no before-hydration script]";
-          }
-          throw new Error(`Cannot find the built path for ${specifier}`);
+  const url = new URL(origin + pathname);
+  const options = {
+    legacyBuild: false,
+    links,
+    logging,
+    markdownRender: [astroRemark, astroConfig.markdown],
+    mod,
+    origin,
+    pathname,
+    scripts,
+    renderers,
+    async resolve(specifier) {
+      const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
+      if (typeof hashedFilePath !== "string") {
+        if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+          return "data:text/javascript;charset=utf-8,//[no before-hydration script]";
         }
-        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,
-      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;
+        throw new Error(`Cannot find the built path for ${specifier}`);
       }
-      body = result.html;
+      const relPath = npath.posix.relative(pathname, "/" + hashedFilePath);
+      const fullyRelativePath = relPath[0] === "." ? relPath : "./" + relPath;
+      return fullyRelativePath;
+    },
+    request: createRequest({ url, headers: new Headers(), logging }),
+    route: pageData.route,
+    routeCache,
+    site: astroConfig.site ? new URL(astroConfig.base, astroConfig.site).toString() : astroConfig.site,
+    ssr: isBuildingToSSR(opts.astroConfig)
+  };
+  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;
     }
-    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, body, "utf-8");
-  } catch (err) {
-    error(opts.logging, "build", `Error rendering:`, err);
+    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, body, "utf-8");
 }
 export {
   chunkIsPage,