astro 0.25.2 → 0.26.0

package/dist/vite-plugin-astro/compile.js

@@ -13,30 +13,28 @@ const configCache = /* @__PURE__ */ new WeakMap();
 async function compile(config, filename, source, viteTransform, opts) {
   const filenameURL = new URL(`file://${filename}`);
   const normalizedID = fileURLToPath(filenameURL);
-  const pathname = filenameURL.pathname.substr(config.projectRoot.pathname.length - 1);
+  const pathname = filenameURL.pathname.substr(config.root.pathname.length - 1);
   let rawCSSDeps = /* @__PURE__ */ new Set();
   let cssTransformError;
   const transformResult = await transform(source, {
     pathname,
-    projectRoot: config.projectRoot.toString(),
-    site: config.buildOptions.site,
+    projectRoot: config.root.toString(),
+    site: config.site ? new URL(config.base, config.site).toString() : void 0,
     sourcefile: filename,
     sourcemap: "both",
     internalURL: `/@fs${prependForwardSlash(viteID(new URL("../runtime/server/index.js", import.meta.url)))}`,
-    experimentalStaticExtraction: !config.buildOptions.legacyBuild,
+    experimentalStaticExtraction: true,
     preprocessStyle: async (value, attrs) => {
       const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
       try {
-        if (!config.buildOptions.legacyBuild) {
-          value.replace(/(?:@import)\s(?:url\()?\s?["\'](.*?)["\']\s?\)?(?:[^;]*);?/gi, (match, spec) => {
-            rawCSSDeps.add(spec);
-            if (lang === ".css") {
-              return createImportPlaceholder(spec);
-            } else {
-              return match;
-            }
-          });
-        }
+        value.replace(/(?:@import)\s(?:url\()?\s?["\'](.*?)["\']\s?\)?(?:[^;]*);?/gi, (match, spec) => {
+          rawCSSDeps.add(spec);
+          if (lang === ".css") {
+            return createImportPlaceholder(spec);
+          } else {
+            return match;
+          }
+        });
         const result = await transformWithVite({
           value,
           lang,

package/dist/vite-plugin-astro/hmr.js

@@ -1,5 +1,5 @@
 import { invalidateCompilation, isCached } from "./compile.js";
-import { info } from "../core/logger.js";
+import { info } from "../core/logger/core.js";
 import * as msg from "../core/messages.js";
 async function trackCSSDependencies(opts) {
   const { viteDevServer, filename, deps, id } = opts;
@@ -46,7 +46,7 @@ async function handleHotUpdate(ctx, config, logging) {
     invalidateCompilation(config, file2);
   }
   const mod = ctx.modules.find((m) => m.file === ctx.file);
-  const file = ctx.file.replace(config.projectRoot.pathname, "/");
+  const file = ctx.file.replace(config.root.pathname, "/");
   if (ctx.file.endsWith(".astro")) {
     ctx.server.ws.send({ type: "custom", event: "astro:update", data: { file } });
   }

package/dist/vite-plugin-astro/index.js

@@ -9,25 +9,26 @@ import ancestor from "common-ancestor-path";
 import { trackCSSDependencies, handleHotUpdate } from "./hmr.js";
 import { isRelativePath, startsWithForwardSlash } from "../core/path.js";
 import { PAGE_SCRIPT_ID, PAGE_SSR_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
+import { resolvePages } from "../core/util.js";
 const FRONTMATTER_PARSE_REGEXP = /^\-\-\-(.*)^\-\-\-/ms;
 function astro({ config, logging }) {
   function normalizeFilename(filename) {
     if (filename.startsWith("/@fs")) {
       filename = filename.slice("/@fs".length);
-    } else if (filename.startsWith("/") && !ancestor(filename, config.projectRoot.pathname)) {
-      filename = new URL("." + filename, config.projectRoot).pathname;
+    } else if (filename.startsWith("/") && !ancestor(filename, config.root.pathname)) {
+      filename = new URL("." + filename, config.root).pathname;
     }
     return filename;
   }
   function relativeToRoot(pathname) {
     const arg = startsWithForwardSlash(pathname) ? "." + pathname : pathname;
-    const url = new URL(arg, config.projectRoot);
+    const url = new URL(arg, config.root);
     return slash(fileURLToPath(url)) + url.search;
   }
   let resolvedConfig;
   let viteTransform;
   let viteDevServer = null;
-  const srcRootWeb = config.src.pathname.slice(config.projectRoot.pathname.length - 1);
+  const srcRootWeb = config.srcDir.pathname.slice(config.root.pathname.length - 1);
   const isBrowserPath = (path) => path.startsWith(srcRootWeb);
   return {
     name: "astro:build",
@@ -60,6 +61,7 @@ function astro({ config, logging }) {
       }
     },
     async load(id, opts) {
+      var _a;
       const parsedId = parseAstroRequest(id);
       const query = parsedId.query;
       if (!id.endsWith(".astro") && !query.astro) {
@@ -68,10 +70,10 @@ function astro({ config, logging }) {
       const filename = normalizeFilename(parsedId.filename);
       const fileUrl = new URL(`file://${filename}`);
       let source = await fs.promises.readFile(fileUrl, "utf-8");
-      const isPage = fileUrl.pathname.startsWith(config.pages.pathname);
+      const isPage = fileUrl.pathname.startsWith(resolvePages(config).pathname);
       if (isPage && config._ctx.scripts.some((s) => s.stage === "page")) {
         source += `
-<script hoist src="${PAGE_SCRIPT_ID}" />`;
+<script src="${PAGE_SCRIPT_ID}" />`;
       }
       if (query.astro) {
         if (query.type === "style") {
@@ -95,6 +97,17 @@ function astro({ config, logging }) {
           if (!hoistedScript) {
             throw new Error(`No hoisted script at index ${query.index}`);
           }
+          if (hoistedScript.type === "external") {
+            const src = hoistedScript.src;
+            if (src.startsWith("/") && !isBrowserPath(src)) {
+              const publicDir = config.publicDir.pathname.replace(/\/$/, "").split("/").pop() + "/";
+              throw new Error(`
+
+<script src="${src}"> references an asset in the "${publicDir}" directory. Please add the "is:inline" directive to keep this asset from being bundled.
+
+File: ${filename}`);
+            }
+          }
           return {
             code: hoistedScript.type === "inline" ? hoistedScript.code : `import "${hoistedScript.src}";`
           };
@@ -106,7 +119,7 @@ function astro({ config, logging }) {
           loader: "ts",
           sourcemap: "external",
           sourcefile: id,
-          define: config.vite.define
+          define: (_a = config.vite) == null ? void 0 : _a.define
         });
         let SUFFIX = "";
         if (!resolvedConfig.isProduction) {
@@ -141,7 +154,7 @@ import "${PAGE_SSR_SCRIPT_ID}";`;
     
     \`@astrojs/compiler\` encountered an unrecoverable error when compiling the following file.
     
-    **${id.replace(fileURLToPath(config.projectRoot), "")}**
+    **${id.replace(fileURLToPath(config.root), "")}**
     \`\`\`astro
     ${source}
     \`\`\`

package/dist/vite-plugin-astro/styles.js

@@ -1,4 +1,4 @@
-import { STYLE_EXTENSIONS } from "../core/render/dev/css.js";
+import { STYLE_EXTENSIONS } from "../core/render/util.js";
 function getViteTransform(viteConfig) {
   const viteCSSPlugin = viteConfig.plugins.find(({ name }) => name === "vite:css");
   if (!viteCSSPlugin)

package/dist/vite-plugin-astro-postprocess/index.js

@@ -1,4 +1,6 @@
-import * as babel from "@babel/core";
+import { parse as babelParser } from "@babel/parser";
+import { parse, print, types, visit } from "recast";
+const ASTRO_GLOB_REGEX = /Astro2?\s*\.\s*glob\s*\(/;
 const validAstroGlobalNames = /* @__PURE__ */ new Set(["Astro", "Astro2"]);
 function astro({ config }) {
   return {
@@ -7,43 +9,38 @@ function astro({ config }) {
       if (!id.endsWith(".astro") && !id.endsWith(".md")) {
         return null;
       }
-      if (!code.includes("fetchContent")) {
+      if (!ASTRO_GLOB_REGEX.test(code)) {
         return null;
       }
-      const result = await babel.transformAsync(code, {
-        sourceType: "module",
-        sourceMaps: true,
-        plugins: [
-          () => {
-            return {
-              visitor: {
-                StringLiteral(path) {
-                  if (path.parent.type !== "CallExpression" || path.parent.callee.type !== "MemberExpression" || !validAstroGlobalNames.has(path.parent.callee.object.name) || path.parent.callee.property.name !== "fetchContent") {
-                    return;
-                  }
-                  const { value } = path.node;
-                  if (/[a-z]\:\/\//.test(value)) {
-                    return;
-                  }
-                  path.replaceWith({
-                    type: "CallExpression",
-                    callee: {
-                      type: "MemberExpression",
-                      object: { type: "MetaProperty", meta: { type: "Identifier", name: "import" }, property: { type: "Identifier", name: "meta" } },
-                      property: { type: "Identifier", name: "globEager" },
-                      computed: false
-                    },
-                    arguments: [path.node]
-                  });
-                }
-              }
-            };
+      const ast = parse(code, {
+        parser: { parse: babelParser }
+      });
+      visit(ast, {
+        visitCallExpression: function(path) {
+          if (!types.namedTypes.MemberExpression.check(path.node.callee) || !types.namedTypes.Identifier.check(path.node.callee.property) || !(path.node.callee.property.name === "glob") || !types.namedTypes.Identifier.check(path.node.callee.object) || !(path.node.callee.object.name === "Astro" || path.node.callee.object.name === "Astro2")) {
+            this.traverse(path);
+            return;
           }
-        ]
+          const argsPath = path.get("arguments", 0);
+          const args = argsPath.value;
+          argsPath.replace({
+            type: "CallExpression",
+            callee: {
+              type: "MemberExpression",
+              object: { type: "MetaProperty", meta: { type: "Identifier", name: "import" }, property: { type: "Identifier", name: "meta" } },
+              property: { type: "Identifier", name: "glob" },
+              computed: false
+            },
+            arguments: [args]
+          }, {
+            type: "ArrowFunctionExpression",
+            body: args,
+            params: []
+          });
+          return false;
+        }
       });
-      if (!result || !result.code) {
-        return null;
-      }
+      const result = print(ast);
       return { code: result.code, map: result.map };
     }
   };

package/dist/vite-plugin-astro-server/index.js

@@ -1,14 +1,17 @@
-import { info, warn, error } from "../core/logger.js";
+import { info, warn, error } from "../core/logger/core.js";
 import { getParamsAndProps, GetParamsAndPropsError } from "../core/render/core.js";
 import { createRouteManifest, matchRoute } from "../core/routing/index.js";
 import stripAnsi from "strip-ansi";
-import { createSafeError } from "../core/util.js";
+import { createSafeError, resolvePages, isBuildingToSSR } from "../core/util.js";
 import { ssr, preload } from "../core/render/dev/index.js";
 import { call as callEndpoint } from "../core/endpoint/dev/index.js";
 import * as msg from "../core/messages.js";
 import notFoundTemplate, { subpathNotUsedTemplate } from "../template/4xx.js";
 import serverErrorTemplate from "../template/5xx.js";
 import { RouteCache } from "../core/render/route-cache.js";
+import { fixViteErrorMessage } from "../core/errors.js";
+import { createRequest } from "../core/request.js";
+import { Readable } from "stream";
 const BAD_VITE_MIDDLEWARE = ["viteIndexHtmlMiddleware", "vite404Middleware", "viteSpaFallbackMiddleware"];
 function removeViteHttpMiddleware(server) {
   for (let i = server.stack.length - 1; i > 0; i--) {
@@ -29,13 +32,18 @@ async function writeWebResponse(res, webResponse) {
   const { status, headers, body } = webResponse;
   res.writeHead(status, Object.fromEntries(headers.entries()));
   if (body) {
-    const reader = body.getReader();
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      if (value) {
-        res.write(value);
+    if (body instanceof Readable) {
+      body.pipe(res);
+      return;
+    } else {
+      const reader = body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value) {
+          res.write(value);
+        }
       }
     }
   }
@@ -51,7 +59,7 @@ async function writeSSRResult(result, res, statusCode) {
   writeHtmlResponse(res, statusCode, html);
 }
 async function handle404Response(origin, config, req, res) {
-  const site = config.buildOptions.site ? new URL(config.buildOptions.site) : void 0;
+  const site = config.site ? new URL(config.base, config.site) : void 0;
   const devRoot = site ? site.pathname : "/";
   const pathname = decodeURI(new URL(origin + req.url).pathname);
   let html = "";
@@ -76,7 +84,7 @@ async function handle500Response(viteServer, origin, req, res, err) {
   writeHtmlResponse(res, 500, transformedHtml);
 }
 function getCustom404Route(config, manifest) {
-  const relPages = config.pages.href.replace(config.projectRoot.href, "");
+  const relPages = resolvePages(config).href.replace(config.root.href, "");
   return manifest.routes.find((r) => r.component === relPages + "404.astro");
 }
 function log404(logging, pathname) {
@@ -84,12 +92,35 @@ function log404(logging, pathname) {
 }
 async function handleRequest(routeCache, viteServer, logging, manifest, config, req, res) {
   const reqStart = performance.now();
-  const site = config.buildOptions.site ? new URL(config.buildOptions.site) : void 0;
+  const site = config.site ? new URL(config.base, config.site) : void 0;
   const devRoot = site ? site.pathname : "/";
   const origin = `${viteServer.config.server.https ? "https" : "http"}://${req.headers.host}`;
+  const buildingToSSR = isBuildingToSSR(config);
   const url = new URL(origin + req.url);
   const pathname = decodeURI(url.pathname);
   const rootRelativeUrl = pathname.substring(devRoot.length - 1);
+  if (!buildingToSSR) {
+    for (const [key] of url.searchParams) {
+      url.searchParams.delete(key);
+    }
+  }
+  let body = void 0;
+  if (!(req.method === "GET" || req.method === "HEAD")) {
+    let bytes = [];
+    await new Promise((resolve) => {
+      req.setEncoding("utf-8");
+      req.on("data", (bts) => bytes.push(bts));
+      req.on("end", resolve);
+    });
+    body = new TextEncoder().encode(bytes.join("")).buffer;
+  }
+  const request = createRequest({
+    url,
+    headers: buildingToSSR ? req.headers : new Headers(),
+    method: req.method,
+    body,
+    logging
+  });
   try {
     if (!pathname.startsWith(devRoot)) {
       log404(logging, pathname);
@@ -106,7 +137,7 @@ async function handleRequest(routeCache, viteServer, logging, manifest, config,
         return handle404Response(origin, config, req, res);
       }
     }
-    const filePath = new URL(`./${route.component}`, config.projectRoot);
+    const filePath = new URL(`./${route.component}`, config.root);
     const preloadedComponent = await preload({ astroConfig: config, filePath, viteServer });
     const [, mod] = preloadedComponent;
     const paramsAndPropsRes = await getParamsAndProps({
@@ -115,24 +146,23 @@ async function handleRequest(routeCache, viteServer, logging, manifest, config,
       routeCache,
       pathname: rootRelativeUrl,
       logging,
-      ssr: config.buildOptions.experimentalSsr
+      ssr: isBuildingToSSR(config)
     });
     if (paramsAndPropsRes === GetParamsAndPropsError.NoMatchingStaticPath) {
       warn(logging, "getStaticPaths", `Route pattern matched, but no matching static path found. (${pathname})`);
       log404(logging, pathname);
       const routeCustom404 = getCustom404Route(config, manifest);
       if (routeCustom404) {
-        const filePathCustom404 = new URL(`./${routeCustom404.component}`, config.projectRoot);
+        const filePathCustom404 = new URL(`./${routeCustom404.component}`, config.root);
         const preloadedCompCustom404 = await preload({ astroConfig: config, filePath: filePathCustom404, viteServer });
         const result = await ssr(preloadedCompCustom404, {
           astroConfig: config,
           filePath: filePathCustom404,
           logging,
           mode: "development",
-          method: "GET",
-          headers: new Headers(Object.entries(req.headers)),
           origin,
           pathname: rootRelativeUrl,
+          request,
           route: routeCustom404,
           routeCache,
           viteServer
@@ -152,8 +182,7 @@ async function handleRequest(routeCache, viteServer, logging, manifest, config,
       route,
       routeCache,
       viteServer,
-      method: req.method || "GET",
-      headers: new Headers(Object.entries(req.headers))
+      request
     };
     if (route.type === "endpoint") {
       const result = await callEndpoint(options);
@@ -169,9 +198,8 @@ async function handleRequest(routeCache, viteServer, logging, manifest, config,
     }
   } catch (_err) {
     debugger;
-    info(logging, "serve", msg.req({ url: pathname, statusCode: 500 }));
-    const err = createSafeError(_err);
-    error(logging, "error", msg.err(err));
+    const err = fixViteErrorMessage(createSafeError(_err), viteServer);
+    error(logging, null, msg.formatErrorMessage(err));
     handle500Response(viteServer, origin, req, res, err);
   }
 }

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

@@ -1,7 +1,7 @@
 import * as path from "path";
 import esbuild from "esbuild";
-import { isCSSRequest } from "../core/render/dev/css.js";
-import { getPageDatasByChunk } from "../core/build/internal.js";
+import { isCSSRequest } from "../core/render/util.js";
+import { getPageDatasByChunk, getPageDataByViteID, hasPageDataByViteID } from "../core/build/internal.js";
 const PLUGIN_NAME = "@astrojs/rollup-plugin-build-css";
 const ASTRO_STYLE_PREFIX = "@astro-inline-style";
 const ASTRO_PAGE_STYLE_PREFIX = "@astro-page-all-styles";
@@ -30,8 +30,46 @@ function isPageStyleVirtualModule(id) {
   return id.startsWith(ASTRO_PAGE_STYLE_PREFIX);
 }
 function rollupPluginAstroBuildCSS(options) {
-  const { internals } = options;
+  const { internals, legacy } = options;
   const styleSourceMap = /* @__PURE__ */ new Map();
+  function* walkStyles(ctx, id, seen = /* @__PURE__ */ new Set()) {
+    seen.add(id);
+    if (styleSourceMap.has(id)) {
+      yield [id, styleSourceMap.get(id)];
+    }
+    const info = ctx.getModuleInfo(id);
+    if (info) {
+      for (const importedId of info.importedIds) {
+        if (!seen.has(importedId)) {
+          yield* walkStyles(ctx, importedId, seen);
+        }
+      }
+    }
+  }
+  async function addStyles() {
+    var _a;
+    for (const id of this.getModuleIds()) {
+      if (hasPageDataByViteID(internals, id)) {
+        let pageStyles = "";
+        for (const [_styleId, styles] of walkStyles(this, id)) {
+          pageStyles += styles;
+        }
+        if (!pageStyles)
+          continue;
+        const { code: minifiedCSS } = await esbuild.transform(pageStyles, {
+          loader: "css",
+          minify: true
+        });
+        const referenceId = this.emitFile({
+          name: "entry.css",
+          type: "asset",
+          source: minifiedCSS
+        });
+        const fileName = this.getFileName(referenceId);
+        (_a = getPageDataByViteID(internals, id)) == null ? void 0 : _a.css.add(fileName);
+      }
+    }
+  }
   return {
     name: PLUGIN_NAME,
     configResolved(resolvedConfig) {
@@ -75,6 +113,8 @@ function rollupPluginAstroBuildCSS(options) {
       return null;
     },
     async renderChunk(_code, chunk) {
+      if (!legacy)
+        return null;
       let chunkCSS = "";
       let isPureCSS = true;
       for (const [id] of Object.entries(chunk.modules)) {
@@ -108,13 +148,16 @@ function rollupPluginAstroBuildCSS(options) {
       }
       return null;
     },
-    generateBundle(opts, bundle) {
+    async generateBundle(opts, bundle) {
       const hasPureCSSChunks = internals.pureCSSChunks.size;
       const pureChunkFilenames = new Set([...internals.pureCSSChunks].map((chunk) => chunk.fileName));
       const emptyChunkFiles = [...pureChunkFilenames].map((file) => path.basename(file)).join("|").replace(/\./g, "\\.");
       const emptyChunkRE = new RegExp(opts.format === "es" ? `\\bimport\\s*"[^"]*(?:${emptyChunkFiles})";
 ?` : `\\brequire\\(\\s*"[^"]*(?:${emptyChunkFiles})"\\);
 ?`, "g");
+      if (!legacy) {
+        await addStyles.call(this);
+      }
       for (const [chunkId, chunk] of Object.entries(bundle)) {
         if (chunk.type === "chunk") {
           for (const { css: cssSet } of getPageDatasByChunk(internals, chunk)) {

package/dist/vite-plugin-build-html/index.js

@@ -17,31 +17,32 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { createElement, createScript, getAttribute, hasAttribute, insertBefore, remove, setAttribute } from "@web/parse5-utils";
+import { promises as fs } from "fs";
 import parse5 from "parse5";
-import srcsetParse from "srcset-parse";
 import * as npath from "path";
-import { promises as fs } from "fs";
-import { getAttribute, hasAttribute, insertBefore, remove, createScript, createElement, setAttribute } from "@web/parse5-utils";
-import { addRollupInput } from "./add-rollup-input.js";
-import { findAssets, findExternalScripts, findInlineScripts, findInlineStyles, getTextContent, getAttributes } from "./extract-assets.js";
-import { isBuildableImage, isBuildableLink, isHoistedScript, isInSrcDirectory, hasSrcSet } from "./util.js";
+import srcsetParse from "srcset-parse";
+import { prependDotSlash } from "../core/path.js";
 import { render as ssrRender } from "../core/render/dev/index.js";
-import { getAstroStyleId, getAstroPageStyleId } from "../vite-plugin-build-css/index.js";
-import { prependDotSlash, removeEndingForwardSlash } from "../core/path.js";
+import { getOutputFilename } from "../core/util.js";
+import { getAstroPageStyleId, getAstroStyleId } from "../vite-plugin-build-css/index.js";
+import { addRollupInput } from "./add-rollup-input.js";
+import { findAssets, findExternalScripts, findInlineScripts, findInlineStyles, getAttributes, getTextContent } from "./extract-assets.js";
+import { hasSrcSet, isBuildableImage, isBuildableLink, isHoistedScript, isInSrcDirectory } from "./util.js";
+import { createRequest } from "../core/request.js";
 const matchSrcset = srcsetParse.default;
 const PLUGIN_NAME = "@astro/rollup-plugin-build";
 const ASTRO_PAGE_PREFIX = "@astro-page";
 const ASTRO_SCRIPT_PREFIX = "@astro-script";
 const ASTRO_EMPTY = "@astro-empty";
-const STATUS_CODE_REGEXP = /^[0-9]{3}$/;
 function relativePath(from, to) {
   const rel = npath.posix.relative(from, to);
   return prependDotSlash(rel);
 }
 function rollupPluginAstroScanHTML(options) {
   const { astroConfig, internals, logging, origin, allPages, routeCache, viteServer, pageNames } = options;
-  const srcRoot = astroConfig.src.pathname;
-  const srcRootWeb = srcRoot.substr(astroConfig.projectRoot.pathname.length - 1);
+  const srcRoot = astroConfig.srcDir.pathname;
+  const srcRootWeb = srcRoot.substr(astroConfig.root.pathname.length - 1);
   const renderedPageMap = /* @__PURE__ */ new Map();
   const astroScriptMap = /* @__PURE__ */ new Map();
   const astroPageMap = /* @__PURE__ */ new Map();
@@ -65,10 +66,13 @@ function rollupPluginAstroScanHTML(options) {
           const id = ASTRO_PAGE_PREFIX + pathname;
           const response = await ssrRender(renderers, mod, {
             astroConfig,
-            filePath: new URL(`./${component}`, astroConfig.projectRoot),
+            filePath: new URL(`./${component}`, astroConfig.root),
             logging,
-            headers: new Headers(),
-            method: "GET",
+            request: createRequest({
+              url: new URL(origin + pathname),
+              headers: new Headers(),
+              logging
+            }),
             mode: "production",
             origin,
             pathname,
@@ -131,7 +135,7 @@ function rollupPluginAstroScanHTML(options) {
               if ((src == null ? void 0 : src.startsWith(srcRoot)) && !astroAssetMap.has(src)) {
                 astroAssetMap.set(src, fs.readFile(new URL(`file://${src}`)));
               } else if ((src == null ? void 0 : src.startsWith(srcRootWeb)) && !astroAssetMap.has(src)) {
-                const resolved = new URL("." + src, astroConfig.projectRoot);
+                const resolved = new URL("." + src, astroConfig.root);
                 astroAssetMap.set(src, fs.readFile(resolved));
               }
             }
@@ -141,7 +145,7 @@ function rollupPluginAstroScanHTML(options) {
                 if (url.startsWith(srcRoot) && !astroAssetMap.has(url)) {
                   astroAssetMap.set(url, fs.readFile(new URL(`file://${url}`)));
                 } else if (url.startsWith(srcRootWeb) && !astroAssetMap.has(url)) {
-                  const resolved = new URL("." + url, astroConfig.projectRoot);
+                  const resolved = new URL("." + url, astroConfig.root);
                   astroAssetMap.set(url, fs.readFile(resolved));
                 }
               }
@@ -313,7 +317,7 @@ function rollupPluginAstroScanHTML(options) {
           } else if (isInSrcDirectory(script, "src", srcRoot, srcRootWeb)) {
             let src = getAttribute(script, "src");
             if (src == null ? void 0 : src.startsWith(srcRootWeb)) {
-              src = new URL("." + src, astroConfig.projectRoot).pathname;
+              src = new URL("." + src, astroConfig.root).pathname;
             }
             if (src && (facadeIdMap.has(src) || facadeIdMap.has(src.substr(1)))) {
               const assetRootPath = "/" + (facadeIdMap.get(src) || facadeIdMap.get(src.substr(1)));
@@ -386,12 +390,7 @@ function rollupPluginAstroScanHTML(options) {
         }
         const outHTML = parse5.serialize(document);
         const name = pathname.substr(1);
-        let outPath;
-        if (astroConfig.buildOptions.pageUrlFormat === "file" || STATUS_CODE_REGEXP.test(name)) {
-          outPath = `${removeEndingForwardSlash(name || "index")}.html`;
-        } else {
-          outPath = npath.posix.join(name, "index.html");
-        }
+        const outPath = getOutputFilename(astroConfig, name);
         this.emitFile({
           fileName: outPath,
           source: outHTML,

package/dist/vite-plugin-config-alias/index.js

@@ -47,7 +47,7 @@ const getConfigAlias = (cwd) => {
   return aliases;
 };
 function configAliasVitePlugin(astroConfig) {
-  const configAlias = getConfigAlias(astroConfig.projectRoot && url.fileURLToPath(astroConfig.projectRoot));
+  const configAlias = getConfigAlias(astroConfig.root && url.fileURLToPath(astroConfig.root));
   if (!configAlias)
     return {};
   return {

package/dist/vite-plugin-env/index.js

@@ -6,7 +6,7 @@ function getPrivateEnv(viteConfig, astroConfig) {
   if (viteConfig.envPrefix) {
     envPrefixes = Array.isArray(viteConfig.envPrefix) ? viteConfig.envPrefix : [viteConfig.envPrefix];
   }
-  const fullEnv = loadEnv(viteConfig.mode, viteConfig.envDir ?? fileURLToPath(astroConfig.projectRoot), "");
+  const fullEnv = loadEnv(viteConfig.mode, viteConfig.envDir ?? fileURLToPath(astroConfig.root), "");
   const privateKeys = Object.keys(fullEnv).filter((key) => {
     if (typeof process.env[key] !== "undefined")
       return false;

package/dist/vite-plugin-jsx/index.js

@@ -3,7 +3,7 @@ import esbuild from "esbuild";
 import * as colors from "kleur/colors";
 import * as eslexer from "es-module-lexer";
 import path from "path";
-import { error } from "../core/logger.js";
+import { error } from "../core/logger/core.js";
 import { parseNpmName } from "../core/util.js";
 const JSX_RENDERER_CACHE = /* @__PURE__ */ new WeakMap();
 const JSX_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx"]);