astro 4.7.1 → 4.8.0

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

@@ -1,25 +1,21 @@
 import { routeIsRedirect } from "../../redirects/index.js";
 import { addRollupInput } from "../add-rollup-input.js";
-import { eachPageFromAllPages } from "../internal.js";
+import {} from "../internal.js";
 import { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
-import { getPathFromVirtualModulePageName, getVirtualModulePageNameFromPath } from "./util.js";
+import { getPagesFromVirtualModulePageName, getVirtualModulePageName } from "./util.js";
 const ASTRO_PAGE_MODULE_ID = "@astro-page:";
 const ASTRO_PAGE_RESOLVED_MODULE_ID = "\0" + ASTRO_PAGE_MODULE_ID;
-function getVirtualModulePageIdFromPath(path) {
-  const name = getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path);
-  return "\0" + name;
-}
 function vitePluginPages(opts, internals) {
   return {
     name: "@astro/plugin-build-pages",
     options(options) {
       if (opts.settings.config.output === "static") {
         const inputs = /* @__PURE__ */ new Set();
-        for (const [path, pageData] of eachPageFromAllPages(opts.allPages)) {
+        for (const pageData of Object.values(opts.allPages)) {
           if (routeIsRedirect(pageData.route)) {
             continue;
           }
-          inputs.add(getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path));
+          inputs.add(getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component));
         }
         return addRollupInput(options, Array.from(inputs));
       }
@@ -33,9 +29,12 @@ function vitePluginPages(opts, internals) {
       if (id.startsWith(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
         const imports = [];
         const exports = [];
-        const pageName = getPathFromVirtualModulePageName(ASTRO_PAGE_RESOLVED_MODULE_ID, id);
-        const pageData = internals.pagesByComponent.get(pageName);
-        if (pageData) {
+        const pageDatas = getPagesFromVirtualModulePageName(
+          internals,
+          ASTRO_PAGE_RESOLVED_MODULE_ID,
+          id
+        );
+        for (const pageData of pageDatas) {
           const resolvedPage = await this.resolve(pageData.moduleSpecifier);
           if (resolvedPage) {
             imports.push(`const page = () => import(${JSON.stringify(pageData.moduleSpecifier)});`);
@@ -64,6 +63,5 @@ function pluginPages(opts, internals) {
 export {
   ASTRO_PAGE_MODULE_ID,
   ASTRO_PAGE_RESOLVED_MODULE_ID,
-  getVirtualModulePageIdFromPath,
   pluginPages
 };

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

@@ -1,15 +1,14 @@
 import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { isFunctionPerRouteEnabled } from "../../../integrations/hooks.js";
-import { isServerLikeOutput } from "../../../prerender/utils.js";
 import { routeIsRedirect } from "../../redirects/index.js";
+import { isServerLikeOutput } from "../../util.js";
 import { addRollupInput } from "../add-rollup-input.js";
-import { eachPageFromAllPages } from "../internal.js";
 import { SSR_MANIFEST_VIRTUAL_MODULE_ID } from "./plugin-manifest.js";
 import { MIDDLEWARE_MODULE_ID } from "./plugin-middleware.js";
 import { ASTRO_PAGE_MODULE_ID } from "./plugin-pages.js";
 import { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
-import { getPathFromVirtualModulePageName, getVirtualModulePageNameFromPath } from "./util.js";
+import { getComponentFromVirtualModulePageName, getVirtualModulePageName } from "./util.js";
 const SSR_VIRTUAL_MODULE_ID = "@astrojs-ssr-virtual-entry";
 const RESOLVED_SSR_VIRTUAL_MODULE_ID = "\0" + SSR_VIRTUAL_MODULE_ID;
 function vitePluginSSR(internals, adapter, options) {
@@ -32,16 +31,19 @@ function vitePluginSSR(internals, adapter, options) {
         const exports = [];
         let i = 0;
         const pageMap = [];
-        for (const [path, pageData] of eachPageFromAllPages(allPages)) {
+        for (const pageData of Object.values(allPages)) {
           if (routeIsRedirect(pageData.route)) {
             continue;
           }
-          const virtualModuleName = getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path);
+          const virtualModuleName = getVirtualModulePageName(
+            ASTRO_PAGE_MODULE_ID,
+            pageData.component
+          );
           let module = await this.resolve(virtualModuleName);
           if (module) {
             const variable = `_page${i}`;
             imports.push(`const ${variable} = () => import("${virtualModuleName}");`);
-            const pageData2 = internals.pagesByComponent.get(path);
+            const pageData2 = internals.pagesByKeys.get(pageData.key);
             if (pageData2) {
               pageMap.push(`[${JSON.stringify(pageData2.component)}, ${variable}]`);
             }
@@ -115,11 +117,11 @@ function vitePluginSSRSplit(internals, adapter, options) {
     options(opts) {
       if (functionPerRouteEnabled) {
         const inputs = /* @__PURE__ */ new Set();
-        for (const [path, pageData] of eachPageFromAllPages(options.allPages)) {
+        for (const pageData of Object.values(options.allPages)) {
           if (routeIsRedirect(pageData.route)) {
             continue;
           }
-          inputs.add(getVirtualModulePageNameFromPath(SPLIT_MODULE_ID, path));
+          inputs.add(getVirtualModulePageName(SPLIT_MODULE_ID, pageData.component));
         }
         return addRollupInput(opts, Array.from(inputs));
       }
@@ -134,8 +136,8 @@ function vitePluginSSRSplit(internals, adapter, options) {
         const imports = [];
         const contents = [];
         const exports = [];
-        const path = getPathFromVirtualModulePageName(RESOLVED_SPLIT_MODULE_ID, id);
-        const virtualModuleName = getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path);
+        const componentPath = getComponentFromVirtualModulePageName(RESOLVED_SPLIT_MODULE_ID, id);
+        const virtualModuleName = getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, componentPath);
         let module = await this.resolve(virtualModuleName);
         if (module) {
           imports.push(`import * as pageModule from "${virtualModuleName}";`);
@@ -225,9 +227,9 @@ if (_start in serverEntrypointModule) {
   };
 }
 function storeEntryPoint(moduleKey, options, internals, fileName) {
-  const componentPath = getPathFromVirtualModulePageName(RESOLVED_SPLIT_MODULE_ID, moduleKey);
-  for (const [page, pageData] of eachPageFromAllPages(options.allPages)) {
-    if (componentPath == page) {
+  const componentPath = getComponentFromVirtualModulePageName(RESOLVED_SPLIT_MODULE_ID, moduleKey);
+  for (const pageData of Object.values(options.allPages)) {
+    if (componentPath == pageData.component) {
       const publicPath = fileURLToPath(options.settings.config.build.server);
       internals.entryPoints.set(pageData.route, pathToFileURL(join(publicPath, fileName)));
     }

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

@@ -1,4 +1,6 @@
 import type { BuildOptions, Rollup, Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal.js';
+import type { PageBuildData } from '../types.js';
 type OutputOptionsHook = Extract<VitePlugin['outputOptions'], Function>;
 type OutputOptions = Parameters<OutputOptionsHook>[0];
 type ExtendManualChunksHooks = {
@@ -7,21 +9,34 @@ type ExtendManualChunksHooks = {
 };
 export declare function extendManualChunks(outputOptions: OutputOptions, hooks: ExtendManualChunksHooks): void;
 export declare const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
+export declare const ASTRO_PAGE_KEY_SEPARATOR = "&";
+/**
+ * Generate a unique key to identify each page in the build process.
+ * @param route Usually pageData.route.route
+ * @param componentPath Usually pageData.component
+ */
+export declare function makePageDataKey(route: string, componentPath: string): string;
 /**
  * Prevents Rollup from triggering other plugins in the process by masking the extension (hence the virtual file).
- *
- * 1. We add a fixed prefix, which is used as virtual module naming convention
- * 2. If the path has an extension (at the end of the path), we replace the dot that belongs to the extension with an arbitrary string.
- *
- * @param virtualModulePrefix
- * @param path
+ * 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;
+/**
+ * From the VirtualModulePageName, and the internals, get all pageDatas that use this
+ * component as their entry point.
+ * @param virtualModulePrefix The prefix used to create the virtual module
+ * @param id Virtual module name
  */
-export declare function getVirtualModulePageNameFromPath(virtualModulePrefix: string, path: string): string;
+export declare function getPagesFromVirtualModulePageName(internals: BuildInternals, virtualModulePrefix: string, id: string): PageBuildData[];
 /**
- *
- * @param virtualModulePrefix
- * @param id
+ * From the VirtualModulePageName, get the component path.
+ * Remember that the component can be use by multiple routes.
+ * Inverse function of getVirtualModulePageName() above.
+ * @param virtualModulePrefix The prefix at the beginning of the virtual module
+ * @param id Virtual module name
  */
-export declare function getPathFromVirtualModulePageName(virtualModulePrefix: string, id: string): string;
+export declare function getComponentFromVirtualModulePageName(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

@@ -26,13 +26,26 @@ function extendManualChunks(outputOptions, hooks) {
   };
 }
 const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
-function getVirtualModulePageNameFromPath(virtualModulePrefix, path) {
+const ASTRO_PAGE_KEY_SEPARATOR = "&";
+function makePageDataKey(route, componentPath) {
+  return route + ASTRO_PAGE_KEY_SEPARATOR + componentPath;
+}
+function getVirtualModulePageName(virtualModulePrefix, path) {
   const extension = extname(path);
   return virtualModulePrefix + (extension.startsWith(".") ? path.slice(0, -extension.length) + extension.replace(".", ASTRO_PAGE_EXTENSION_POST_PATTERN) : path);
 }
-function getPathFromVirtualModulePageName(virtualModulePrefix, id) {
-  const pageName = id.slice(virtualModulePrefix.length);
-  return pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
+function getPagesFromVirtualModulePageName(internals, virtualModulePrefix, id) {
+  const path = getComponentFromVirtualModulePageName(virtualModulePrefix, id);
+  const pages = [];
+  internals.pagesByKeys.forEach((pageData) => {
+    if (pageData.component === path) {
+      pages.push(pageData);
+    }
+  });
+  return pages;
+}
+function getComponentFromVirtualModulePageName(virtualModulePrefix, id) {
+  return id.slice(virtualModulePrefix.length).replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
 }
 function shouldInlineAsset(assetContent, assetPath, assetsInlineLimit) {
   if (typeof assetsInlineLimit === "function") {
@@ -47,8 +60,11 @@ function shouldInlineAsset(assetContent, assetPath, assetsInlineLimit) {
 }
 export {
   ASTRO_PAGE_EXTENSION_POST_PATTERN,
+  ASTRO_PAGE_KEY_SEPARATOR,
   extendManualChunks,
-  getPathFromVirtualModulePageName,
-  getVirtualModulePageNameFromPath,
+  getComponentFromVirtualModulePageName,
+  getPagesFromVirtualModulePageName,
+  getVirtualModulePageName,
+  makePageDataKey,
   shouldInlineAsset
 };

package/dist/core/build/static-build.js

@@ -10,13 +10,13 @@ import { PROPAGATED_ASSET_FLAG } from "../../content/consts.js";
 import { hasAnyContentFlag } from "../../content/utils.js";
 import {
   createBuildInternals,
-  eachPageData
+  getPageDatasWithPublicKey
 } from "../../core/build/internal.js";
 import { emptyDir, removeEmptyDirs } from "../../core/fs/index.js";
 import { appendForwardSlash, prependForwardSlash, removeFileExtension } from "../../core/path.js";
-import { isModeServerWithNoAdapter } from "../../core/util.js";
+import { isModeServerWithNoAdapter, isServerLikeOutput } from "../../core/util.js";
 import { runHookBuildSetup } from "../../integrations/hooks.js";
-import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js";
+import { getOutputDirectory } from "../../prerender/utils.js";
 import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { routeIsRedirect } from "../redirects/index.js";
@@ -26,6 +26,7 @@ import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { createPluginContainer } from "./plugin.js";
 import { registerAllPlugins } from "./plugins/index.js";
+import { copyContentToCache } from "./plugins/plugin-content.js";
 import { RESOLVED_SSR_MANIFEST_VIRTUAL_MODULE_ID } from "./plugins/plugin-manifest.js";
 import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
 import { RESOLVED_RENDERERS_MODULE_ID } from "./plugins/plugin-renderers.js";
@@ -40,10 +41,10 @@ async function viteBuild(opts) {
   settings.timer.start("SSR build");
   const pageInput = /* @__PURE__ */ new Set();
   const internals = createBuildInternals();
-  for (const [component, pageData] of Object.entries(allPages)) {
-    const astroModuleURL = new URL("./" + component, settings.config.root);
-    const astroModuleId = prependForwardSlash(component);
-    trackPageData(internals, component, pageData, astroModuleId, astroModuleURL);
+  for (const pageData of Object.values(allPages)) {
+    const astroModuleURL = new URL("./" + pageData.component, settings.config.root);
+    const astroModuleId = prependForwardSlash(pageData.component);
+    trackPageData(internals, pageData.component, pageData, astroModuleId, astroModuleURL);
     if (!routeIsRedirect(pageData.route)) {
       pageInput.add(astroModuleId);
     }
@@ -74,6 +75,9 @@ async function viteBuild(opts) {
   const ssrOutputs = viteBuildReturnToRollupOutputs(ssrOutput);
   const clientOutputs = viteBuildReturnToRollupOutputs(clientOutput ?? []);
   await runPostBuildHooks(container, ssrOutputs, clientOutputs);
+  if (opts.settings.config.experimental.contentCollectionCache) {
+    await copyContentToCache(opts);
+  }
   settings.timer.end("Client build");
   internals.ssrEntryChunk = void 0;
   if (opts.teardownCompiler) {
@@ -212,7 +216,7 @@ async function ssrBuild(opts, internals, input, container) {
   };
   const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
-    pages: internals.pagesByComponent,
+    pages: getPageDatasWithPublicKey(internals.pagesByKeys),
     vite: viteBuildConfig,
     target: "server",
     logger: opts.logger
@@ -260,7 +264,7 @@ ${bgGreen(black(" building client (vite) "))}`);
   };
   await runHookBuildSetup({
     config: settings.config,
-    pages: internals.pagesByComponent,
+    pages: getPageDatasWithPublicKey(internals.pagesByKeys),
     vite: viteBuildConfig,
     target: "client",
     logger: opts.logger
@@ -281,13 +285,18 @@ async function runPostBuildHooks(container, ssrOutputs, clientOutputs) {
   }
 }
 async function cleanStaticOutput(opts, internals, ssrOutputChunkNames) {
-  const allStaticFiles = /* @__PURE__ */ new Set();
-  for (const pageData of eachPageData(internals)) {
-    if (pageData.route.prerender && !pageData.hasSharedModules) {
-      const { moduleSpecifier } = pageData;
-      const pageBundleId = internals.pageToBundleMap.get(moduleSpecifier);
-      const entryBundleId = internals.entrySpecifierToBundleMap.get(moduleSpecifier);
-      allStaticFiles.add(pageBundleId ?? entryBundleId);
+  const prerenderedFiles = /* @__PURE__ */ new Set();
+  const onDemandsFiles = /* @__PURE__ */ new Set();
+  for (const pageData of internals.pagesByKeys.values()) {
+    const { moduleSpecifier } = pageData;
+    const bundleId = internals.pageToBundleMap.get(moduleSpecifier) ?? internals.entrySpecifierToBundleMap.get(moduleSpecifier);
+    if (pageData.route.prerender && !pageData.hasSharedModules && !onDemandsFiles.has(bundleId)) {
+      prerenderedFiles.add(bundleId);
+    } else {
+      onDemandsFiles.add(bundleId);
+      if (prerenderedFiles.has(bundleId)) {
+        prerenderedFiles.delete(bundleId);
+      }
     }
   }
   const ssr = isServerLikeOutput(opts.settings.config);
@@ -297,7 +306,7 @@ async function cleanStaticOutput(opts, internals, ssrOutputChunkNames) {
     await eslexer.init;
     await Promise.all(
       files.map(async (filename) => {
-        if (!allStaticFiles.has(filename)) {
+        if (!prerenderedFiles.has(filename)) {
           return;
         }
         const url = new URL(filename, out);
@@ -305,11 +314,9 @@ async function cleanStaticOutput(opts, internals, ssrOutputChunkNames) {
         const [, exports] = eslexer.parse(text);
         let value = "const noop = () => {};";
         for (const e of exports) {
-          if (e.n === "default")
-            value += `
+          if (e.n === "default") value += `
  export default noop;`;
-          else
-            value += `
+          else value += `
 export const ${e.n} = noop;`;
         }
         await fs.promises.writeFile(url, value, { encoding: "utf8" });
@@ -348,8 +355,7 @@ async function copyFiles(fromFolder, toFolder, includeDotfiles = false) {
     cwd: fileURLToPath(fromFolder),
     dot: includeDotfiles
   });
-  if (files.length === 0)
-    return;
+  if (files.length === 0) return;
   return await Promise.all(
     files.map(async function copyFile(filename) {
       const from = new URL(filename, fromFolder);
@@ -378,8 +384,7 @@ async function ssrMoveAssets(opts) {
         const currentUrl = new URL(filename, appendForwardSlash(serverAssets.toString()));
         const clientUrl = new URL(filename, appendForwardSlash(clientAssets.toString()));
         const dir = new URL(path.parse(clientUrl.href).dir);
-        if (!fs.existsSync(dir))
-          await fs.promises.mkdir(dir, { recursive: true });
+        if (!fs.existsSync(dir)) await fs.promises.mkdir(dir, { recursive: true });
         return fs.promises.rename(currentUrl, clientUrl);
       })
     );

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

@@ -12,16 +12,16 @@ export type StylesheetAsset = {
     type: 'external';
     src: string;
 };
+export type HoistedScriptAsset = {
+    type: 'inline' | 'external';
+    value: string;
+};
 export interface PageBuildData {
+    key: string;
     component: ComponentPath;
     route: RouteData;
     moduleSpecifier: string;
-    propagatedStyles: Map<string, Set<StylesheetAsset>>;
-    propagatedScripts: Map<string, Set<string>>;
-    hoistedScript: {
-        type: 'inline' | 'external';
-        value: string;
-    } | undefined;
+    hoistedScript: HoistedScriptAsset | undefined;
     styles: Array<{
         depth: number;
         order: number;

package/dist/core/client-directive/build.js

@@ -19,8 +19,7 @@ window.dispatchEvent(new Event('astro:' + ${stringifiedName}));`,
     write: false
   });
   const outputFile = output.outputFiles?.[0];
-  if (!outputFile)
-    return "";
+  if (!outputFile) return "";
   return outputFile.text;
 }
 export {

package/dist/core/config/config.js

@@ -23,9 +23,6 @@ async function validateConfig(userConfig, root, cmd) {
     }
     throw e;
   }
-  if (result.build.inlineStylesheets !== "auto" && result.experimental.contentCollectionCache) {
-    result.experimental.contentCollectionCache = false;
-  }
   return result;
 }
 function resolveFlags(flags) {
@@ -77,15 +74,13 @@ async function resolveConfigPath(options) {
   return userConfigPath;
 }
 async function loadConfig(root, configFile, fsMod = fs) {
-  if (configFile === false)
-    return {};
+  if (configFile === false) return {};
   const configPath = await resolveConfigPath({
     root,
     configFile,
     fs: fsMod
   });
-  if (!configPath)
-    return {};
+  if (!configPath) return {};
   try {
     return await loadConfigWithVite({
       root,

package/dist/core/config/logging.js

@@ -1,8 +1,7 @@
 import { Logger } from "../logger/core.js";
 import { nodeLogDestination } from "../logger/node.js";
 function createNodeLogger(inlineConfig) {
-  if (inlineConfig.logger)
-    return inlineConfig.logger;
+  if (inlineConfig.logger) return inlineConfig.logger;
   return new Logger({
     dest: nodeLogDestination,
     level: inlineConfig.logLevel ?? "info"