astro 5.16.5 → 6.0.0-alpha.1

package/dist/core/build/internal.js

@@ -1,8 +1,8 @@
 import { prependForwardSlash, removeFileExtension } from "../path.js";
 import { viteID } from "../util.js";
-import { makePageDataKey } from "./plugins/util.js";
 function createBuildInternals() {
   return {
+    clientInput: /* @__PURE__ */ new Set(),
     cssModuleToChunkIdMap: /* @__PURE__ */ new Map(),
     inlinedScripts: /* @__PURE__ */ new Map(),
     entrySpecifierToBundleMap: /* @__PURE__ */ new Map(),
@@ -16,8 +16,6 @@ function createBuildInternals() {
     discoveredScripts: /* @__PURE__ */ new Set(),
     staticFiles: /* @__PURE__ */ new Set(),
     componentMetadata: /* @__PURE__ */ new Map(),
-    entryPoints: /* @__PURE__ */ new Map(),
-    prerenderOnlyChunks: [],
     astroActionsEntryPoint: void 0,
     middlewareEntryPoint: void 0,
     clientChunksAndAssets: /* @__PURE__ */ new Set()
@@ -71,13 +69,6 @@ function* getPageDatasByClientOnlyID(internals, viteid) {
     }
   }
 }
-function getPageData(internals, route, component) {
-  let pageData = internals.pagesByKeys.get(makePageDataKey(route, component));
-  if (pageData) {
-    return pageData;
-  }
-  return void 0;
-}
 function getPageDataByViteID(internals, viteid) {
   if (internals.pagesByViteID.has(viteid)) {
     return internals.pagesByViteID.get(viteid);
@@ -92,46 +83,11 @@ function hasPrerenderedPages(internals) {
   }
   return false;
 }
-function cssOrder(a, b) {
-  let depthA = a.depth, depthB = b.depth, orderA = a.order, orderB = b.order;
-  if (orderA === -1 && orderB >= 0) {
-    return 1;
-  } else if (orderB === -1 && orderA >= 0) {
-    return -1;
-  } else if (orderA > orderB) {
-    return 1;
-  } else if (orderA < orderB) {
-    return -1;
-  } else {
-    if (depthA === -1) {
-      return -1;
-    } else if (depthB === -1) {
-      return 1;
-    } else {
-      return depthA > depthB ? -1 : 1;
-    }
-  }
-}
-function mergeInlineCss(acc, current) {
-  const lastAdded = acc.at(acc.length - 1);
-  const lastWasInline = lastAdded?.type === "inline";
-  const currentIsInline = current?.type === "inline";
-  if (lastWasInline && currentIsInline) {
-    const merged = { type: "inline", content: lastAdded.content + current.content };
-    acc[acc.length - 1] = merged;
-    return acc;
-  }
-  acc.push(current);
-  return acc;
-}
 export {
   createBuildInternals,
-  cssOrder,
-  getPageData,
   getPageDataByViteID,
   getPageDatasByClientOnlyID,
   hasPrerenderedPages,
-  mergeInlineCss,
   trackClientOnlyPageDatas,
   trackPageData,
   trackScriptPageDatas

package/dist/core/build/pipeline.d.ts

@@ -1,53 +1,42 @@
-import type { AstroSettings, ComponentInstance } from '../../types/astro.js';
+import type { ComponentInstance } from '../../types/astro.js';
 import type { RewritePayload } from '../../types/public/common.js';
 import type { RouteData, SSRResult } from '../../types/public/internal.js';
 import type { SSRManifest } from '../app/types.js';
 import type { TryRewriteResult } from '../base-pipeline.js';
-import { Pipeline } from '../render/index.js';
-import { type BuildInternals } from './internal.js';
-import type { PageBuildData, SinglePageBuiltModule, StaticBuildOptions } from './types.js';
+import { Pipeline } from '../base-pipeline.js';
+import type { BuildInternals } from './internal.js';
+import type { SinglePageBuiltModule, StaticBuildOptions } from './types.js';
 /**
  * The build pipeline is responsible to gather the files emitted by the SSR build and generate the pages by executing these files.
  */
 export declare class BuildPipeline extends Pipeline {
     #private;
-    readonly internals: BuildInternals;
     readonly manifest: SSRManifest;
-    readonly options: StaticBuildOptions;
-    readonly config: import("../../index.js").AstroConfig;
-    readonly settings: AstroSettings;
     readonly defaultRoutes: {
         instance: ComponentInstance;
         matchesComponent(filePath: URL): boolean;
         route: string;
         component: string;
     }[];
-    get outFolder(): URL;
+    internals: BuildInternals | undefined;
+    options: StaticBuildOptions | undefined;
+    getName(): string;
+    getSettings(): import("../../types/astro.js").AstroSettings;
+    getOptions(): StaticBuildOptions;
+    getInternals(): BuildInternals;
     private constructor();
     getRoutes(): RouteData[];
-    static create({ internals, manifest, options, }: Pick<BuildPipeline, 'internals' | 'manifest' | 'options'>): BuildPipeline;
-    /**
-     * The SSR build emits two important files:
-     * - dist/server/manifest.mjs
-     * - dist/renderers.mjs
-     *
-     * These two files, put together, will be used to generate the pages.
-     *
-     * ## Errors
-     *
-     * It will throw errors if the previous files can't be found in the file system.
-     *
-     * @param staticBuildOptions
-     */
-    static retrieveManifest(settings: AstroSettings, internals: BuildInternals): Promise<SSRManifest>;
+    static create({ manifest }: Pick<BuildPipeline, 'manifest'>): BuildPipeline;
+    setInternals(internals: BuildInternals): void;
+    setOptions(options: StaticBuildOptions): void;
     headElements(routeData: RouteData): Pick<SSRResult, 'scripts' | 'styles' | 'links'>;
     componentMetadata(): void;
     /**
      * It collects the routes to generate during the build.
      * It returns a map of page information and their relative entry point as a string.
      */
-    retrieveRoutesToGenerate(): Map<PageBuildData, string>;
+    retrieveRoutesToGenerate(): Set<RouteData>;
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    getModuleForRoute(route: RouteData): Promise<SinglePageBuiltModule>;
     tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
-    retrieveSsrEntry(route: RouteData, filePath: string): Promise<SinglePageBuiltModule>;
 }

package/dist/core/build/pipeline.js

@@ -1,18 +1,16 @@
-import { getServerOutputDirectory } from "../../prerender/utils.js";
+import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../vite-plugin-pages/const.js";
+import { getVirtualModulePageName } from "../../vite-plugin-pages/util.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
-import { routeIsFallback, routeIsRedirect } from "../redirects/helpers.js";
-import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
-import { Pipeline } from "../render/index.js";
+import { createConsoleLogger } from "../app/index.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/component.js";
+import { Pipeline } from "../base-pipeline.js";
 import { createAssetLink, createStylesheetElementSet } from "../render/ssr-element.js";
 import { createDefaultRoutes } from "../routing/default.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
 import { findRouteToRewrite } from "../routing/rewrite.js";
-import { getOutDirWithinCwd } from "./common.js";
-import { cssOrder, getPageData, mergeInlineCss } from "./internal.js";
-import { ASTRO_PAGE_MODULE_ID, ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
-import { getPagesFromVirtualModulePageName, getVirtualModulePageName } from "./plugins/util.js";
-import { i18nHasFallback } from "./util.js";
+import { cssOrder, mergeInlineCss, getPageData } from "./runtime.js";
 class BuildPipeline extends Pipeline {
-  constructor(internals, manifest, options, config = options.settings.config, settings = options.settings, defaultRoutes = createDefaultRoutes(manifest)) {
+  constructor(manifest, defaultRoutes = createDefaultRoutes(manifest)) {
     const resolveCache = /* @__PURE__ */ new Map();
     async function resolve(specifier) {
       if (resolveCache.has(specifier)) {
@@ -30,91 +28,57 @@ class BuildPipeline extends Pipeline {
       resolveCache.set(specifier, assetLink);
       return assetLink;
     }
-    const serverLike = settings.buildOutput === "server";
-    const streaming = serverLike;
-    super(
-      options.logger,
-      manifest,
-      options.runtimeMode,
-      manifest.renderers,
-      resolve,
-      serverLike,
-      streaming
-    );
-    this.internals = internals;
+    const logger = createConsoleLogger(manifest.logLevel);
+    super(logger, manifest, "production", manifest.renderers, resolve, manifest.serverLike);
     this.manifest = manifest;
-    this.options = options;
-    this.config = config;
-    this.settings = settings;
     this.defaultRoutes = defaultRoutes;
   }
-  #componentsInterner = /* @__PURE__ */ new WeakMap();
+  internals;
+  options;
+  getName() {
+    return "BuildPipeline";
+  }
   /**
    * This cache is needed to map a single `RouteData` to its file path.
    * @private
    */
   #routesByFilePath = /* @__PURE__ */ new WeakMap();
-  get outFolder() {
-    return this.settings.buildOutput === "server" ? this.settings.config.build.server : getOutDirWithinCwd(this.settings.config.outDir);
+  getSettings() {
+    if (!this.options) {
+      throw new Error("No options defined");
+    }
+    return this.options.settings;
+  }
+  getOptions() {
+    if (!this.options) {
+      throw new Error("No options defined");
+    }
+    return this.options;
+  }
+  getInternals() {
+    if (!this.internals) {
+      throw new Error("No internals defined");
+    }
+    return this.internals;
   }
   getRoutes() {
-    return this.options.routesList.routes;
+    return this.getOptions().routesList.routes;
   }
-  static create({
-    internals,
-    manifest,
-    options
-  }) {
-    return new BuildPipeline(internals, manifest, options);
+  static create({ manifest }) {
+    return new BuildPipeline(manifest);
   }
-  /**
-   * The SSR build emits two important files:
-   * - dist/server/manifest.mjs
-   * - dist/renderers.mjs
-   *
-   * These two files, put together, will be used to generate the pages.
-   *
-   * ## Errors
-   *
-   * It will throw errors if the previous files can't be found in the file system.
-   *
-   * @param staticBuildOptions
-   */
-  static async retrieveManifest(settings, internals) {
-    const baseDirectory = getServerOutputDirectory(settings);
-    const manifestEntryUrl = new URL(
-      `${internals.manifestFileName}?time=${Date.now()}`,
-      baseDirectory
-    );
-    const { manifest } = await import(manifestEntryUrl.toString());
-    if (!manifest) {
-      throw new Error(
-        "Astro couldn't find the emitted manifest. This is an internal error, please file an issue."
-      );
-    }
-    const renderersEntryUrl = new URL(`renderers.mjs?time=${Date.now()}`, baseDirectory);
-    const renderers = await import(renderersEntryUrl.toString());
-    const middleware = internals.middlewareEntryPoint ? async function() {
-      const mod = await import(internals.middlewareEntryPoint.toString());
-      return { onRequest: mod.onRequest };
-    } : manifest.middleware;
-    if (!renderers) {
-      throw new Error(
-        "Astro couldn't find the emitted renderers. This is an internal error, please file an issue."
-      );
-    }
-    return {
-      ...manifest,
-      renderers: renderers.renderers,
-      middleware
-    };
+  setInternals(internals) {
+    this.internals = internals;
+  }
+  setOptions(options) {
+    this.options = options;
   }
   headElements(routeData) {
     const {
-      internals,
-      manifest: { assetsPrefix, base },
-      settings
+      manifest: { assetsPrefix, base }
     } = this;
+    const settings = this.getSettings();
+    const internals = this.getInternals();
     const links = /* @__PURE__ */ new Set();
     const pageBuildData = getPageData(internals, routeData.route, routeData.component);
     const scripts = /* @__PURE__ */ new Set();
@@ -148,116 +112,88 @@ class BuildPipeline extends Pipeline {
    * It returns a map of page information and their relative entry point as a string.
    */
   retrieveRoutesToGenerate() {
-    const pages = /* @__PURE__ */ new Map();
-    for (const [virtualModulePageName, filePath] of this.internals.entrySpecifierToBundleMap) {
-      if (virtualModulePageName.includes(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
-        let pageDatas = [];
-        pageDatas.push(
-          ...getPagesFromVirtualModulePageName(
-            this.internals,
-            ASTRO_PAGE_RESOLVED_MODULE_ID,
-            virtualModulePageName
-          )
-        );
-        for (const pageData of pageDatas) {
-          pages.set(pageData, filePath);
-        }
+    const pages = /* @__PURE__ */ new Set();
+    const defaultRouteComponents = new Set(this.defaultRoutes.map((route) => route.component));
+    for (const { routeData } of this.manifest.routes) {
+      if (routeIsRedirect(routeData)) {
+        pages.add(routeData);
+        continue;
       }
-    }
-    for (const pageData of this.internals.pagesByKeys.values()) {
-      if (routeIsRedirect(pageData.route)) {
-        pages.set(pageData, pageData.component);
-      } else if (routeIsFallback(pageData.route) && (i18nHasFallback(this.config) || routeIsFallback(pageData.route) && pageData.route.route === "/")) {
-        const moduleSpecifier = getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component);
-        const filePath = this.internals.entrySpecifierToBundleMap.get(moduleSpecifier);
-        if (filePath) {
-          pages.set(pageData, filePath);
-        }
+      if (routeIsFallback(routeData) && i18nHasFallback(this.manifest)) {
+        pages.add(routeData);
+        continue;
+      }
+      if (defaultRouteComponents.has(routeData.component)) {
+        continue;
+      }
+      pages.add(routeData);
+      const moduleSpecifier = getVirtualModulePageName(
+        VIRTUAL_PAGE_RESOLVED_MODULE_ID,
+        routeData.component
+      );
+      const filePath = this.internals?.entrySpecifierToBundleMap.get(moduleSpecifier);
+      if (filePath) {
+        this.#routesByFilePath.set(routeData, filePath);
       }
-    }
-    for (const [buildData, filePath] of pages.entries()) {
-      this.#routesByFilePath.set(buildData.route, filePath);
     }
     return pages;
   }
   async getComponentByRoute(routeData) {
-    if (this.#componentsInterner.has(routeData)) {
-      const entry = this.#componentsInterner.get(routeData);
-      return await entry.page();
+    const module = await this.getModuleForRoute(routeData);
+    return module.page();
+  }
+  async getModuleForRoute(route) {
+    for (const defaultRoute of this.defaultRoutes) {
+      if (route.component === defaultRoute.component) {
+        return {
+          page: () => Promise.resolve(defaultRoute.instance)
+        };
+      }
     }
-    for (const route of this.defaultRoutes) {
-      if (route.component === routeData.component) {
-        return route.instance;
+    let routeToProcess = route;
+    if (routeIsRedirect(route)) {
+      if (route.redirectRoute) {
+        routeToProcess = route.redirectRoute;
+      } else {
+        return RedirectSinglePageBuiltModule;
       }
+    } else if (routeIsFallback(route)) {
+      routeToProcess = getFallbackRoute(route, this.manifest.routes);
     }
-    const filePath = this.#routesByFilePath.get(routeData);
-    const module = await this.retrieveSsrEntry(routeData, filePath);
-    return module.page();
+    if (this.manifest.pageMap) {
+      const importComponentInstance = this.manifest.pageMap.get(routeToProcess.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      return await importComponentInstance();
+    } else if (this.manifest.pageModule) {
+      return this.manifest.pageModule;
+    }
+    throw new Error(
+      "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+    );
   }
   async tryRewrite(payload, request) {
     const { routeData, pathname, newUrl } = findRouteToRewrite({
       payload,
       request,
-      routes: this.options.routesList.routes,
-      trailingSlash: this.config.trailingSlash,
-      buildFormat: this.config.build.format,
-      base: this.config.base,
-      outDir: this.serverLike ? this.manifest.buildClientDir : this.manifest.outDir
+      routes: this.manifest.routes.map((routeInfo) => routeInfo.routeData),
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat,
+      base: this.manifest.base,
+      outDir: this.manifest.serverLike ? this.manifest.buildClientDir : this.manifest.outDir
     });
     const componentInstance = await this.getComponentByRoute(routeData);
     return { routeData, componentInstance, newUrl, pathname };
   }
-  async retrieveSsrEntry(route, filePath) {
-    if (this.#componentsInterner.has(route)) {
-      return this.#componentsInterner.get(route);
-    }
-    let entry;
-    if (routeIsRedirect(route)) {
-      entry = await this.#getEntryForRedirectRoute(route, this.outFolder);
-    } else if (routeIsFallback(route)) {
-      entry = await this.#getEntryForFallbackRoute(route, this.outFolder);
-    } else {
-      const ssrEntryURLPage = createEntryURL(filePath, this.outFolder);
-      entry = await import(ssrEntryURLPage.toString());
-    }
-    this.#componentsInterner.set(route, entry);
-    return entry;
-  }
-  async #getEntryForFallbackRoute(route, outFolder) {
-    if (route.type !== "fallback") {
-      throw new Error(`Expected a redirect route.`);
-    }
-    if (route.redirectRoute) {
-      const filePath = getEntryFilePath(this.internals, route.redirectRoute);
-      if (filePath) {
-        const url = createEntryURL(filePath, outFolder);
-        const ssrEntryPage = await import(url.toString());
-        return ssrEntryPage;
-      }
-    }
-    return RedirectSinglePageBuiltModule;
-  }
-  async #getEntryForRedirectRoute(route, outFolder) {
-    if (route.type !== "redirect") {
-      throw new Error(`Expected a redirect route.`);
-    }
-    if (route.redirectRoute) {
-      const filePath = getEntryFilePath(this.internals, route.redirectRoute);
-      if (filePath) {
-        const url = createEntryURL(filePath, outFolder);
-        const ssrEntryPage = await import(url.toString());
-        return ssrEntryPage;
-      }
-    }
-    return RedirectSinglePageBuiltModule;
-  }
-}
-function createEntryURL(filePath, outFolder) {
-  return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
 }
-function getEntryFilePath(internals, pageData) {
-  const id = "\0" + getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component);
-  return internals.entrySpecifierToBundleMap.get(id);
+function i18nHasFallback(manifest) {
+  if (manifest.i18n && manifest.i18n.fallback) {
+    return Object.keys(manifest.i18n.fallback).length > 0;
+  }
+  return false;
 }
 export {
   BuildPipeline

package/dist/core/build/plugins/index.d.ts

@@ -1,2 +1,4 @@
-import type { AstroBuildPluginContainer } from '../plugin.js';
-export declare function registerAllPlugins({ internals, options, register }: AstroBuildPluginContainer): void;
+import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal.js';
+import type { StaticBuildOptions } from '../types.js';
+export declare function getAllBuildPlugins(internals: BuildInternals, options: StaticBuildOptions): Array<VitePlugin | VitePlugin[] | undefined>;

package/dist/core/build/plugins/index.js

@@ -1,35 +1,29 @@
-import { astroConfigBuildPlugin } from "../../../content/vite-plugin-content-assets.js";
+import { vitePluginActionsBuild } from "../../../actions/vite-plugin-actions.js";
 import { astroHeadBuildPlugin } from "../../../vite-plugin-head/index.js";
-import { pluginActions } from "./plugin-actions.js";
 import { pluginAnalyzer } from "./plugin-analyzer.js";
-import { pluginChunks } from "./plugin-chunks.js";
 import { pluginComponentEntry } from "./plugin-component-entry.js";
 import { pluginCSS } from "./plugin-css.js";
 import { pluginInternals } from "./plugin-internals.js";
-import { pluginManifest } from "./plugin-manifest.js";
 import { pluginMiddleware } from "./plugin-middleware.js";
-import { pluginPages } from "./plugin-pages.js";
 import { pluginPrerender } from "./plugin-prerender.js";
-import { pluginRenderers } from "./plugin-renderers.js";
 import { pluginScripts } from "./plugin-scripts.js";
 import { pluginSSR } from "./plugin-ssr.js";
-function registerAllPlugins({ internals, options, register }) {
-  register(pluginComponentEntry(internals));
-  register(pluginAnalyzer(internals));
-  register(pluginInternals(options, internals));
-  register(pluginManifest(options, internals));
-  register(pluginRenderers(options));
-  register(pluginMiddleware(options, internals));
-  register(pluginActions(options, internals));
-  register(pluginPages(options, internals));
-  register(pluginCSS(options, internals));
-  register(astroHeadBuildPlugin(internals));
-  register(pluginPrerender(options, internals));
-  register(astroConfigBuildPlugin(options, internals));
-  register(pluginScripts(internals));
-  register(pluginSSR(options, internals));
-  register(pluginChunks());
+import { pluginNoop } from "./plugin-noop.js";
+function getAllBuildPlugins(internals, options) {
+  return [
+    pluginComponentEntry(internals),
+    pluginAnalyzer(internals),
+    pluginInternals(options, internals),
+    pluginMiddleware(options, internals),
+    vitePluginActionsBuild(options, internals),
+    ...pluginCSS(options, internals),
+    astroHeadBuildPlugin(internals),
+    pluginPrerender(options, internals),
+    pluginScripts(internals),
+    ...pluginSSR(options, internals),
+    pluginNoop()
+  ].filter(Boolean);
 }
 export {
-  registerAllPlugins
+  getAllBuildPlugins
 };

package/dist/core/build/plugins/plugin-analyzer.d.ts

@@ -1,3 +1,3 @@
+import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
-import type { AstroBuildPlugin } from '../plugin.js';
-export declare function pluginAnalyzer(internals: BuildInternals): AstroBuildPlugin;
+export declare function pluginAnalyzer(internals: BuildInternals): VitePlugin;

package/dist/core/build/plugins/plugin-analyzer.js

@@ -4,9 +4,13 @@ import {
   trackClientOnlyPageDatas,
   trackScriptPageDatas
 } from "../internal.js";
-function vitePluginAnalyzer(internals) {
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function pluginAnalyzer(internals) {
   return {
     name: "@astro/rollup-plugin-astro-analyzer",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
     async generateBundle() {
       const ids = this.getModuleIds();
       for (const id of ids) {
@@ -61,18 +65,6 @@ function vitePluginAnalyzer(internals) {
     }
   };
 }
-function pluginAnalyzer(internals) {
-  return {
-    targets: ["server"],
-    hooks: {
-      "build:before": () => {
-        return {
-          vitePlugin: vitePluginAnalyzer(internals)
-        };
-      }
-    }
-  };
-}
 export {
   pluginAnalyzer
 };

package/dist/core/build/plugins/plugin-component-entry.d.ts

@@ -1,4 +1,9 @@
+import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
-import type { AstroBuildPlugin } from '../plugin.js';
+/**
+ * When adding hydrated or client:only components as Rollup inputs, sometimes we're not using all
+ * of the export names, e.g. `import { Counter } from './ManyComponents.jsx'`. This plugin proxies
+ * entries to re-export only the names the user is using.
+ */
+export declare function pluginComponentEntry(internals: BuildInternals): VitePlugin;
 export declare function normalizeEntryId(id: string): string;
-export declare function pluginComponentEntry(internals: BuildInternals): AstroBuildPlugin;

package/dist/core/build/plugins/plugin-component-entry.js

@@ -1,5 +1,6 @@
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 const astroEntryPrefix = "\0astro-entry:";
-function vitePluginComponentEntry(internals) {
+function pluginComponentEntry(internals) {
   const componentToExportNames = /* @__PURE__ */ new Map();
   mergeComponentExportNames(internals.discoveredHydratedComponents);
   mergeComponentExportNames(internals.discoveredClientOnlyComponents);
@@ -22,6 +23,9 @@ function vitePluginComponentEntry(internals) {
   return {
     name: "@astro/plugin-component-entry",
     enforce: "pre",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+    },
     config(config) {
       const rollupInput = config.build?.rollupOptions?.input;
       if (Array.isArray(rollupInput)) {
@@ -55,18 +59,6 @@ function vitePluginComponentEntry(internals) {
 function normalizeEntryId(id) {
   return id.startsWith(astroEntryPrefix) ? id.slice(astroEntryPrefix.length) : id;
 }
-function pluginComponentEntry(internals) {
-  return {
-    targets: ["client"],
-    hooks: {
-      "build:before": () => {
-        return {
-          vitePlugin: vitePluginComponentEntry(internals)
-        };
-      }
-    }
-  };
-}
 export {
   normalizeEntryId,
   pluginComponentEntry

package/dist/core/build/plugins/plugin-css.d.ts

@@ -1,5 +1,5 @@
+import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
-import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
 /***** ASTRO PLUGIN *****/
-export declare function pluginCSS(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
+export declare function pluginCSS(options: StaticBuildOptions, internals: BuildInternals): VitePlugin[];