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

package/dist/vite-plugin-pages/page.js

@@ -0,0 +1,54 @@
+import { prependForwardSlash } from "../core/path.js";
+import { DEFAULT_COMPONENTS } from "../core/routing/default.js";
+import { routeIsRedirect } from "../core/routing/index.js";
+import { VIRTUAL_PAGE_MODULE_ID, VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "./const.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+function pluginPage({ routesList }) {
+  return {
+    name: "@astro/plugin-page",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_PAGE_MODULE_ID}`)
+      },
+      handler(id) {
+        return VIRTUAL_PAGE_RESOLVED_MODULE_ID + id.slice(VIRTUAL_PAGE_MODULE_ID.length);
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_PAGE_RESOLVED_MODULE_ID}`)
+      },
+      handler(id) {
+        const componentPath = getComponentFromVirtualModulePageName(
+          VIRTUAL_PAGE_RESOLVED_MODULE_ID,
+          id
+        );
+        if (DEFAULT_COMPONENTS.some((component) => componentPath === component)) {
+          return { code: "" };
+        }
+        const routes = routesList.routes.filter((route) => route.component === componentPath);
+        for (const route of routes) {
+          if (routeIsRedirect(route)) {
+            continue;
+          }
+          const astroModuleId = prependForwardSlash(componentPath);
+          const imports = [];
+          const exports = [];
+          imports.push(`import * as _page from ${JSON.stringify(astroModuleId)};`);
+          exports.push(`export const page = () => _page`);
+          return { code: `${imports.join("\n")}
+${exports.join("\n")}` };
+        }
+      }
+    }
+  };
+}
+function getComponentFromVirtualModulePageName(virtualModulePrefix, id) {
+  return id.slice(virtualModulePrefix.length).replace(/@_@/g, ".");
+}
+export {
+  pluginPage
+};

package/dist/vite-plugin-pages/pages.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { RoutesList } from '../types/astro.js';
+export declare const VIRTUAL_PAGES_MODULE_ID = "virtual:astro:pages";
+interface PagesPluginOptions {
+    routesList: RoutesList;
+}
+export declare function pluginPages({ routesList }: PagesPluginOptions): VitePlugin;
+export {};

package/dist/vite-plugin-pages/pages.js

@@ -0,0 +1,63 @@
+import { DEFAULT_COMPONENTS } from "../core/routing/default.js";
+import { routeIsRedirect } from "../core/routing/index.js";
+import { VIRTUAL_PAGE_MODULE_ID } from "./const.js";
+import { getVirtualModulePageName } from "./util.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+const VIRTUAL_PAGES_MODULE_ID = "virtual:astro:pages";
+const VIRTUAL_PAGES_RESOLVED_MODULE_ID = "\0" + VIRTUAL_PAGES_MODULE_ID;
+function pluginPages({ routesList }) {
+  return {
+    name: "@astro/plugin-pages",
+    enforce: "post",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_PAGES_MODULE_ID}$`)
+      },
+      handler() {
+        return VIRTUAL_PAGES_RESOLVED_MODULE_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_PAGES_RESOLVED_MODULE_ID}$`)
+      },
+      async handler() {
+        const imports = [];
+        const pageMap = [];
+        let i = 0;
+        for (const route of routesList.routes) {
+          if (routeIsRedirect(route)) {
+            continue;
+          }
+          if (DEFAULT_COMPONENTS.some((component) => route.component === component)) {
+            continue;
+          }
+          const virtualModuleName = getVirtualModulePageName(
+            VIRTUAL_PAGE_MODULE_ID,
+            route.component
+          );
+          const module = await this.resolve(virtualModuleName);
+          if (module) {
+            const variable = `_page${i}`;
+            imports.push(`const ${variable} = () => import("${virtualModuleName}");`);
+            pageMap.push(`[${JSON.stringify(route.component)}, ${variable}]`);
+            i++;
+          }
+        }
+        const pageMapCode = `const pageMap = new Map([
+    ${pageMap.join(",\n    ")}
+]);
+
+export { pageMap };`;
+        return { code: [...imports, pageMapCode].join("\n") };
+      }
+    }
+  };
+}
+export {
+  VIRTUAL_PAGES_MODULE_ID,
+  pluginPages
+};

package/dist/vite-plugin-pages/util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prevents Rollup from triggering other plugins in the process by masking the extension (hence the virtual file).
+ * Inverse function of getComponentFromVirtualModulePageName() below.
+ * @param virtualModulePrefix The prefix used to create the virtual module
+ * @param path Page component path
+ */
+export declare function getVirtualModulePageName(virtualModulePrefix: string, path: string): string;
+export declare function getVirtualModulePageNameForComponent(component: string): string;

package/dist/vite-plugin-pages/util.js

@@ -0,0 +1,15 @@
+import { fileExtension } from "@astrojs/internal-helpers/path";
+import { VIRTUAL_PAGE_MODULE_ID } from "./const.js";
+const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
+function getVirtualModulePageName(virtualModulePrefix, path) {
+  const extension = fileExtension(path);
+  return virtualModulePrefix + (extension.startsWith(".") ? path.slice(0, -extension.length) + extension.replace(".", ASTRO_PAGE_EXTENSION_POST_PATTERN) : path);
+}
+function getVirtualModulePageNameForComponent(component) {
+  const virtualModuleName = getVirtualModulePageName(VIRTUAL_PAGE_MODULE_ID, component);
+  return virtualModuleName;
+}
+export {
+  getVirtualModulePageName,
+  getVirtualModulePageNameForComponent
+};

package/dist/vite-plugin-renderers/index.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../types/astro.js';
+export declare const ASTRO_RENDERERS_MODULE_ID = "virtual:astro:renderers";
+export declare const RESOLVED_ASTRO_RENDERERS_MODULE_ID = "\0virtual:astro:renderers";
+interface PluginOptions {
+    settings: AstroSettings;
+}
+export default function vitePluginRenderers(options: PluginOptions): VitePlugin;
+export {};

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

@@ -0,0 +1,45 @@
+const ASTRO_RENDERERS_MODULE_ID = "virtual:astro:renderers";
+const RESOLVED_ASTRO_RENDERERS_MODULE_ID = `\0${ASTRO_RENDERERS_MODULE_ID}`;
+function vitePluginRenderers(options) {
+  const renderers = options.settings.renderers;
+  return {
+    name: "astro:plugin-renderers",
+    enforce: "pre",
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${ASTRO_RENDERERS_MODULE_ID}$`)
+      },
+      handler() {
+        return RESOLVED_ASTRO_RENDERERS_MODULE_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_ASTRO_RENDERERS_MODULE_ID}$`)
+      },
+      handler() {
+        if (renderers.length > 0) {
+          const imports = [];
+          const exports = [];
+          let i = 0;
+          let rendererItems = "";
+          for (const renderer of renderers) {
+            const variable = `_renderer${i}`;
+            imports.push(`import ${variable} from ${JSON.stringify(renderer.serverEntrypoint)};`);
+            rendererItems += `Object.assign(${JSON.stringify(renderer)}, { ssr: ${variable} }),`;
+            i++;
+          }
+          exports.push(`export const renderers = [${rendererItems}];`);
+          return { code: `${imports.join("\n")}
+${exports.join("\n")}` };
+        }
+        return { code: `export const renderers = [];` };
+      }
+    }
+  };
+}
+export {
+  ASTRO_RENDERERS_MODULE_ID,
+  RESOLVED_ASTRO_RENDERERS_MODULE_ID,
+  vitePluginRenderers as default
+};

package/dist/vite-plugin-routes/index.d.ts

@@ -0,0 +1,14 @@
+import type fsMod from 'node:fs';
+import { type Plugin } from 'vite';
+import type { Logger } from '../core/logger/core.js';
+import type { AstroSettings, RoutesList } from '../types/astro.js';
+type Payload = {
+    settings: AstroSettings;
+    logger: Logger;
+    fsMod?: typeof fsMod;
+    routesList: RoutesList;
+    command: 'dev' | 'build';
+};
+export declare const ASTRO_ROUTES_MODULE_ID = "virtual:astro:routes";
+export default function astroPluginRoutes({ settings, logger, fsMod, routesList: initialRoutesList, command, }: Payload): Promise<Plugin>;
+export {};

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

@@ -0,0 +1,181 @@
+import { extname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import colors from "piccolore";
+import { normalizePath } from "vite";
+import { serializeRouteData } from "../core/app/index.js";
+import { warnMissingAdapter } from "../core/dev/adapter-validation.js";
+import { createRoutesList } from "../core/routing/index.js";
+import { getRoutePrerenderOption } from "../core/routing/manifest/prerender.js";
+import { isEndpoint, isPage } from "../core/util.js";
+import { rootRelativePath } from "../core/viteUtils.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { isAstroServerEnvironment } from "../environments.js";
+const ASTRO_ROUTES_MODULE_ID = "virtual:astro:routes";
+const ASTRO_ROUTES_MODULE_ID_RESOLVED = "\0" + ASTRO_ROUTES_MODULE_ID;
+const KNOWN_FILE_EXTENSIONS = [".astro", ".js", ".ts"];
+async function astroPluginRoutes({
+  settings,
+  logger,
+  fsMod,
+  routesList: initialRoutesList,
+  command
+}) {
+  logger.debug("update", "Re-calculate routes");
+  let routeList = initialRoutesList;
+  let serializedRouteInfo = routeList.routes.map(
+    (r) => {
+      return {
+        file: "",
+        links: [],
+        scripts: [],
+        styles: [],
+        routeData: serializeRouteData(r, settings.config.trailingSlash)
+      };
+    }
+  );
+  async function rebuildRoutes(path = null, server) {
+    if (path != null && path.startsWith(settings.config.srcDir.pathname)) {
+      logger.debug(
+        "update",
+        `Re-calculating routes for ${path.slice(settings.config.srcDir.pathname.length)}`
+      );
+      const file = pathToFileURL(normalizePath(path));
+      routeList = await createRoutesList(
+        {
+          settings,
+          fsMod
+        },
+        logger,
+        { dev: command === "dev" }
+      );
+      serializedRouteInfo = routeList.routes.map((r) => {
+        return {
+          file: fileURLToPath(file),
+          links: [],
+          scripts: [],
+          styles: [],
+          routeData: serializeRouteData(r, settings.config.trailingSlash)
+        };
+      });
+      let environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      const virtualMod = environment.moduleGraph.getModuleById(ASTRO_ROUTES_MODULE_ID_RESOLVED);
+      if (!virtualMod) return;
+      environment.moduleGraph.invalidateModule(virtualMod);
+    }
+  }
+  return {
+    name: "astro:routes",
+    configureServer(server) {
+      server.watcher.on("add", (path) => rebuildRoutes(path, server));
+      server.watcher.on("unlink", (path) => rebuildRoutes(path, server));
+      server.watcher.on("change", (path) => rebuildRoutes(path, server));
+    },
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${ASTRO_ROUTES_MODULE_ID}$`)
+      },
+      handler() {
+        return ASTRO_ROUTES_MODULE_ID_RESOLVED;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${ASTRO_ROUTES_MODULE_ID_RESOLVED}$`)
+      },
+      handler() {
+        const environmentName = this.environment.name;
+        const filteredRoutes = serializedRouteInfo.filter((routeInfo) => {
+          if (command === "build") {
+            if (environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.prerender) {
+              return routeInfo.routeData.prerender;
+            }
+            if (environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr) {
+              return !routeInfo.routeData.prerender;
+            }
+          }
+          return true;
+        });
+        const code = `
+				import { deserializeRouteInfo } from 'astro/app';
+				const serializedData = ${JSON.stringify(filteredRoutes)};
+				const routes = serializedData.map(deserializeRouteInfo);
+				export { routes };
+				`;
+        return { code };
+      }
+    },
+    async transform(code, id) {
+      if (!isAstroServerEnvironment(this.environment)) return;
+      const filename = normalizePath(id);
+      let fileURL;
+      try {
+        fileURL = new URL(`file://${filename}`);
+      } catch {
+        return;
+      }
+      const fileIsPage = isPage(fileURL, settings);
+      const fileIsEndpoint = isEndpoint(fileURL, settings);
+      if (!(fileIsPage || fileIsEndpoint)) return;
+      const route = routeList.routes.find((r) => {
+        const filePath = new URL(`./${r.component}`, settings.config.root);
+        return normalizePath(fileURLToPath(filePath)) === filename;
+      });
+      if (!route) {
+        return;
+      }
+      if (!route.prerender && code.includes("getStaticPaths") && // this should only be valid for `.astro`, `.js` and `.ts` files
+      KNOWN_FILE_EXTENSIONS.includes(extname(filename))) {
+        logger.warn(
+          "router",
+          `getStaticPaths() ignored in dynamic page ${colors.bold(
+            rootRelativePath(settings.config.root, fileURL, true)
+          )}. Add \`export const prerender = true;\` to prerender the page as static HTML during the build process.`
+        );
+      }
+      const { meta = {} } = this.getModuleInfo(id) ?? {};
+      return {
+        code,
+        map: null,
+        meta: {
+          ...meta,
+          astro: {
+            ...meta.astro ?? createDefaultAstroMetadata(),
+            pageOptions: {
+              prerender: route.prerender
+            }
+          }
+        }
+      };
+    },
+    // Handle hot updates to update the prerender option
+    async handleHotUpdate(ctx) {
+      const filename = normalizePath(ctx.file);
+      let fileURL;
+      try {
+        fileURL = new URL(`file://${filename}`);
+      } catch {
+        return;
+      }
+      const fileIsPage = isPage(fileURL, settings);
+      const fileIsEndpoint = isEndpoint(fileURL, settings);
+      if (!(fileIsPage || fileIsEndpoint)) return;
+      const route = routeList.routes.find((r) => {
+        const filePath = new URL(`./${r.component}`, settings.config.root);
+        return normalizePath(fileURLToPath(filePath)) === filename;
+      });
+      if (!route) {
+        return;
+      }
+      await getRoutePrerenderOption(await ctx.read(), route, settings, logger);
+      warnMissingAdapter(logger, settings);
+    }
+  };
+}
+export {
+  ASTRO_ROUTES_MODULE_ID,
+  astroPluginRoutes as default
+};

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

@@ -1,42 +1,44 @@
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 const SCRIPT_ID_PREFIX = `astro:scripts/`;
 const BEFORE_HYDRATION_SCRIPT_ID = `${SCRIPT_ID_PREFIX}${"before-hydration"}.js`;
 const PAGE_SCRIPT_ID = `${SCRIPT_ID_PREFIX}${"page"}.js`;
 const PAGE_SSR_SCRIPT_ID = `${SCRIPT_ID_PREFIX}${"page-ssr"}.js`;
 function astroScriptsPlugin({ settings }) {
-  let env = void 0;
   return {
     name: "astro:scripts",
-    config(_config, _env) {
-      env = _env;
-    },
-    async resolveId(id) {
-      if (id.startsWith(SCRIPT_ID_PREFIX)) {
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${SCRIPT_ID_PREFIX}`)
+      },
+      handler(id) {
         return id;
       }
-      return void 0;
     },
-    async load(id) {
-      if (id === BEFORE_HYDRATION_SCRIPT_ID) {
-        return {
-          code: settings.scripts.filter((s) => s.stage === "before-hydration").map((s) => s.content).join("\n")
-        };
-      }
-      if (id === PAGE_SCRIPT_ID) {
-        return {
-          code: settings.scripts.filter((s) => s.stage === "page").map((s) => s.content).join("\n")
-        };
-      }
-      if (id === PAGE_SSR_SCRIPT_ID) {
-        return {
-          code: settings.scripts.filter((s) => s.stage === "page-ssr").map((s) => s.content).join("\n")
-        };
+    load: {
+      filter: {
+        id: new RegExp(`^(${BEFORE_HYDRATION_SCRIPT_ID}|${PAGE_SCRIPT_ID}|${PAGE_SSR_SCRIPT_ID})$`)
+      },
+      handler(id) {
+        if (id === BEFORE_HYDRATION_SCRIPT_ID) {
+          return {
+            code: settings.scripts.filter((s) => s.stage === "before-hydration").map((s) => s.content).join("\n")
+          };
+        }
+        if (id === PAGE_SCRIPT_ID) {
+          return {
+            code: settings.scripts.filter((s) => s.stage === "page").map((s) => s.content).join("\n")
+          };
+        }
+        if (id === PAGE_SSR_SCRIPT_ID) {
+          return {
+            code: settings.scripts.filter((s) => s.stage === "page-ssr").map((s) => s.content).join("\n")
+          };
+        }
       }
-      return null;
     },
     buildStart() {
       const hasHydrationScripts = settings.scripts.some((s) => s.stage === "before-hydration");
-      const isSsrBuild = env?.isSsrBuild;
-      if (hasHydrationScripts && env?.command === "build" && !isSsrBuild) {
+      if (hasHydrationScripts && (this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr)) {
         this.emitFile({
           type: "chunk",
           id: BEFORE_HYDRATION_SCRIPT_ID,

package/dist/vite-plugin-scripts/page-ssr.js

@@ -2,14 +2,15 @@ import MagicString from "magic-string";
 import { normalizePath } from "vite";
 import { isPage } from "../core/util.js";
 import { PAGE_SSR_SCRIPT_ID } from "./index.js";
+import { isAstroServerEnvironment } from "../environments.js";
 function astroScriptsPostPlugin({
   settings
 }) {
   return {
     name: "astro:scripts:page-ssr",
     enforce: "post",
-    transform(code, id, options) {
-      if (!options?.ssr) return;
+    transform(code, id) {
+      if (!isAstroServerEnvironment(this.environment)) return;
       const hasInjectedScript = settings.scripts.some((s2) => s2.stage === "page-ssr");
       if (!hasInjectedScript) return;
       const filename = normalizePath(id);

package/dist/vite-plugin-utils/index.d.ts

@@ -13,6 +13,7 @@ export declare function getFileInfo(id: string, config: AstroConfig): {
  */
 export declare function normalizeFilename(filename: string, root: URL): string;
 export declare function cleanUrl(url: string): string;
+export declare const specialQueriesRE: RegExp;
 /**
  * Detect `?url`, `?raw`, and `?direct`, in which case we usually want to skip
  * transforming any code with this queries as Vite will handle it directly.

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

@@ -41,5 +41,6 @@ export {
   cleanUrl,
   getFileInfo,
   hasSpecialQueries,
-  normalizeFilename
+  normalizeFilename,
+  specialQueriesRE
 };

package/dist/zod.d.ts

@@ -1,4 +1,4 @@
-import * as mod from 'zod';
-export * from 'zod';
+import * as mod from 'zod/v4';
+export * from 'zod/v4';
 export { mod as z };
 export default mod;

package/dist/zod.js

@@ -1,5 +1,5 @@
-import * as mod from "zod";
-export * from "zod";
+import * as mod from "zod/v4";
+export * from "zod/v4";
 var zod_default = mod;
 export {
   zod_default as default,