astro 4.3.7 → 4.4.1

package/dist/core/build/generate.js

@@ -16,29 +16,20 @@ import {
   removeLeadingForwardSlash,
   removeTrailingForwardSlash
 } from "../../core/path.js";
-import { createI18nMiddleware, i18nPipelineHook } from "../../i18n/middleware.js";
 import { runHookBuildGenerated } from "../../integrations/index.js";
 import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js";
-import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-import { sequence } from "../middleware/index.js";
 import { routeIsFallback } from "../redirects/helpers.js";
 import {
   RedirectSinglePageBuiltModule,
   getRedirectLocationOrThrow,
   routeIsRedirect
 } from "../redirects/index.js";
-import { createRenderContext } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
-import {
-  createAssetLink,
-  createModuleScriptsSet,
-  createStylesheetElementSet
-} from "../render/ssr-element.js";
 import { createRequest } from "../request.js";
 import { matchRoute } from "../routing/match.js";
 import { getOutputFilename } from "../util.js";
-import { BuildPipeline } from "./buildPipeline.js";
+import { BuildPipeline } from "./pipeline.js";
 import { getOutDirWithinCwd, getOutFile, getOutFolder } from "./common.js";
 import {
   cssOrder,
@@ -48,6 +39,7 @@ import {
 } from "./internal.js";
 import { getTimeStat, shouldAppendForwardSlash } from "./util.js";
 import { NoPrerenderedRoutesWithDomains } from "../errors/errors-data.js";
+import { RenderContext } from "../render-context.js";
 function createEntryURL(filePath, outFolder) {
   return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
 }
@@ -95,14 +87,14 @@ function chunkIsPage(settings, output, internals) {
   }
   return false;
 }
-async function generatePages(opts, internals) {
+async function generatePages(options, internals) {
   const generatePagesTimer = performance.now();
-  const ssr = isServerLikeOutput(opts.settings.config);
+  const ssr = isServerLikeOutput(options.settings.config);
   let manifest;
   if (ssr) {
-    manifest = await BuildPipeline.retrieveManifest(opts, internals);
+    manifest = await BuildPipeline.retrieveManifest(options, internals);
   } else {
-    const baseDirectory = getOutputDirectory(opts.settings.config);
+    const baseDirectory = getOutputDirectory(options.settings.config);
     const renderersEntryUrl = new URL("renderers.mjs", baseDirectory);
     const renderers = await import(renderersEntryUrl.toString());
     let middleware = (_, next) => next();
@@ -113,15 +105,15 @@ async function generatePages(opts, internals) {
     } catch {
     }
     manifest = createBuildManifest(
-      opts.settings,
+      options.settings,
       internals,
       renderers.renderers,
       middleware
     );
   }
-  const pipeline = new BuildPipeline(opts, internals, manifest);
-  const outFolder = ssr ? opts.settings.config.build.server : getOutDirWithinCwd(opts.settings.config.outDir);
-  const logger = pipeline.getLogger();
+  const pipeline = BuildPipeline.create({ internals, manifest, options });
+  const { config, logger } = pipeline;
+  const outFolder = ssr ? options.settings.config.build.server : getOutDirWithinCwd(options.settings.config.outDir);
   if (ssr && !hasPrerenderedPages(internals)) {
     delete globalThis?.astroAsset?.addStaticImage;
     return;
@@ -131,7 +123,6 @@ async function generatePages(opts, internals) {
 ${bgGreen(black(` ${verb} static routes `))}`);
   const builtPaths = /* @__PURE__ */ new Set();
   const pagesToGenerate = pipeline.retrieveRoutesToGenerate();
-  const config = pipeline.getConfig();
   if (ssr) {
     for (const [pageData, filePath] of pagesToGenerate) {
       if (pageData.route.prerender) {
@@ -143,7 +134,7 @@ ${bgGreen(black(` ${verb} static routes `))}`);
         }
         const ssrEntryURLPage = createEntryURL(filePath, outFolder);
         const ssrEntryPage = await import(ssrEntryURLPage.toString());
-        if (opts.settings.adapter?.adapterFeatures?.functionPerRoute) {
+        if (options.settings.adapter?.adapterFeatures?.functionPerRoute) {
           const ssrEntry = ssrEntryPage?.pageModule;
           if (ssrEntry) {
             await generatePage(pageData, ssrEntry, builtPaths, pipeline);
@@ -183,11 +174,11 @@ ${bgGreen(black(` ${verb} static routes `))}`);
     logger.info("SKIP_FORMAT", `${bgGreen(black(` generating optimized images `))}`);
     const totalCount = Array.from(staticImageList.values()).map((x) => x.transforms.size).reduce((a, b) => a + b, 0);
     const cpuCount = os.cpus().length;
-    const assetsCreationEnvironment = await prepareAssetsGenerationEnv(pipeline, totalCount);
+    const assetsCreationpipeline = await prepareAssetsGenerationEnv(pipeline, totalCount);
     const queue = new PQueue({ concurrency: Math.max(cpuCount, 1) });
     const assetsTimer = performance.now();
     for (const [originalPath, transforms] of staticImageList) {
-      await generateImagesForPath(originalPath, transforms, assetsCreationEnvironment, queue);
+      await generateImagesForPath(originalPath, transforms, assetsCreationpipeline, queue);
     }
     await queue.onIdle();
     const assetsTimeEnd = performance.now();
@@ -195,33 +186,15 @@ ${bgGreen(black(` ${verb} static routes `))}`);
 `));
     delete globalThis?.astroAsset?.addStaticImage;
   }
-  await runHookBuildGenerated({
-    config: opts.settings.config,
-    logger: pipeline.getLogger()
-  });
+  await runHookBuildGenerated({ config, logger });
 }
 async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
-  const logger = pipeline.getLogger();
-  const config = pipeline.getConfig();
-  const manifest = pipeline.getManifest();
+  const { config, internals, logger } = pipeline;
   const pageModulePromise = ssrEntry.page;
-  const onRequest = manifest.middleware;
-  const pageInfo = getPageDataByComponent(pipeline.getInternals(), pageData.route.component);
+  const pageInfo = getPageDataByComponent(internals, pageData.route.component);
   const styles = pageData.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
   const linkIds = [];
   const scripts = pageInfo?.hoistedScript ?? null;
-  const i18nMiddleware = createI18nMiddleware(
-    manifest.i18n,
-    manifest.base,
-    manifest.trailingSlash,
-    manifest.buildFormat
-  );
-  if (config.i18n && i18nMiddleware) {
-    pipeline.setMiddlewareFunction(sequence(i18nMiddleware, onRequest));
-    pipeline.onBeforeRenderRoute(i18nPipelineHook);
-  } else {
-    pipeline.setMiddlewareFunction(onRequest);
-  }
   if (!pageModulePromise) {
     throw new Error(
       `Unable to find the module for ${pageData.component}. This is unexpected and likely a bug in Astro, please report.`
@@ -243,8 +216,8 @@ async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
     let prevTimeEnd = timeStart;
     for (let i = 0; i < paths.length; i++) {
       const path = paths[i];
-      pipeline.getEnvironment().logger.debug("build", `Generating: ${path}`);
-      const filePath = getOutputFilename(pipeline.getConfig(), path, pageData.route.type);
+      pipeline.logger.debug("build", `Generating: ${path}`);
+      const filePath = getOutputFilename(config, path, pageData.route.type);
       const lineIcon = i === paths.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
       logger.info(null, `  ${blue(lineIcon)} ${dim(filePath)}`, false);
       await generatePath(path, pipeline, generationOptions, route);
@@ -263,8 +236,7 @@ function* eachRouteInRouteData(data) {
   }
 }
 async function getPathsForRoute(route, mod, pipeline, builtPaths) {
-  const opts = pipeline.getStaticBuildOptions();
-  const logger = pipeline.getLogger();
+  const { logger, options, routeCache, serverLike } = pipeline;
   let paths = [];
   if (route.pathname) {
     paths.push(route.pathname);
@@ -279,9 +251,9 @@ async function getPathsForRoute(route, mod, pipeline, builtPaths) {
     const staticPaths = await callGetStaticPaths({
       mod,
       route,
-      routeCache: opts.routeCache,
+      routeCache,
       logger,
-      ssr: isServerLikeOutput(opts.settings.config)
+      ssr: serverLike
     }).catch((err) => {
       logger.debug("build", `\u251C\u2500\u2500 ${bold(red("\u2717"))} ${route.component}`);
       throw err;
@@ -304,7 +276,7 @@ async function getPathsForRoute(route, mod, pipeline, builtPaths) {
       if (!builtPaths.has(removeTrailingForwardSlash(staticPath))) {
         return true;
       }
-      const matchedRoute = matchRoute(staticPath, opts.manifest);
+      const matchedRoute = matchRoute(staticPath, options.manifest);
       return matchedRoute === route;
     });
     for (const staticPath of paths) {
@@ -358,73 +330,31 @@ function getUrlForPath(pathname, base, origin, format, trailingSlash, routeType)
   return url;
 }
 async function generatePath(pathname, pipeline, gopts, route) {
-  const { mod, scripts: hoistedScripts, styles: _styles } = gopts;
-  const manifest = pipeline.getManifest();
-  const logger = pipeline.getLogger();
+  const { mod } = gopts;
+  const { config, logger, options, serverLike } = pipeline;
   logger.debug("build", `Generating: ${pathname}`);
-  const links = /* @__PURE__ */ new Set();
-  const scripts = createModuleScriptsSet(
-    hoistedScripts ? [hoistedScripts] : [],
-    manifest.base,
-    manifest.assetsPrefix
-  );
-  const styles = createStylesheetElementSet(_styles, manifest.base, manifest.assetsPrefix);
-  if (pipeline.getSettings().scripts.some((script) => script.stage === "page")) {
-    const hashedFilePath = pipeline.getInternals().entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
-    if (typeof hashedFilePath !== "string") {
-      throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
-    }
-    const src = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
-    scripts.add({
-      props: { type: "module", src },
-      children: ""
-    });
-  }
-  for (const script of pipeline.getSettings().scripts) {
-    if (script.stage === "head-inline") {
-      scripts.add({
-        props: {},
-        children: script.content
-      });
-    }
-  }
   if (route.type === "page") {
-    addPageName(pathname, pipeline.getStaticBuildOptions());
+    addPageName(pathname, options);
   }
-  const ssr = isServerLikeOutput(pipeline.getConfig());
   const url = getUrlForPath(
     pathname,
-    pipeline.getConfig().base,
-    pipeline.getStaticBuildOptions().origin,
-    pipeline.getConfig().build.format,
-    pipeline.getConfig().trailingSlash,
+    config.base,
+    options.origin,
+    config.build.format,
+    config.trailingSlash,
     route.type
   );
   const request = createRequest({
     url,
     headers: new Headers(),
-    logger: pipeline.getLogger(),
-    ssr
-  });
-  const i18n = pipeline.getConfig().i18n;
-  const renderContext = await createRenderContext({
-    pathname,
-    request,
-    componentMetadata: manifest.componentMetadata,
-    scripts,
-    styles,
-    links,
-    route,
-    env: pipeline.getEnvironment(),
-    mod,
-    locales: i18n?.locales,
-    routing: i18n?.routing,
-    defaultLocale: i18n?.defaultLocale
+    logger,
+    ssr: serverLike
   });
+  const renderContext = RenderContext.create({ pipeline, pathname, request, routeData: route });
   let body;
   let response;
   try {
-    response = await pipeline.renderRoute(renderContext, mod);
+    response = await renderContext.render(mod);
   } catch (err) {
     if (!AstroError.is(err) && !err.id && typeof err === "object") {
       err.id = route.component;
@@ -432,13 +362,13 @@ async function generatePath(pathname, pipeline, gopts, route) {
     throw err;
   }
   if (response.status >= 300 && response.status < 400) {
-    if (!pipeline.getConfig().build.redirects) {
+    if (!config.build.redirects) {
       return;
     }
     const locationSite = getRedirectLocationOrThrow(response.headers);
-    const siteURL = pipeline.getConfig().site;
+    const siteURL = config.site;
     const location = siteURL ? new URL(locationSite, siteURL) : locationSite;
-    const fromPath = new URL(renderContext.request.url).pathname;
+    const fromPath = new URL(request.url).pathname;
     const delay = response.status === 302 ? 2 : 0;
     body = `<!doctype html>
 <title>Redirecting to: ${location}</title>
@@ -448,7 +378,7 @@ async function generatePath(pathname, pipeline, gopts, route) {
 <body>
 	<a href="${location}">Redirecting from <code>${fromPath}</code> to <code>${location}</code></a>
 </body>`;
-    if (pipeline.getConfig().compressHTML === true) {
+    if (config.compressHTML === true) {
       body = body.replaceAll("\n", "");
     }
     if (route.type !== "redirect") {
@@ -459,8 +389,8 @@ async function generatePath(pathname, pipeline, gopts, route) {
       return;
     body = Buffer.from(await response.arrayBuffer());
   }
-  const outFolder = getOutFolder(pipeline.getConfig(), pathname, route);
-  const outFile = getOutFile(pipeline.getConfig(), outFolder, pathname, route);
+  const outFolder = getOutFolder(config, pathname, route);
+  const outFile = getOutFile(config, outFolder, pathname, route);
   route.distURL = outFile;
   await fs.promises.mkdir(outFolder, { recursive: true });
   await fs.promises.writeFile(outFile, body);

package/dist/core/build/index.js

@@ -18,7 +18,6 @@ import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
 import { levels, timerMessage } from "../logger/core.js";
 import { apply as applyPolyfill } from "../polyfill.js";
-import { RouteCache } from "../render/route-cache.js";
 import { createRouteManifest } from "../routing/index.js";
 import { collectPagesData } from "./page-data.js";
 import { staticBuild, viteBuild } from "./static-build.js";
@@ -51,7 +50,6 @@ class AstroBuilder {
   logger;
   mode = "production";
   origin;
-  routeCache;
   manifest;
   timer;
   teardownCompiler;
@@ -62,7 +60,6 @@ class AstroBuilder {
     this.settings = settings;
     this.logger = options.logger;
     this.teardownCompiler = options.teardownCompiler ?? true;
-    this.routeCache = new RouteCache(this.logger);
     this.origin = settings.config.site ? new URL(settings.config.site).origin : `http://localhost:${settings.config.server.port}`;
     this.manifest = { routes: [] };
     this.timer = {};
@@ -130,7 +127,6 @@ class AstroBuilder {
       mode: this.mode,
       origin: this.origin,
       pageNames,
-      routeCache: this.routeCache,
       teardownCompiler: this.teardownCompiler,
       viteConfig
     };

package/dist/core/build/{buildPipeline.d.ts → pipeline.d.ts}

@@ -1,21 +1,19 @@
-import type { AstroConfig, AstroSettings } from '../../@types/astro.js';
+import type { RouteData, SSRResult } from '../../@types/astro.js';
 import type { SSRManifest } from '../app/types.js';
-import type { Logger } from '../logger/core.js';
-import { Pipeline } from '../pipeline.js';
-import type { BuildInternals } from './internal.js';
+import { Pipeline } from '../render/index.js';
+import { type BuildInternals } from './internal.js';
 import type { PageBuildData, StaticBuildOptions } from './types.js';
 /**
- * This pipeline is responsible to gather the files emitted by the SSR build and generate the pages by executing these files.
+ * 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;
-    constructor(staticBuildOptions: StaticBuildOptions, internals: BuildInternals, manifest: SSRManifest);
-    getInternals(): Readonly<BuildInternals>;
-    getSettings(): Readonly<AstroSettings>;
-    getStaticBuildOptions(): Readonly<StaticBuildOptions>;
-    getConfig(): AstroConfig;
-    getManifest(): SSRManifest;
-    getLogger(): Logger;
+    readonly internals: BuildInternals;
+    readonly manifest: SSRManifest;
+    readonly options: StaticBuildOptions;
+    readonly config: import("../../@types/astro.js").AstroConfig;
+    readonly settings: import("../../@types/astro.js").AstroSettings;
+    private constructor();
+    static create({ internals, manifest, options, }: Pick<BuildPipeline, 'internals' | 'manifest' | 'options'>): BuildPipeline;
     /**
      * The SSR build emits two important files:
      * - dist/server/manifest.mjs
@@ -30,6 +28,8 @@ export declare class BuildPipeline extends Pipeline {
      * @param staticBuildOptions
      */
     static retrieveManifest(staticBuildOptions: StaticBuildOptions, internals: BuildInternals): Promise<SSRManifest>;
+    headElements(routeData: RouteData): Pick<SSRResult, 'scripts' | 'styles' | 'links'>;
+    componentMetadata(): void;
     /**
      * It collects the routes to generate during the build.
      *

package/dist/core/build/pipeline.js

@@ -0,0 +1,180 @@
+import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js";
+import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { routeIsFallback, routeIsRedirect } from "../redirects/helpers.js";
+import { Pipeline } from "../render/index.js";
+import {
+  createAssetLink,
+  createModuleScriptsSet,
+  createStylesheetElementSet
+} from "../render/ssr-element.js";
+import {
+  getPageDataByComponent,
+  cssOrder,
+  mergeInlineCss
+} from "./internal.js";
+import {
+  ASTRO_PAGE_RESOLVED_MODULE_ID,
+  getVirtualModulePageNameFromPath
+} from "./plugins/plugin-pages.js";
+import { RESOLVED_SPLIT_MODULE_ID } from "./plugins/plugin-ssr.js";
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
+import { i18nHasFallback } from "./util.js";
+class BuildPipeline extends Pipeline {
+  constructor(internals, manifest, options, config = options.settings.config, settings = options.settings) {
+    const resolveCache = /* @__PURE__ */ new Map();
+    async function resolve(specifier) {
+      if (resolveCache.has(specifier)) {
+        return resolveCache.get(specifier);
+      }
+      const hashedFilePath = manifest.entryModules[specifier];
+      if (typeof hashedFilePath !== "string" || hashedFilePath === "") {
+        if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+          resolveCache.set(specifier, "");
+          return "";
+        }
+        throw new Error(`Cannot find the built path for ${specifier}`);
+      }
+      const assetLink = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+      resolveCache.set(specifier, assetLink);
+      return assetLink;
+    }
+    const serverLike = isServerLikeOutput(config);
+    const streaming = true;
+    super(
+      options.logger,
+      manifest,
+      options.mode,
+      manifest.renderers,
+      resolve,
+      serverLike,
+      streaming
+    );
+    this.internals = internals;
+    this.manifest = manifest;
+    this.options = options;
+    this.config = config;
+    this.settings = settings;
+  }
+  static create({
+    internals,
+    manifest,
+    options
+  }) {
+    return new BuildPipeline(internals, manifest, options);
+  }
+  /**
+   * 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(staticBuildOptions, internals) {
+    const config = staticBuildOptions.settings.config;
+    const baseDirectory = getOutputDirectory(config);
+    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 = await import(new URL("middleware.mjs", baseDirectory).toString()).then((mod) => mod.onRequest).catch(() => 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
+    };
+  }
+  headElements(routeData) {
+    const {
+      internals,
+      manifest: { assetsPrefix, base },
+      settings
+    } = this;
+    const links = /* @__PURE__ */ new Set();
+    const pageBuildData = getPageDataByComponent(internals, routeData.component);
+    const scripts = createModuleScriptsSet(
+      pageBuildData?.hoistedScript ? [pageBuildData.hoistedScript] : [],
+      base,
+      assetsPrefix
+    );
+    const sortedCssAssets = pageBuildData?.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
+    const styles = createStylesheetElementSet(sortedCssAssets ?? [], base, assetsPrefix);
+    if (settings.scripts.some((script) => script.stage === "page")) {
+      const hashedFilePath = internals.entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
+      if (typeof hashedFilePath !== "string") {
+        throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
+      }
+      const src = createAssetLink(hashedFilePath, base, assetsPrefix);
+      scripts.add({
+        props: { type: "module", src },
+        children: ""
+      });
+    }
+    for (const script of settings.scripts) {
+      if (script.stage === "head-inline") {
+        scripts.add({
+          props: {},
+          children: script.content
+        });
+      }
+    }
+    return { scripts, styles, links };
+  }
+  componentMetadata() {
+  }
+  /**
+   * 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() {
+    const pages = /* @__PURE__ */ new Map();
+    for (const [entrypoint, filePath] of this.internals.entrySpecifierToBundleMap) {
+      if (entrypoint.includes(ASTRO_PAGE_RESOLVED_MODULE_ID) || entrypoint.includes(RESOLVED_SPLIT_MODULE_ID)) {
+        const [, pageName] = entrypoint.split(":");
+        const pageData = this.internals.pagesByComponent.get(
+          `${pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".")}`
+        );
+        if (!pageData) {
+          throw new Error(
+            "Build failed. Astro couldn't find the emitted page from " + pageName + " pattern"
+          );
+        }
+        pages.set(pageData, filePath);
+      }
+    }
+    for (const [path, pageData] of this.internals.pagesByComponent.entries()) {
+      if (routeIsRedirect(pageData.route)) {
+        pages.set(pageData, path);
+      } else if (routeIsFallback(pageData.route) && (i18nHasFallback(this.config) || routeIsFallback(pageData.route) && pageData.route.route === "/")) {
+        const moduleSpecifier = getVirtualModulePageNameFromPath(path);
+        const filePath = this.internals.entrySpecifierToBundleMap.get(moduleSpecifier);
+        if (filePath) {
+          pages.set(pageData, filePath);
+        }
+      }
+    }
+    return pages;
+  }
+}
+export {
+  BuildPipeline
+};

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

@@ -1,4 +1,3 @@
-import {} from "vite";
 import { isBuildableCSSRequest } from "../../../vite-plugin-astro-server/util.js";
 import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
 import * as assetName from "../css-asset-name.js";
@@ -10,7 +9,7 @@ import {
   getPageDatasByHoistedScriptId,
   isHoistedScript
 } from "../internal.js";
-import { extendManualChunks } from "./util.js";
+import { extendManualChunks, shouldInlineAsset } from "./util.js";
 function pluginCSS(options, internals) {
   return {
     targets: ["client", "server"],
@@ -146,17 +145,19 @@ function rollupPluginAstroBuildCSS(options) {
       }
     }
   };
+  let assetsInlineLimit;
   const inlineStylesheetsPlugin = {
     name: "astro:rollup-plugin-inline-stylesheets",
     enforce: "post",
+    configResolved(config) {
+      assetsInlineLimit = config.build.assetsInlineLimit;
+    },
     async generateBundle(_outputOptions, bundle) {
       const inlineConfig = settings.config.build.inlineStylesheets;
-      const { assetsInlineLimit = 4096 } = settings.config.vite?.build ?? {};
       Object.entries(bundle).forEach(([id, stylesheet]) => {
         if (stylesheet.type !== "asset" || stylesheet.name?.endsWith(".css") !== true || typeof stylesheet.source !== "string")
           return;
-        const assetSize = new TextEncoder().encode(stylesheet.source).byteLength;
-        const toBeInlined = inlineConfig === "always" ? true : inlineConfig === "never" ? false : assetSize <= assetsInlineLimit;
+        const toBeInlined = inlineConfig === "always" ? true : inlineConfig === "never" ? false : shouldInlineAsset(stylesheet.source, stylesheet.fileName, assetsInlineLimit);
         const sheet = toBeInlined ? { type: "inline", content: stylesheet.source } : { type: "external", src: stylesheet.fileName };
         const pages = Array.from(eachPageData(internals));
         let sheetAddedToPage = false;

package/dist/core/build/plugins/plugin-hoisted-scripts.js

@@ -1,11 +1,16 @@
 import { viteID } from "../../util.js";
 import { getPageDataByViteID } from "../internal.js";
+import { shouldInlineAsset } from "./util.js";
 function virtualHoistedEntry(id) {
   return id.startsWith("/astro/hoisted.js?q=");
 }
 function vitePluginHoistedScripts(settings, internals) {
+  let assetsInlineLimit;
   return {
     name: "@astro/rollup-plugin-astro-hoisted-scripts",
+    configResolved(config) {
+      assetsInlineLimit = config.build.assetsInlineLimit;
+    },
     resolveId(id) {
       if (virtualHoistedEntry(id)) {
         return id;
@@ -28,10 +33,6 @@ function vitePluginHoistedScripts(settings, internals) {
       return void 0;
     },
     async generateBundle(_options, bundle) {
-      let assetInlineLimit = 4096;
-      if (settings.config.vite?.build && settings.config.vite.build.assetsInlineLimit !== void 0) {
-        assetInlineLimit = settings.config.vite?.build.assetsInlineLimit;
-      }
       const considerInlining = /* @__PURE__ */ new Map();
       const importedByOtherScripts = /* @__PURE__ */ new Set();
       Object.entries(bundle).forEach(([id, output]) => {
@@ -41,7 +42,7 @@ function vitePluginHoistedScripts(settings, internals) {
         }
       });
       for (const [id, output] of considerInlining.entries()) {
-        const canBeInlined = importedByOtherScripts.has(output.fileName) === false && output.imports.length === 0 && output.dynamicImports.length === 0 && Buffer.byteLength(output.code) <= assetInlineLimit;
+        const canBeInlined = importedByOtherScripts.has(output.fileName) === false && output.imports.length === 0 && output.dynamicImports.length === 0 && shouldInlineAsset(output.code, output.fileName, assetsInlineLimit);
         let removeFromBundle = false;
         const facadeId = output.facadeModuleId;
         const pages = internals.hoistedScriptIdToPagesMap.get(facadeId);

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

@@ -1,4 +1,4 @@
-import type { Rollup, Plugin as VitePlugin } from 'vite';
+import type { BuildOptions, Rollup, Plugin as VitePlugin } from 'vite';
 type OutputOptionsHook = Extract<VitePlugin['outputOptions'], Function>;
 type OutputOptions = Parameters<OutputOptionsHook>[0];
 type ExtendManualChunksHooks = {
@@ -21,4 +21,5 @@ export declare function getVirtualModulePageNameFromPath(virtualModulePrefix: st
  * @param id
  */
 export declare function getPathFromVirtualModulePageName(virtualModulePrefix: string, id: string): string;
+export declare function shouldInlineAsset(assetContent: string, assetPath: string, assetsInlineLimit: NonNullable<BuildOptions['assetsInlineLimit']>): boolean;
 export {};

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

@@ -37,9 +37,20 @@ function getPathFromVirtualModulePageName(virtualModulePrefix, id) {
   const pageName = id.slice(virtualModulePrefix.length);
   return pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
 }
+function shouldInlineAsset(assetContent, assetPath, assetsInlineLimit) {
+  if (typeof assetsInlineLimit === "number") {
+    return Buffer.byteLength(assetContent) < assetsInlineLimit;
+  }
+  const result = assetsInlineLimit(assetPath, Buffer.from(assetContent));
+  if (result != null) {
+    return result;
+  }
+  return Buffer.byteLength(assetContent) < 4096;
+}
 export {
   ASTRO_PAGE_EXTENSION_POST_PATTERN,
   extendManualChunks,
   getPathFromVirtualModulePageName,
-  getVirtualModulePageNameFromPath
+  getVirtualModulePageNameFromPath,
+  shouldInlineAsset
 };