astro 6.0.0-alpha.0 → 6.0.0-alpha.2

package/dist/vite-plugin-app/pipeline.js

@@ -0,0 +1,166 @@
+import { fileURLToPath } from "node:url";
+import { Pipeline } from "../core/base-pipeline.js";
+import { ASTRO_VERSION } from "../core/constants.js";
+import { enhanceViteSSRError } from "../core/errors/dev/index.js";
+import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { RedirectComponentInstance } from "../core/redirects/index.js";
+import { loadRenderer } from "../core/render/index.js";
+import { createDefaultRoutes } from "../core/routing/default.js";
+import { routeIsRedirect } from "../core/routing/index.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
+import { isPage } from "../core/util.js";
+import { resolveIdToUrl } from "../core/viteUtils.js";
+import { getComponentMetadata } from "../vite-plugin-astro-server/metadata.js";
+import { createResolve } from "../vite-plugin-astro-server/resolve.js";
+import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
+import { getDevCSSModuleName } from "../vite-plugin-css/util.js";
+class AstroServerPipeline extends Pipeline {
+  constructor(loader, logger, manifest, settings, getDebugInfo, defaultRoutes = createDefaultRoutes(manifest)) {
+    const resolve = createResolve(loader, manifest.rootDir);
+    const streaming = true;
+    super(logger, manifest, "development", [], resolve, streaming);
+    this.loader = loader;
+    this.logger = logger;
+    this.manifest = manifest;
+    this.settings = settings;
+    this.getDebugInfo = getDebugInfo;
+    this.defaultRoutes = defaultRoutes;
+  }
+  getName() {
+    return "AstroServerPipeline";
+  }
+  // renderers are loaded on every request,
+  // so it needs to be mutable here unlike in other environments
+  renderers = new Array();
+  routesList;
+  componentInterner = /* @__PURE__ */ new WeakMap();
+  static create(manifestData, {
+    loader,
+    logger,
+    manifest,
+    settings,
+    getDebugInfo
+  }) {
+    const pipeline = new AstroServerPipeline(loader, logger, manifest, settings, getDebugInfo);
+    pipeline.routesList = manifestData;
+    return pipeline;
+  }
+  async headElements(routeData) {
+    const { manifest, loader, runtimeMode, settings } = this;
+    const filePath = new URL(`${routeData.component}`, manifest.rootDir);
+    const scripts = /* @__PURE__ */ new Set();
+    if (settings) {
+      if (isPage(filePath, settings) && runtimeMode === "development") {
+        scripts.add({
+          props: { type: "module", src: "/@vite/client" },
+          children: ""
+        });
+        if (settings.config.devToolbar.enabled && await settings.preferences.get("devToolbar.enabled")) {
+          const src = await resolveIdToUrl(
+            loader,
+            "astro/runtime/client/dev-toolbar/entrypoint.js"
+          );
+          scripts.add({ props: { type: "module", src }, children: "" });
+          const additionalMetadata = {
+            root: fileURLToPath(settings.config.root),
+            version: ASTRO_VERSION,
+            latestAstroVersion: settings.latestAstroVersion,
+            // TODO: Currently the debug info is always fetched, which slows things down.
+            // We should look into not loading it if the dev toolbar is disabled. And when
+            // enabled, it would nice to request the debug info through import.meta.hot
+            // when the button is click to defer execution as much as possible
+            debugInfo: await this.getDebugInfo()
+          };
+          const children = `window.__astro_dev_toolbar__ = ${JSON.stringify(additionalMetadata)}`;
+          scripts.add({ props: {}, children });
+        }
+      }
+      for (const script of settings.scripts) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.content
+          });
+        } else if (script.stage === "page" && isPage(filePath, settings)) {
+          scripts.add({
+            props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
+            children: ""
+          });
+        }
+      }
+    }
+    const { css } = await loader.import(getDevCSSModuleName(routeData.component));
+    const links = /* @__PURE__ */ new Set();
+    const styles = /* @__PURE__ */ new Set();
+    for (const { id, url: src, content } of css) {
+      scripts.add({ props: { type: "module", src }, children: "" });
+      styles.add({ props: { "data-vite-dev-id": id }, children: content });
+    }
+    return { scripts, styles, links };
+  }
+  componentMetadata(routeData) {
+    const filePath = new URL(`${routeData.component}`, this.manifest.rootDir);
+    return getComponentMetadata(filePath, this.loader);
+  }
+  async preload(routeData, filePath) {
+    if (routeIsRedirect(routeData)) {
+      return RedirectComponentInstance;
+    }
+    const { loader } = this;
+    for (const route of this.defaultRoutes) {
+      if (route.matchesComponent(filePath)) {
+        return route.instance;
+      }
+    }
+    if (this.settings) {
+      const renderers__ = this.settings.renderers.map((r) => loadRenderer(r, loader));
+      const renderers_ = await Promise.all(renderers__);
+      this.renderers = renderers_.filter((r) => Boolean(r));
+    }
+    try {
+      const componentInstance = await loader.import(filePath.toString());
+      this.componentInterner.set(routeData, componentInstance);
+      return componentInstance;
+    } catch (error) {
+      if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
+        throw error;
+      }
+      throw enhanceViteSSRError({ error, filePath, loader });
+    }
+  }
+  clearRouteCache() {
+    this.routeCache.clearAll();
+    this.componentInterner = /* @__PURE__ */ new WeakMap();
+  }
+  async getComponentByRoute(routeData) {
+    const component = this.componentInterner.get(routeData);
+    if (component) {
+      return component;
+    } else {
+      const filePath = new URL(`${routeData.component}`, this.manifest.rootDir);
+      return await this.preload(routeData, filePath);
+    }
+  }
+  async tryRewrite(payload, request) {
+    if (!this.routesList) {
+      throw new Error("Missing manifest data. This is an internal error, please file an issue.");
+    }
+    const { routeData, pathname, newUrl } = findRouteToRewrite({
+      payload,
+      request,
+      routes: this.routesList?.routes,
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat,
+      base: this.manifest.base,
+      outDir: this.manifest.outDir
+    });
+    const componentInstance = await this.getComponentByRoute(routeData);
+    return { newUrl, pathname, componentInstance, routeData };
+  }
+  setManifestData(manifestData) {
+    this.routesList = manifestData;
+  }
+}
+export {
+  AstroServerPipeline
+};

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

@@ -1,5 +1,7 @@
 import { defaultClientConditions, defaultServerConditions, normalizePath } from "vite";
-import { hasSpecialQueries, normalizeFilename } from "../vite-plugin-utils/index.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { isAstroServerEnvironment } from "../environments.js";
+import { normalizeFilename, specialQueriesRE } from "../vite-plugin-utils/index.js";
 import { compileAstro } from "./compile.js";
 import { handleHotUpdate } from "./hmr.js";
 import { parseAstroRequest } from "./query.js";
@@ -14,205 +16,248 @@ function astro({ settings, logger }) {
   const srcRootWeb = config.srcDir.pathname.slice(config.root.pathname.length - 1);
   const isBrowserPath = (path) => path.startsWith(srcRootWeb) && srcRootWeb !== "/";
   const notAstroComponent = (component) => !component.resolvedPath.endsWith(".astro");
-  const prePlugin = {
-    name: "astro:build",
-    enforce: "pre",
-    // run transforms before other plugins can
-    async configEnvironment(name, viteConfig, opts) {
-      viteConfig.resolve ??= {};
-      if (viteConfig.resolve.conditions == null) {
-        if (viteConfig.consumer === "client" || name === "client" || opts.isSsrTargetWebworker) {
-          viteConfig.resolve.conditions = [...defaultClientConditions];
-        } else {
-          viteConfig.resolve.conditions = [...defaultServerConditions];
+  return [
+    {
+      name: "astro:build:css-hmr",
+      enforce: "pre",
+      applyToEnvironment(environment) {
+        return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+      },
+      transform: {
+        filter: {
+          id: {
+            include: [/(?:\?|&)astro(?:&|=|$)/],
+            // ignore astro file sub-requests, e.g. Foo.astro?astro&type=script&index=0&lang.ts
+            exclude: [specialQueriesRE]
+          }
+        },
+        async handler(_source, id) {
+          const parsedId = parseAstroRequest(id);
+          const astroFilename = normalizePath(normalizeFilename(parsedId.filename, config.root));
+          const compileMetadata = astroFileToCompileMetadata.get(astroFilename);
+          if (compileMetadata && parsedId.query.type === "style" && parsedId.query.index != null) {
+            const result = compileMetadata.css[parsedId.query.index];
+            result.dependencies?.forEach((dep) => this.addWatchFile(dep));
+          }
         }
       }
-      viteConfig.resolve.conditions.push("astro");
     },
-    configResolved(viteConfig) {
-      compile = (code, filename) => {
-        return compileAstro({
-          compileProps: {
-            astroConfig: config,
-            viteConfig,
-            preferences: settings.preferences,
-            filename,
-            source: code
-          },
-          astroFileToCompileMetadata,
-          logger
+    {
+      name: "astro:build",
+      enforce: "pre",
+      // run transforms before other plugins can
+      async configEnvironment(name, viteConfig, opts) {
+        viteConfig.resolve ??= {};
+        if (viteConfig.resolve.conditions == null) {
+          if (viteConfig.consumer === "client" || name === "client" || opts.isSsrTargetWebworker) {
+            viteConfig.resolve.conditions = [...defaultClientConditions];
+          } else {
+            viteConfig.resolve.conditions = [...defaultServerConditions];
+          }
+        }
+        viteConfig.resolve.conditions.push("astro");
+      },
+      async configResolved(viteConfig) {
+        const toolbarEnabled = await settings.preferences.get("devToolbar.enabled");
+        compile = (code, filename) => {
+          return compileAstro({
+            compileProps: {
+              astroConfig: config,
+              viteConfig,
+              toolbarEnabled,
+              filename,
+              source: code
+            },
+            astroFileToCompileMetadata,
+            logger
+          });
+        };
+      },
+      configureServer(_server) {
+        server = _server;
+        server.watcher.on("unlink", (filename) => {
+          astroFileToCompileMetadata.delete(filename);
         });
-      };
-    },
-    configureServer(_server) {
-      server = _server;
-      server.watcher.on("unlink", (filename) => {
-        astroFileToCompileMetadata.delete(filename);
-      });
-    },
-    buildStart() {
-      astroFileToCompileMetadata = /* @__PURE__ */ new Map();
-      if (astroFileToCompileMetadataWeakMap.has(config)) {
-        astroFileToCompileMetadata = astroFileToCompileMetadataWeakMap.get(config);
-      } else {
-        astroFileToCompileMetadataWeakMap.set(config, astroFileToCompileMetadata);
-      }
-    },
-    async load(id, opts) {
-      const parsedId = parseAstroRequest(id);
-      const query = parsedId.query;
-      if (!query.astro) {
-        return null;
-      }
-      const filename = normalizePath(normalizeFilename(parsedId.filename, config.root));
-      let compileMetadata = astroFileToCompileMetadata.get(filename);
-      if (!compileMetadata) {
-        if (server) {
-          const code = await loadId(server.pluginContainer, filename);
-          if (code != null) await compile(code, filename);
+      },
+      buildStart() {
+        astroFileToCompileMetadata = /* @__PURE__ */ new Map();
+        if (astroFileToCompileMetadataWeakMap.has(config)) {
+          astroFileToCompileMetadata = astroFileToCompileMetadataWeakMap.get(config);
+        } else {
+          astroFileToCompileMetadataWeakMap.set(config, astroFileToCompileMetadata);
         }
-        compileMetadata = astroFileToCompileMetadata.get(filename);
-      }
-      if (!compileMetadata) {
-        throw new Error(
-          `No cached compile metadata found for "${id}". The main Astro module "${filename}" should have compiled and filled the metadata first, before its virtual modules can be requested.`
-        );
-      }
-      switch (query.type) {
-        case "style": {
-          if (typeof query.index === "undefined") {
-            throw new Error(`Requests for Astro CSS must include an index.`);
+      },
+      load: {
+        filter: {
+          id: /(?:\?|&)astro(?:&|=|$)/
+        },
+        async handler(id) {
+          const parsedId = parseAstroRequest(id);
+          const query = parsedId.query;
+          const filename = normalizePath(normalizeFilename(parsedId.filename, config.root));
+          let compileMetadata = astroFileToCompileMetadata.get(filename);
+          if (!compileMetadata) {
+            if (server) {
+              const code = await loadId(server.pluginContainer, filename);
+              if (code != null) await compile(code, filename);
+            }
+            compileMetadata = astroFileToCompileMetadata.get(filename);
           }
-          const result = compileMetadata.css[query.index];
-          if (!result) {
-            throw new Error(`No Astro CSS at index ${query.index}`);
+          if (!compileMetadata) {
+            throw new Error(
+              `No cached compile metadata found for "${id}". The main Astro module "${filename}" should have compiled and filled the metadata first, before its virtual modules can be requested.`
+            );
           }
-          result.dependencies?.forEach((dep) => this.addWatchFile(dep));
-          return {
-            code: result.code,
-            // `vite.cssScopeTo` is a Vite feature that allows this CSS to be treeshaken
-            // if the Astro component's default export is not used
-            meta: result.isGlobal ? void 0 : {
-              vite: {
-                cssScopeTo: [filename, "default"]
+          switch (query.type) {
+            case "style": {
+              if (typeof query.index === "undefined") {
+                throw new Error(`Requests for Astro CSS must include an index.`);
               }
+              const result = compileMetadata.css[query.index];
+              if (!result) {
+                throw new Error(`No Astro CSS at index ${query.index}`);
+              }
+              result.dependencies?.forEach((dep) => this.addWatchFile(dep));
+              return {
+                code: result.code,
+                // `vite.cssScopeTo` is a Vite feature that allows this CSS to be treeshaken
+                // if the Astro component's default export is not used
+                meta: result.isGlobal ? void 0 : {
+                  vite: {
+                    cssScopeTo: [filename, "default"]
+                  }
+                }
+              };
             }
-          };
-        }
-        case "script": {
-          if (typeof query.index === "undefined") {
-            throw new Error(`Requests for scripts must include an index`);
-          }
-          if (opts?.ssr) {
-            return {
-              code: `/* client script, empty in SSR: ${id} */`
-            };
-          }
-          const script = compileMetadata.scripts[query.index];
-          if (!script) {
-            throw new Error(`No script at index ${query.index}`);
-          }
-          if (script.type === "external") {
-            const src = script.src;
-            if (src.startsWith("/") && !isBrowserPath(src)) {
-              const publicDir = config.publicDir.pathname.replace(/\/$/, "").split("/").pop() + "/";
-              throw new Error(
-                `
+            case "script": {
+              if (typeof query.index === "undefined") {
+                throw new Error(`Requests for scripts must include an index`);
+              }
+              if (isAstroServerEnvironment(this.environment)) {
+                return {
+                  code: `/* client script, empty in SSR: ${id} */`
+                };
+              }
+              const script = compileMetadata.scripts[query.index];
+              if (!script) {
+                throw new Error(`No script at index ${query.index}`);
+              }
+              if (script.type === "external") {
+                const src = script.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: ${id}`
-              );
+                  );
+                }
+              }
+              const result = {
+                code: "",
+                meta: {
+                  vite: {
+                    lang: "ts"
+                  }
+                }
+              };
+              switch (script.type) {
+                case "inline": {
+                  const { code, map } = script;
+                  result.code = appendSourceMap(code, map);
+                  break;
+                }
+                case "external": {
+                  const { src } = script;
+                  result.code = `import "${src}"`;
+                  break;
+                }
+              }
+              return result;
             }
+            case "custom":
+            case "template":
+            case void 0:
+            default:
+              return null;
+          }
+        }
+      },
+      transform: {
+        filter: {
+          id: {
+            include: [/\.astro$/, /\.astro\?/],
+            // ignore astro file sub-requests, e.g. Foo.astro?astro&type=script&index=0&lang.ts
+            exclude: [specialQueriesRE, /(?:\?|&)astro(?:&|=|$)/]
+          }
+        },
+        async handler(source, id) {
+          const parsedId = parseAstroRequest(id);
+          if (!parsedId.filename.endsWith(".astro")) {
+            return;
           }
-          const result = {
-            code: "",
+          const filename = normalizePath(parsedId.filename);
+          if (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
+            return {
+              code: `export default import.meta.env.DEV
+									? () => {
+											throw new Error(
+												'Astro components cannot be used in the browser.\\nTried to render "${filename}".'
+											);
+										}
+									: {};`,
+              meta: { vite: { lang: "ts" } }
+            };
+          }
+          const transformResult = await compile(source, filename);
+          const astroMetadata = {
+            // Remove Astro components that have been mistakenly given client directives
+            // We'll warn the user about this later, but for now we'll prevent them from breaking the build
+            clientOnlyComponents: transformResult.clientOnlyComponents.filter(notAstroComponent),
+            hydratedComponents: transformResult.hydratedComponents.filter(notAstroComponent),
+            serverComponents: transformResult.serverComponents,
+            scripts: transformResult.scripts,
+            containsHead: transformResult.containsHead,
+            propagation: transformResult.propagation ? "self" : "none",
+            pageOptions: {}
+          };
+          return {
+            code: transformResult.code,
+            map: transformResult.map,
             meta: {
+              astro: astroMetadata,
               vite: {
+                // Setting this vite metadata to `ts` causes Vite to resolve .js
+                // extensions to .ts files.
                 lang: "ts"
               }
             }
           };
-          switch (script.type) {
-            case "inline": {
-              const { code, map } = script;
-              result.code = appendSourceMap(code, map);
-              break;
-            }
-            case "external": {
-              const { src } = script;
-              result.code = `import "${src}"`;
-              break;
-            }
-          }
-          return result;
         }
-        case "custom":
-        case "template":
-        case void 0:
-        default:
-          return null;
+      },
+      async handleHotUpdate(ctx) {
+        return handleHotUpdate(ctx, { logger, astroFileToCompileMetadata });
       }
     },
-    async transform(source, id) {
-      if (hasSpecialQueries(id)) return;
-      const parsedId = parseAstroRequest(id);
-      if (!parsedId.filename.endsWith(".astro") || parsedId.query.astro) {
-        if (this.environment.name === "client") {
-          const astroFilename = normalizePath(normalizeFilename(parsedId.filename, config.root));
-          const compileMetadata = astroFileToCompileMetadata.get(astroFilename);
-          if (compileMetadata && parsedId.query.type === "style" && parsedId.query.index != null) {
-            const result = compileMetadata.css[parsedId.query.index];
-            result.dependencies?.forEach((dep) => this.addWatchFile(dep));
-          }
+    {
+      name: "astro:build:normal",
+      // If Vite resolver can't resolve the Astro request, it's likely a virtual Astro file, fallback here instead
+      resolveId: {
+        filter: {
+          id: /(?:\?|&)astro(?:&|=|$)/
+        },
+        handler(id) {
+          return id;
         }
-        return;
-      }
-      const filename = normalizePath(parsedId.filename);
-      const transformResult = await compile(source, filename);
-      const astroMetadata = {
-        // Remove Astro components that have been mistakenly given client directives
-        // We'll warn the user about this later, but for now we'll prevent them from breaking the build
-        clientOnlyComponents: transformResult.clientOnlyComponents.filter(notAstroComponent),
-        hydratedComponents: transformResult.hydratedComponents.filter(notAstroComponent),
-        serverComponents: transformResult.serverComponents,
-        scripts: transformResult.scripts,
-        containsHead: transformResult.containsHead,
-        propagation: transformResult.propagation ? "self" : "none",
-        pageOptions: {}
-      };
-      return {
-        code: transformResult.code,
-        map: transformResult.map,
-        meta: {
-          astro: astroMetadata,
-          vite: {
-            // Setting this vite metadata to `ts` causes Vite to resolve .js
-            // extensions to .ts files.
-            lang: "ts"
-          }
-        }
-      };
-    },
-    async handleHotUpdate(ctx) {
-      return handleHotUpdate(ctx, { logger, astroFileToCompileMetadata });
-    }
-  };
-  const normalPlugin = {
-    name: "astro:build:normal",
-    resolveId(id) {
-      const parsedId = parseAstroRequest(id);
-      if (parsedId.query.astro) {
-        return id;
       }
     }
-  };
-  return [prePlugin, normalPlugin];
+  ];
 }
 function appendSourceMap(content, map) {
   if (!map) return content;
-  return `${content}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(
+  return `${content}${"\n//#"} sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(
     map
   ).toString("base64")}`;
 }

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

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import path from "node:path";
 import { appendForwardSlash } from "@astrojs/internal-helpers/path";
-import colors from "picocolors";
+import colors from "piccolore";
 import { notFoundTemplate, subpathNotUsedTemplate } from "../template/4xx.js";
 import { writeHtmlResponse } from "./response.js";
 function baseMiddleware(settings, logger) {

package/dist/vite-plugin-astro-server/controller.d.ts

@@ -16,7 +16,7 @@ interface RunWithErrorHandlingParams {
     controller: DevServerController;
     pathname: string;
     run: () => Promise<any>;
-    onError: (error: unknown) => Error;
+    onError: (error: unknown) => Error | undefined;
 }
 export declare function runWithErrorHandling({ controller: { state }, pathname, run, onError, }: RunWithErrorHandlingParams): Promise<void>;
 export {};

package/dist/vite-plugin-astro-server/error.d.ts

@@ -1,7 +1,6 @@
+import type { SSRManifest } from '../core/app/types.js';
+import type { Logger } from '../core/logger/core.js';
 import type { ModuleLoader } from '../core/module-loader/index.js';
-import type { AstroConfig } from '../types/public/config.js';
-import type { DevPipeline } from './pipeline.js';
-export declare function recordServerError(loader: ModuleLoader, config: AstroConfig, { logger }: DevPipeline, _err: unknown): {
-    error: Error;
+export declare function recordServerError(loader: ModuleLoader, manifest: SSRManifest, logger: Logger, err: Error): {
     errorWithMetadata: import("../core/errors/errors.js").ErrorWithMetadata;
 };

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

@@ -1,16 +1,13 @@
 import { collectErrorMetadata } from "../core/errors/dev/index.js";
-import { createSafeError } from "../core/errors/index.js";
 import { formatErrorMessage } from "../core/messages.js";
-function recordServerError(loader, config, { logger }, _err) {
-  const err = createSafeError(_err);
+function recordServerError(loader, manifest, logger, err) {
   try {
     loader.fixStacktrace(err);
   } catch {
   }
-  const errorWithMetadata = collectErrorMetadata(err, config.root);
+  const errorWithMetadata = collectErrorMetadata(err, manifest.rootDir);
   logger.error(null, formatErrorMessage(errorWithMetadata, logger.level() === "debug"));
   return {
-    error: err,
     errorWithMetadata
   };
 }

package/dist/vite-plugin-astro-server/index.d.ts

@@ -1,3 +1,2 @@
 export { createController, runWithErrorHandling } from './controller.js';
 export { default as vitePluginAstroServer } from './plugin.js';
-export { handleRequest } from './request.js';

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

@@ -1,9 +1,7 @@
 import { createController, runWithErrorHandling } from "./controller.js";
 import { default as default2 } from "./plugin.js";
-import { handleRequest } from "./request.js";
 export {
   createController,
-  handleRequest,
   runWithErrorHandling,
   default2 as vitePluginAstroServer
 };