astro 5.16.5 → 6.0.0-alpha.1

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

@@ -1,22 +1,22 @@
 import npath from "node:path";
+import { isCSSRequest } from "vite";
 import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "../core/constants.js";
 import { unwrapId } from "../core/util.js";
 import { hasSpecialQueries } from "../vite-plugin-utils/index.js";
-import { isCSSRequest } from "./util.js";
 const fileExtensionsToSSR = /* @__PURE__ */ new Set([".astro", ".mdoc", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS]);
 const STRIP_QUERY_PARAMS_REGEX = /\?.*$/;
-async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
+async function* crawlGraph(environment, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
   const id = unwrapId(_id);
   const importedModules = /* @__PURE__ */ new Set();
   const moduleEntriesForId = isRootFile ? (
     // "getModulesByFile" pulls from a delayed module cache (fun implementation detail),
     // So we can get up-to-date info on initial server load.
     // Needed for slower CSS preprocessing like Tailwind
-    loader.getModulesByFile(id) ?? /* @__PURE__ */ new Set()
+    environment.moduleGraph.getModulesByFile(id) ?? /* @__PURE__ */ new Set()
   ) : (
     // For non-root files, we're safe to pull from "getModuleById" based on testing.
     // TODO: Find better invalidation strategy to use "getModuleById" in all cases!
-    /* @__PURE__ */ new Set([loader.getModuleById(id)])
+    /* @__PURE__ */ new Set([environment.moduleGraph.getModuleById(id)])
   );
   for (const entry of moduleEntriesForId) {
     if (!entry) {
@@ -37,10 +37,10 @@ async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ ne
         const isPropagationStoppingPoint = importedModule.id.includes("?astroPropagatedAssets");
         if (isFileTypeNeedingSSR && // Should not SSR a module with ?astroPropagatedAssets
         !isPropagationStoppingPoint) {
-          const mod = loader.getModuleById(importedModule.id);
+          const mod = environment.moduleGraph.getModuleById(importedModule.id);
           if (!mod?.ssrModule) {
             try {
-              await loader.import(importedModule.id);
+              await environment.runner.import(importedModule.id);
             } catch {
             }
           }
@@ -56,7 +56,7 @@ async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ ne
       continue;
     }
     yield importedModule;
-    yield* crawlGraph(loader, importedModule.id, false, scanned);
+    yield* crawlGraph(environment, importedModule.id, false, scanned);
   }
 }
 function isImportedBy(parent, entry) {

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

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { normalizePath } from "vite";
 const getConfigAlias = (settings) => {
@@ -30,6 +31,39 @@ const getConfigAlias = (settings) => {
   }
   return aliases;
 };
+const getViteResolveAlias = (settings) => {
+  const { tsConfig, tsConfigPath } = settings;
+  if (!tsConfig || !tsConfigPath || !tsConfig.compilerOptions) return [];
+  const { baseUrl, paths } = tsConfig.compilerOptions;
+  const effectiveBaseUrl = baseUrl ?? (paths ? "." : void 0);
+  if (!effectiveBaseUrl) return [];
+  const resolvedBaseUrl = path.resolve(path.dirname(tsConfigPath), effectiveBaseUrl);
+  const aliases = [];
+  if (paths) {
+    for (const [aliasPattern, values] of Object.entries(paths)) {
+      const resolvedValues = values.map((v) => path.resolve(resolvedBaseUrl, v));
+      const customResolver = (id) => {
+        for (const resolvedValue of resolvedValues) {
+          const resolved = resolvedValue.replace("*", id);
+          if (fs.existsSync(resolved)) {
+            return resolved;
+          }
+        }
+        return null;
+      };
+      aliases.push({
+        // Build regex from alias pattern (e.g., '@styles/*' -> /^@styles\/(.+)$/)
+        // First, escape special regex chars. Then replace * with a capture group (.+)
+        find: new RegExp(
+          `^${aliasPattern.replace(/[\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*/g, "(.+)")}$`
+        ),
+        replacement: aliasPattern.includes("*") ? "$1" : aliasPattern,
+        customResolver
+      });
+    }
+  }
+  return aliases;
+};
 function configAliasVitePlugin({
   settings
 }) {
@@ -39,8 +73,12 @@ function configAliasVitePlugin({
     name: "astro:tsconfig-alias",
     // use post to only resolve ids that all other plugins before it can't
     enforce: "post",
-    configResolved(config) {
-      patchCreateResolver(config, plugin);
+    config() {
+      return {
+        resolve: {
+          alias: getViteResolveAlias(settings)
+        }
+      };
     },
     async resolveId(id, importer, options) {
       if (isVirtualId(id)) return;
@@ -58,36 +96,6 @@ function configAliasVitePlugin({
   };
   return plugin;
 }
-function patchCreateResolver(config, postPlugin) {
-  const _createResolver = config.createResolver;
-  config.createResolver = function(...args1) {
-    const resolver = _createResolver.apply(config, args1);
-    return async function(...args2) {
-      const id = args2[0];
-      const importer = args2[1];
-      const ssr = args2[3];
-      if (importer?.includes("node_modules")) {
-        return resolver.apply(_createResolver, args2);
-      }
-      const fakePluginContext = {
-        resolve: (_id, _importer) => resolver(_id, _importer, false, ssr)
-      };
-      const fakeResolveIdOpts = {
-        assertions: {},
-        isEntry: false,
-        ssr
-      };
-      const result = await resolver.apply(_createResolver, args2);
-      if (result) return result;
-      const resolved = await postPlugin.resolveId.apply(fakePluginContext, [
-        id,
-        importer,
-        fakeResolveIdOpts
-      ]);
-      if (resolved) return resolved;
-    };
-  };
-}
 function isVirtualId(id) {
   return id.includes("\0") || id.startsWith("virtual:") || id.startsWith("astro:");
 }

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

@@ -0,0 +1,18 @@
+import type { Plugin } from 'vite';
+import type { RoutesList } from '../types/astro.js';
+interface AstroVitePluginOptions {
+    routesList: RoutesList;
+    command: 'dev' | 'build';
+}
+/**
+ * This plugin tracks the CSS that should be applied by route.
+ *
+ * The virtual module should be used only during development.
+ * Per-route virtual modules are created to avoid invalidation loops.
+ *
+ * The second plugin imports all of the individual CSS modules in a map.
+ *
+ * @param routesList
+ */
+export declare function astroDevCssPlugin({ routesList, command }: AstroVitePluginOptions): Plugin[];
+export {};

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

@@ -0,0 +1,134 @@
+import { wrapId } from "../core/util.js";
+import { isBuildableCSSRequest } from "../vite-plugin-astro-server/util.js";
+import { getVirtualModulePageNameForComponent } from "../vite-plugin-pages/util.js";
+import { getDevCSSModuleName } from "./util.js";
+import { prependForwardSlash } from "@astrojs/internal-helpers/path";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+const MODULE_DEV_CSS = "virtual:astro:dev-css";
+const RESOLVED_MODULE_DEV_CSS = "\0" + MODULE_DEV_CSS;
+const MODULE_DEV_CSS_PREFIX = "virtual:astro:dev-css:";
+const RESOLVED_MODULE_DEV_CSS_PREFIX = "\0" + MODULE_DEV_CSS_PREFIX;
+const MODULE_DEV_CSS_ALL = "virtual:astro:dev-css-all";
+const RESOLVED_MODULE_DEV_CSS_ALL = "\0" + MODULE_DEV_CSS_ALL;
+const ASTRO_CSS_EXTENSION_POST_PATTERN = "@_@";
+function getComponentFromVirtualModuleCssName(virtualModulePrefix, id) {
+  return id.slice(virtualModulePrefix.length).replace(new RegExp(ASTRO_CSS_EXTENSION_POST_PATTERN, "g"), ".");
+}
+function* collectCSSWithOrder(id, mod, seen = /* @__PURE__ */ new Set()) {
+  seen.add(id);
+  const imported = Array.from(mod.importedModules);
+  if (isBuildableCSSRequest(id)) {
+    yield {
+      id: wrapId(mod.id ?? mod.url),
+      idKey: id,
+      content: "",
+      url: prependForwardSlash(wrapId(mod.url))
+    };
+    return;
+  } else if (id.endsWith("?raw")) {
+    return;
+  }
+  for (const imp of imported) {
+    if (imp.id && !seen.has(imp?.id)) {
+      yield* collectCSSWithOrder(imp.id, imp, seen);
+    }
+  }
+}
+function astroDevCssPlugin({ routesList, command }) {
+  let environment = void 0;
+  const cssContentCache = /* @__PURE__ */ new Map();
+  return [
+    {
+      name: MODULE_DEV_CSS,
+      async configureServer(server) {
+        environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      },
+      resolveId(id) {
+        if (id === MODULE_DEV_CSS) {
+          return RESOLVED_MODULE_DEV_CSS;
+        }
+        if (id.startsWith(MODULE_DEV_CSS_PREFIX)) {
+          return RESOLVED_MODULE_DEV_CSS_PREFIX + id.slice(MODULE_DEV_CSS_PREFIX.length);
+        }
+      },
+      async load(id) {
+        if (id === RESOLVED_MODULE_DEV_CSS) {
+          return {
+            code: `export const css = new Set()`
+          };
+        }
+        if (id.startsWith(RESOLVED_MODULE_DEV_CSS_PREFIX)) {
+          const componentPath = getComponentFromVirtualModuleCssName(
+            RESOLVED_MODULE_DEV_CSS_PREFIX,
+            id
+          );
+          const cssWithOrder = /* @__PURE__ */ new Map();
+          const componentPageId = getVirtualModulePageNameForComponent(componentPath);
+          await environment?.runner?.import(componentPageId);
+          const resolved = await environment?.pluginContainer.resolveId(componentPageId);
+          if (!resolved?.id) {
+            return {
+              code: "export const css = new Set()"
+            };
+          }
+          const mod = environment?.moduleGraph.getModuleById(resolved.id);
+          if (!mod) {
+            return {
+              code: "export const css = new Set()"
+            };
+          }
+          for (const collected of collectCSSWithOrder(componentPageId, mod)) {
+            if (!cssWithOrder.has(collected.idKey)) {
+              const content = cssContentCache.get(collected.id) || collected.content;
+              cssWithOrder.set(collected.idKey, { ...collected, content });
+            }
+          }
+          const cssArray = Array.from(cssWithOrder.values());
+          const cleanedCss = cssArray.map(({ content, id: cssId, url }) => ({
+            content,
+            id: cssId,
+            url
+          }));
+          return {
+            code: `export const css = new Set(${JSON.stringify(cleanedCss)})`
+          };
+        }
+      },
+      async transform(code, id) {
+        if (command === "build") {
+          return;
+        }
+        if (isBuildableCSSRequest(id)) {
+          const mod = environment?.moduleGraph.getModuleById(id);
+          if (mod) {
+            cssContentCache.set(id, code);
+          }
+        }
+      }
+    },
+    {
+      name: MODULE_DEV_CSS_ALL,
+      resolveId(id) {
+        if (id === MODULE_DEV_CSS_ALL) {
+          return RESOLVED_MODULE_DEV_CSS_ALL;
+        }
+      },
+      load(id) {
+        if (id === RESOLVED_MODULE_DEV_CSS_ALL) {
+          let code = `export const devCSSMap = new Map([`;
+          for (const route of routesList.routes) {
+            code += `
+	[${JSON.stringify(route.component)}, () => import(${JSON.stringify(getDevCSSModuleName(route.component))})],`;
+          }
+          code += "]);";
+          return {
+            code
+          };
+        }
+      }
+    }
+  ];
+}
+export {
+  astroDevCssPlugin
+};

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

@@ -0,0 +1,5 @@
+/**
+ * Get the virtual module name for a dev CSS import.
+ * Usage: `await loader.import(getDevCSSModuleName(routeData.component))`
+ */
+export declare function getDevCSSModuleName(componentPath: string): string;

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

@@ -0,0 +1,8 @@
+import { getVirtualModulePageName } from "../vite-plugin-pages/util.js";
+const MODULE_DEV_CSS_PREFIX = "virtual:astro:dev-css:";
+function getDevCSSModuleName(componentPath) {
+  return getVirtualModulePageName(MODULE_DEV_CSS_PREFIX, componentPath);
+}
+export {
+  getDevCSSModuleName
+};

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

@@ -0,0 +1,15 @@
+import type * as vite from 'vite';
+import type { AstroSettings } from '../types/astro.js';
+import type { CrawlFrameworkPkgsResult } from 'vitefu';
+interface Payload {
+    command: 'dev' | 'build';
+    settings: AstroSettings;
+    astroPkgsConfig: CrawlFrameworkPkgsResult;
+}
+/**
+ * This plugin is responsible of setting up the environments of the vite server, such as
+ * dependencies, SSR, etc.
+ *
+ */
+export declare function vitePluginEnvironment({ command, settings, astroPkgsConfig, }: Payload): vite.Plugin;
+export {};

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

@@ -0,0 +1,77 @@
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { convertPathToPattern } from "tinyglobby";
+import { fileURLToPath } from "node:url";
+const ONLY_DEV_EXTERNAL = [
+  // Imported by `@astrojs/prism` which exposes `<Prism/>` that is processed by Vite
+  "prismjs/components/index.js",
+  // Imported by `astro/assets` -> `packages/astro/src/core/logger/core.ts`
+  "string-width",
+  // Imported by `astro:transitions` -> packages/astro/src/runtime/server/transition.ts
+  "cssesc"
+];
+const ALWAYS_NOEXTERNAL = [
+  // This is only because Vite's native ESM doesn't resolve "exports" correctly.
+  "astro",
+  // Vite fails on nested `.astro` imports without bundling
+  "astro/components",
+  // Handle recommended nanostores. Only @nanostores/preact is required from our testing!
+  // Full explanation and related bug report: https://github.com/withastro/astro/pull/3667
+  "@nanostores/preact",
+  // fontsource packages are CSS that need to be processed
+  "@fontsource/*"
+];
+function vitePluginEnvironment({
+  command,
+  settings,
+  astroPkgsConfig
+}) {
+  const srcDirPattern = convertPathToPattern(fileURLToPath(settings.config.srcDir));
+  return {
+    name: "astro:environment",
+    configEnvironment(environmentName, _options) {
+      const finalEnvironmentOptions = {
+        optimizeDeps: {
+          include: [],
+          exclude: []
+        },
+        resolve: {
+          // Astro imports in third-party packages should use the same version as root
+          dedupe: ["astro"]
+        }
+      };
+      if (environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.astro || environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
+        if (_options.resolve?.noExternal !== true) {
+          finalEnvironmentOptions.resolve.noExternal = [
+            ...ALWAYS_NOEXTERNAL,
+            ...astroPkgsConfig.ssr.noExternal
+          ];
+          finalEnvironmentOptions.resolve.external = [
+            ...command === "dev" ? ONLY_DEV_EXTERNAL : [],
+            ...astroPkgsConfig.ssr.external
+          ];
+        }
+        if (_options.optimizeDeps?.noDiscovery === false) {
+          finalEnvironmentOptions.optimizeDeps = {
+            entries: [`${srcDirPattern}**/*.{jsx,tsx,vue,svelte,html,astro}`],
+            include: [],
+            exclude: ["node-fetch"]
+          };
+        }
+      }
+      if (environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
+        finalEnvironmentOptions.optimizeDeps = {
+          include: [
+            // For the dev toolbar
+            "astro > html-escaper"
+          ],
+          // Astro files can't be rendered on the client
+          entries: [`${srcDirPattern}**/*.{jsx,tsx,vue,svelte,html}`]
+        };
+      }
+      return finalEnvironmentOptions;
+    }
+  };
+}
+export {
+  vitePluginEnvironment
+};

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

@@ -1,5 +1,4 @@
 import type * as vite from 'vite';
 import type { BuildInternals } from '../core/build/internal.js';
-import type { AstroBuildPlugin } from '../core/build/plugin.js';
 export default function configHeadVitePlugin(): vite.Plugin;
-export declare function astroHeadBuildPlugin(internals: BuildInternals): AstroBuildPlugin;
+export declare function astroHeadBuildPlugin(internals: BuildInternals): vite.Plugin;

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

@@ -1,12 +1,13 @@
 import { getParentModuleInfos, getTopLevelPageModuleInfos } from "../core/build/graph.js";
 import { getAstroMetadata } from "../vite-plugin-astro/index.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 const injectExp = /(?:^\/\/|\/\/!)\s*astro-head-inject/;
 function configHeadVitePlugin() {
-  let server;
+  let environment;
   function propagateMetadata(id, prop, value, seen = /* @__PURE__ */ new Set()) {
     if (seen.has(id)) return;
     seen.add(id);
-    const mod = server.moduleGraph.getModuleById(id);
+    const mod = environment.moduleGraph.getModuleById(id);
     const info = this.getModuleInfo(id);
     if (info?.meta.astro) {
       const astroMetadata = getAstroMetadata(info);
@@ -24,8 +25,8 @@ function configHeadVitePlugin() {
     name: "astro:head-metadata",
     enforce: "pre",
     apply: "serve",
-    configureServer(_server) {
-      server = _server;
+    configureServer(server) {
+      environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
     },
     resolveId(source, importer) {
       if (importer) {
@@ -47,21 +48,10 @@ function configHeadVitePlugin() {
       }
     },
     transform(source, id) {
-      if (!server) {
-        return;
-      }
       let info = this.getModuleInfo(id);
       if (info && getAstroMetadata(info)?.containsHead) {
         propagateMetadata.call(this, id, "containsHead", true);
       }
-      if (info && getAstroMetadata(info)?.propagation === "self") {
-        const mod = server.moduleGraph.getModuleById(id);
-        for (const parent of mod?.importers ?? []) {
-          if (parent.id) {
-            propagateMetadata.call(this, parent.id, "propagation", "in-tree");
-          }
-        }
-      }
       if (injectExp.test(source)) {
         propagateMetadata.call(this, id, "propagation", "in-tree");
       }
@@ -70,54 +60,48 @@ function configHeadVitePlugin() {
 }
 function astroHeadBuildPlugin(internals) {
   return {
-    targets: ["server"],
-    hooks: {
-      "build:before"() {
-        return {
-          vitePlugin: {
-            name: "astro:head-metadata-build",
-            generateBundle(_opts, bundle) {
-              const map = internals.componentMetadata;
-              function getOrCreateMetadata(id) {
-                if (map.has(id)) return map.get(id);
-                const metadata = {
-                  propagation: "none",
-                  containsHead: false
-                };
-                map.set(id, metadata);
-                return metadata;
+    name: "astro:head-metadata-build",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
+    generateBundle(_opts, bundle) {
+      const map = internals.componentMetadata;
+      function getOrCreateMetadata(id) {
+        if (map.has(id)) return map.get(id);
+        const metadata = {
+          propagation: "none",
+          containsHead: false
+        };
+        map.set(id, metadata);
+        return metadata;
+      }
+      for (const [, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") continue;
+        for (const [id, mod] of Object.entries(output.modules)) {
+          const modinfo = this.getModuleInfo(id);
+          if (modinfo) {
+            const meta = getAstroMetadata(modinfo);
+            if (meta?.containsHead) {
+              for (const pageInfo of getTopLevelPageModuleInfos(id, this)) {
+                let metadata = getOrCreateMetadata(pageInfo.id);
+                metadata.containsHead = true;
               }
-              for (const [, output] of Object.entries(bundle)) {
-                if (output.type !== "chunk") continue;
-                for (const [id, mod] of Object.entries(output.modules)) {
-                  const modinfo = this.getModuleInfo(id);
-                  if (modinfo) {
-                    const meta = getAstroMetadata(modinfo);
-                    if (meta?.containsHead) {
-                      for (const pageInfo of getTopLevelPageModuleInfos(id, this)) {
-                        let metadata = getOrCreateMetadata(pageInfo.id);
-                        metadata.containsHead = true;
-                      }
-                    }
-                    if (meta?.propagation === "self") {
-                      for (const info of getParentModuleInfos(id, this)) {
-                        let metadata = getOrCreateMetadata(info.id);
-                        if (metadata.propagation !== "self") {
-                          metadata.propagation = "in-tree";
-                        }
-                      }
-                    }
-                  }
-                  if (mod.code && injectExp.test(mod.code)) {
-                    for (const info of getParentModuleInfos(id, this)) {
-                      getOrCreateMetadata(info.id).propagation = "in-tree";
-                    }
-                  }
+            }
+            if (meta?.propagation === "self") {
+              for (const info of getParentModuleInfos(id, this)) {
+                let metadata = getOrCreateMetadata(info.id);
+                if (metadata.propagation !== "self") {
+                  metadata.propagation = "in-tree";
                 }
               }
             }
           }
-        };
+          if (mod.code && injectExp.test(mod.code)) {
+            for (const info of getParentModuleInfos(id, this)) {
+              getOrCreateMetadata(info.id).propagation = "in-tree";
+            }
+          }
+        }
       }
     }
   };

package/dist/vite-plugin-hmr-reload/index.js

@@ -1,3 +1,4 @@
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 function hmrReload() {
   return {
     name: "astro:hmr-reload",
@@ -5,7 +6,7 @@ function hmrReload() {
     hotUpdate: {
       order: "post",
       handler({ modules, server, timestamp }) {
-        if (this.environment.name !== "ssr") return;
+        if (this.environment.name !== ASTRO_VITE_ENVIRONMENT_NAMES.ssr) return;
         let hasSsrOnlyModules = false;
         const invalidatedModules = /* @__PURE__ */ new Set();
         for (const mod of modules) {

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

@@ -46,7 +46,6 @@ function markdown({ settings, logger }) {
         if (!processor) {
           processor = createMarkdownProcessor({
             image: settings.config.image,
-            experimentalHeadingIdCompat: settings.config.experimental.headingIdCompat,
             ...settings.config.markdown
           });
         }

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

@@ -0,0 +1,2 @@
+export declare const VIRTUAL_PAGE_MODULE_ID = "virtual:astro:page:";
+export declare const VIRTUAL_PAGE_RESOLVED_MODULE_ID: string;

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

@@ -0,0 +1,6 @@
+const VIRTUAL_PAGE_MODULE_ID = "virtual:astro:page:";
+const VIRTUAL_PAGE_RESOLVED_MODULE_ID = "\0" + VIRTUAL_PAGE_MODULE_ID;
+export {
+  VIRTUAL_PAGE_MODULE_ID,
+  VIRTUAL_PAGE_RESOLVED_MODULE_ID
+};

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

@@ -0,0 +1,2 @@
+export { pluginPage } from './page.js';
+export { pluginPages, VIRTUAL_PAGES_MODULE_ID } from './pages.js';

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

@@ -0,0 +1,7 @@
+import { pluginPage } from "./page.js";
+import { pluginPages, VIRTUAL_PAGES_MODULE_ID } from "./pages.js";
+export {
+  VIRTUAL_PAGES_MODULE_ID,
+  pluginPage,
+  pluginPages
+};

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

@@ -0,0 +1,7 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { RoutesList } from '../types/astro.js';
+interface PagePluginOptions {
+    routesList: RoutesList;
+}
+export declare function pluginPage({ routesList }: PagePluginOptions): VitePlugin;
+export {};

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

@@ -0,0 +1,48 @@
+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(id) {
+      if (id.startsWith(VIRTUAL_PAGE_MODULE_ID)) {
+        return VIRTUAL_PAGE_RESOLVED_MODULE_ID + id.slice(VIRTUAL_PAGE_MODULE_ID.length);
+      }
+    },
+    async load(id) {
+      if (id.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_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
+};