astro 0.25.3 → 0.26.1

package/dist/types/vite-plugin-build-html/index.d.ts

@@ -1,8 +1,8 @@
+import type { Plugin as VitePlugin, ViteDevServer } from 'vite';
 import type { AstroConfig } from '../@types/astro';
-import type { LogOptions } from '../core/logger.js';
-import type { ViteDevServer, Plugin as VitePlugin } from 'vite';
-import type { AllPagesData } from '../core/build/types';
 import type { BuildInternals } from '../core/build/internal';
+import type { AllPagesData } from '../core/build/types';
+import type { LogOptions } from '../core/logger/core.js';
 import { RouteCache } from '../core/render/route-cache.js';
 interface PluginOptions {
     astroConfig: AstroConfig;

package/dist/types/vite-plugin-config-alias/index.d.ts

@@ -6,6 +6,6 @@ export declare interface Alias {
 }
 /** Returns a Vite plugin used to alias pathes from tsconfig.json and jsconfig.json. */
 export default function configAliasVitePlugin(astroConfig: {
-    projectRoot?: URL;
+    root?: URL;
     [key: string]: unknown;
 }): vite.PluginOption;

package/dist/types/vite-plugin-env/index.d.ts

@@ -3,5 +3,5 @@ import type { AstroConfig } from '../@types/astro';
 interface EnvPluginOptions {
     config: AstroConfig;
 }
-export default function envVitePlugin({ config: astroConfig }: EnvPluginOptions): vite.PluginOption;
+export default function envVitePlugin({ config: astroConfig, }: EnvPluginOptions): vite.PluginOption;
 export {};

package/dist/types/vite-plugin-integrations-container/index.d.ts

@@ -1,6 +1,6 @@
 import { Plugin as VitePlugin } from 'vite';
 import { AstroConfig } from '../@types/astro.js';
 /** Connect Astro integrations into Vite, as needed. */
-export default function astroIntegrationsContainerPlugin({ config }: {
+export default function astroIntegrationsContainerPlugin({ config, }: {
     config: AstroConfig;
 }): VitePlugin;

package/dist/types/vite-plugin-jsx/index.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from 'vite';
 import type { AstroConfig } from '../@types/astro';
-import type { LogOptions } from '../core/logger.js';
+import type { LogOptions } from '../core/logger/core.js';
 interface AstroPluginJSXOptions {
     config: AstroConfig;
     logging: LogOptions;

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,18 +70,25 @@ 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") {
           if (typeof query.index === "undefined") {
             throw new Error(`Requests for Astro CSS must include an index.`);
           }
-          const transformResult = await cachedCompilation(config, filename, source, viteTransform, { ssr: Boolean(opts == null ? void 0 : opts.ssr) });
-          await trackCSSDependencies.call(this, { viteDevServer, id, filename, deps: transformResult.rawCSSDeps });
+          const transformResult = await cachedCompilation(config, filename, source, viteTransform, {
+            ssr: Boolean(opts == null ? void 0 : opts.ssr)
+          });
+          await trackCSSDependencies.call(this, {
+            viteDevServer,
+            id,
+            filename,
+            deps: transformResult.rawCSSDeps
+          });
           const csses = transformResult.css;
           const code = csses[query.index];
           return {
@@ -89,24 +98,39 @@ function astro({ config, logging }) {
           if (typeof query.index === "undefined") {
             throw new Error(`Requests for hoisted scripts must include an index`);
           }
-          const transformResult = await cachedCompilation(config, filename, source, viteTransform, { ssr: Boolean(opts == null ? void 0 : opts.ssr) });
+          const transformResult = await cachedCompilation(config, filename, source, viteTransform, {
+            ssr: Boolean(opts == null ? void 0 : opts.ssr)
+          });
           const scripts = transformResult.scripts;
           const hoistedScript = scripts[query.index];
           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}";`
           };
         }
       }
       try {
-        const transformResult = await cachedCompilation(config, filename, source, viteTransform, { ssr: Boolean(opts == null ? void 0 : opts.ssr) });
+        const transformResult = await cachedCompilation(config, filename, source, viteTransform, {
+          ssr: Boolean(opts == null ? void 0 : opts.ssr)
+        });
         const { code, map } = await esbuild.transform(transformResult.code, {
           loader: "ts",
           sourcemap: "external",
           sourcefile: id,
-          define: config.vite.define
+          define: (_a = config.vite) == null ? void 0 : _a.define
         });
         let SUFFIX = "";
         if (!resolvedConfig.isProduction) {
@@ -125,7 +149,11 @@ import "${PAGE_SSR_SCRIPT_ID}";`;
         const scannedFrontmatter = FRONTMATTER_PARSE_REGEXP.exec(source);
         if (scannedFrontmatter) {
           try {
-            await esbuild.transform(scannedFrontmatter[1], { loader: "ts", sourcemap: false, sourcefile: id });
+            await esbuild.transform(scannedFrontmatter[1], {
+              loader: "ts",
+              sourcemap: false,
+              sourcefile: id
+            });
           } catch (frontmatterErr) {
             if (frontmatterErr && frontmatterErr.message) {
               frontmatterErr.message = frontmatterErr.message.replace("end of file", "end of frontmatter");
@@ -141,7 +169,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)
@@ -7,7 +7,13 @@ function getViteTransform(viteConfig) {
     throw new Error(`vite:css has no transform() hook`);
   return viteCSSPlugin.transform.bind(null);
 }
-async function transformWithVite({ value, lang, transformHook, id, ssr }) {
+async function transformWithVite({
+  value,
+  lang,
+  transformHook,
+  id,
+  ssr
+}) {
   if (!STYLE_EXTENSIONS.has(lang)) {
     return null;
   }

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,42 @@ 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,15 +1,22 @@
-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";
-const BAD_VITE_MIDDLEWARE = ["viteIndexHtmlMiddleware", "vite404Middleware", "viteSpaFallbackMiddleware"];
+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--) {
     if (BAD_VITE_MIDDLEWARE.includes(server.stack[i].handle.name)) {
@@ -29,13 +36,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,14 +63,19 @@ 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 = "";
   if (pathname === "/" && !pathname.startsWith(devRoot)) {
     html = subpathNotUsedTemplate(devRoot, pathname);
   } else {
-    html = notFoundTemplate({ statusCode: 404, title: "Not found", tabTitle: "404: Not Found", pathname });
+    html = notFoundTemplate({
+      statusCode: 404,
+      title: "Not found",
+      tabTitle: "404: Not Found",
+      pathname
+    });
   }
   writeHtmlResponse(res, 404, html);
 }
@@ -76,7 +93,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 +101,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 +146,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 +155,27 @@ 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 preloadedCompCustom404 = await preload({ astroConfig: config, filePath: filePathCustom404, viteServer });
+        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 +195,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 +211,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,11 @@
 import * as path from "path";
 import esbuild from "esbuild";
-import { isCSSRequest } from "../core/render/dev/css.js";
-import { getPageDatasByChunk, getPageDataByViteID, hasPageDataByViteID } 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";