astro 3.4.4 → 3.5.1

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

@@ -1,7 +1,7 @@
 import type { Rollup } from 'vite';
 import type { RouteData, SSRResult } from '../../@types/astro.js';
 import type { PageOptions } from '../../vite-plugin-astro/types.js';
-import type { PageBuildData, StylesheetAsset, ViteID } from './types.js';
+import type { AllPagesData, PageBuildData, StylesheetAsset, ViteID } from './types.js';
 export interface BuildInternals {
     /**
      * Each CSS module is named with a chunk id derived from the Astro pages they
@@ -20,8 +20,14 @@ export interface BuildInternals {
     pageToBundleMap: Map<string, string>;
     /**
      * A map for page-specific information.
+     * // TODO: Remove in Astro 4.0
+     * @deprecated
      */
     pagesByComponent: Map<string, PageBuildData>;
+    /**
+     * TODO: Use this in Astro 4.0
+     */
+    pagesByComponents: Map<string, PageBuildData[]>;
     /**
      * A map for page-specific output.
      */
@@ -59,6 +65,9 @@ export interface BuildInternals {
      * These will be used as the top-level entrypoints for the client build.
      */
     discoveredScripts: Set<string>;
+    cachedClientEntries: string[];
+    propagatedStylesMap: Map<string, Set<StylesheetAsset>>;
+    propagatedScriptsMap: Map<string, Set<string>>;
     staticFiles: Set<string>;
     ssrEntryChunk?: Rollup.OutputChunk;
     manifestEntryChunk?: Rollup.OutputChunk;
@@ -84,6 +93,7 @@ export declare function getPageDataByComponent(internals: BuildInternals, compon
 export declare function getPageDataByViteID(internals: BuildInternals, viteid: ViteID): PageBuildData | undefined;
 export declare function hasPageDataByViteID(internals: BuildInternals, viteid: ViteID): boolean;
 export declare function eachPageData(internals: BuildInternals): Generator<PageBuildData, void, undefined>;
+export declare function eachPageFromAllPages(allPages: AllPagesData): Generator<[string, PageBuildData]>;
 export declare function eachPageDataFromEntryPoint(internals: BuildInternals): Generator<[PageBuildData, string]>;
 export declare function hasPrerenderedPages(internals: BuildInternals): boolean;
 interface OrderInfo {

package/dist/core/build/internal.js

@@ -1,4 +1,5 @@
 import { prependForwardSlash, removeFileExtension } from "../path.js";
+import { routeIsFallback } from "../redirects/helpers.js";
 import { viteID } from "../util.js";
 import {
   ASTRO_PAGE_RESOLVED_MODULE_ID,
@@ -10,15 +11,19 @@ function createBuildInternals() {
   const hoistedScriptIdToHoistedMap = /* @__PURE__ */ new Map();
   const hoistedScriptIdToPagesMap = /* @__PURE__ */ new Map();
   return {
+    cachedClientEntries: [],
     cssModuleToChunkIdMap: /* @__PURE__ */ new Map(),
     hoistedScriptIdToHoistedMap,
     hoistedScriptIdToPagesMap,
     entrySpecifierToBundleMap: /* @__PURE__ */ new Map(),
     pageToBundleMap: /* @__PURE__ */ new Map(),
     pagesByComponent: /* @__PURE__ */ new Map(),
+    pagesByComponents: /* @__PURE__ */ new Map(),
     pageOptionsByPage: /* @__PURE__ */ new Map(),
     pagesByViteID: /* @__PURE__ */ new Map(),
     pagesByClientOnly: /* @__PURE__ */ new Map(),
+    propagatedStylesMap: /* @__PURE__ */ new Map(),
+    propagatedScriptsMap: /* @__PURE__ */ new Map(),
     discoveredHydratedComponents: /* @__PURE__ */ new Map(),
     discoveredClientOnlyComponents: /* @__PURE__ */ new Map(),
     discoveredScripts: /* @__PURE__ */ new Set(),
@@ -30,7 +35,16 @@ function createBuildInternals() {
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {
   pageData.moduleSpecifier = componentModuleId;
-  internals.pagesByComponent.set(component, pageData);
+  if (!routeIsFallback(pageData.route)) {
+    internals.pagesByComponent.set(component, pageData);
+  }
+  const list = internals.pagesByComponents.get(component);
+  if (list) {
+    list.push(pageData);
+    internals.pagesByComponents.set(component, list);
+  } else {
+    internals.pagesByComponents.set(component, [pageData]);
+  }
   internals.pagesByViteID.set(viteID(componentURL), pageData);
 }
 function trackClientOnlyPageDatas(internals, pageData, clientOnlys) {
@@ -90,6 +104,13 @@ function hasPageDataByViteID(internals, viteid) {
 function* eachPageData(internals) {
   yield* internals.pagesByComponent.values();
 }
+function* eachPageFromAllPages(allPages) {
+  for (const [path, list] of Object.entries(allPages)) {
+    for (const pageData of list) {
+      yield [path, pageData];
+    }
+  }
+}
 function* eachPageDataFromEntryPoint(internals) {
   for (const [entryPoint, filePath] of internals.entrySpecifierToBundleMap) {
     if (entryPoint.includes(ASTRO_PAGE_RESOLVED_MODULE_ID) || entryPoint.includes(RESOLVED_SPLIT_MODULE_ID)) {
@@ -169,6 +190,7 @@ export {
   cssOrder,
   eachPageData,
   eachPageDataFromEntryPoint,
+  eachPageFromAllPages,
   getEntryFilePathFromComponentPath,
   getPageDataByComponent,
   getPageDataByViteID,

package/dist/core/build/page-data.js

@@ -21,15 +21,29 @@ async function collectPagesData(opts) {
         clearInterval(routeCollectionLogTimeout);
       }, 1e4);
       builtPaths.add(route.pathname);
-      allPages[route.component] = {
-        component: route.component,
-        route,
-        moduleSpecifier: "",
-        styles: [],
-        propagatedStyles: /* @__PURE__ */ new Map(),
-        propagatedScripts: /* @__PURE__ */ new Map(),
-        hoistedScript: void 0
-      };
+      if (allPages[route.component]) {
+        allPages[route.component].push({
+          component: route.component,
+          route,
+          moduleSpecifier: "",
+          styles: [],
+          propagatedStyles: /* @__PURE__ */ new Map(),
+          propagatedScripts: /* @__PURE__ */ new Map(),
+          hoistedScript: void 0
+        });
+      } else {
+        allPages[route.component] = [
+          {
+            component: route.component,
+            route,
+            moduleSpecifier: "",
+            styles: [],
+            propagatedStyles: /* @__PURE__ */ new Map(),
+            propagatedScripts: /* @__PURE__ */ new Map(),
+            hoistedScript: void 0
+          }
+        ];
+      }
       clearInterval(routeCollectionLogTimeout);
       if (settings.config.output === "static") {
         const html = `${route.pathname}`.replace(/\/?$/, "/index.html");
@@ -42,15 +56,29 @@ async function collectPagesData(opts) {
       }
       continue;
     }
-    allPages[route.component] = {
-      component: route.component,
-      route,
-      moduleSpecifier: "",
-      styles: [],
-      propagatedStyles: /* @__PURE__ */ new Map(),
-      propagatedScripts: /* @__PURE__ */ new Map(),
-      hoistedScript: void 0
-    };
+    if (allPages[route.component]) {
+      allPages[route.component].push({
+        component: route.component,
+        route,
+        moduleSpecifier: "",
+        styles: [],
+        propagatedStyles: /* @__PURE__ */ new Map(),
+        propagatedScripts: /* @__PURE__ */ new Map(),
+        hoistedScript: void 0
+      });
+    } else {
+      allPages[route.component] = [
+        {
+          component: route.component,
+          route,
+          moduleSpecifier: "",
+          styles: [],
+          propagatedStyles: /* @__PURE__ */ new Map(),
+          propagatedScripts: /* @__PURE__ */ new Map(),
+          hoistedScript: void 0
+        }
+      ];
+    }
   }
   clearInterval(dataCollectionLogTimeout);
   return { assets, allPages };

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

@@ -6,17 +6,19 @@ type OutputChunkorAsset = RollupOutputArray[number]['output'][number];
 type OutputChunk = Extract<OutputChunkorAsset, {
     type: 'chunk';
 }>;
-type MutateChunk = (chunk: OutputChunk, build: 'server' | 'client', newCode: string) => void;
+export type BuildTarget = 'server' | 'client';
+type MutateChunk = (chunk: OutputChunk, targets: BuildTarget[], newCode: string) => void;
+export interface BuildBeforeHookResult {
+    enforce?: 'after-user-plugins';
+    vitePlugin: VitePlugin | VitePlugin[] | undefined;
+}
 export type AstroBuildPlugin = {
-    build: 'ssr' | 'client' | 'both';
+    targets: BuildTarget[];
     hooks?: {
         'build:before'?: (opts: {
-            build: 'ssr' | 'client';
+            target: BuildTarget;
             input: Set<string>;
-        }) => {
-            enforce?: 'after-user-plugins';
-            vitePlugin: VitePlugin | VitePlugin[] | undefined;
-        };
+        }) => BuildBeforeHookResult | Promise<BuildBeforeHookResult>;
         'build:post'?: (opts: {
             ssrOutputs: RollupOutputArray;
             clientOutputs: RollupOutputArray;
@@ -28,12 +30,12 @@ export declare function createPluginContainer(options: StaticBuildOptions, inter
     options: StaticBuildOptions;
     internals: BuildInternals;
     register(plugin: AstroBuildPlugin): void;
-    runBeforeHook(build: 'ssr' | 'client', input: Set<string>): {
+    runBeforeHook(target: BuildTarget, input: Set<string>): Promise<{
         vitePlugins: (VitePlugin | VitePlugin[])[];
         lastVitePlugins: (VitePlugin | VitePlugin[])[];
-    };
+    }>;
     runPostHook(ssrReturn: ViteBuildReturn, clientReturn: ViteBuildReturn | null): Promise<Map<string, {
-        build: 'server' | 'client';
+        targets: BuildTarget[];
         code: string;
     }>>;
 };

package/dist/core/build/plugin.js

@@ -1,36 +1,28 @@
 function createPluginContainer(options, internals) {
-  const clientPlugins = [];
-  const ssrPlugins = [];
+  const plugins = /* @__PURE__ */ new Map();
   const allPlugins = /* @__PURE__ */ new Set();
+  for (const target of ["client", "server"]) {
+    plugins.set(target, []);
+  }
   return {
     options,
     internals,
     register(plugin) {
       allPlugins.add(plugin);
-      switch (plugin.build) {
-        case "client": {
-          clientPlugins.push(plugin);
-          break;
-        }
-        case "ssr": {
-          ssrPlugins.push(plugin);
-          break;
-        }
-        case "both": {
-          clientPlugins.push(plugin);
-          ssrPlugins.push(plugin);
-          break;
-        }
+      for (const target of plugin.targets) {
+        const targetPlugins = plugins.get(target) ?? [];
+        targetPlugins.push(plugin);
+        plugins.set(target, targetPlugins);
       }
     },
     // Hooks
-    runBeforeHook(build, input) {
-      let plugins = build === "ssr" ? ssrPlugins : clientPlugins;
+    async runBeforeHook(target, input) {
+      let targetPlugins = plugins.get(target) ?? [];
       let vitePlugins = [];
       let lastVitePlugins = [];
-      for (const plugin of plugins) {
+      for (const plugin of targetPlugins) {
         if (plugin.hooks?.["build:before"]) {
-          let result = plugin.hooks["build:before"]({ build, input });
+          let result = await plugin.hooks["build:before"]({ target, input });
           if (result.vitePlugin) {
             vitePlugins.push(result.vitePlugin);
           }
@@ -55,10 +47,10 @@ function createPluginContainer(options, internals) {
       } else if (clientReturn && "output" in clientReturn) {
         clientOutputs.push(clientReturn);
       }
-      const mutate = (chunk, build, newCode) => {
+      const mutate = (chunk, targets, newCode) => {
         chunk.code = newCode;
         mutations.set(chunk.fileName, {
-          build,
+          targets,
           code: newCode
         });
       };

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

@@ -2,7 +2,9 @@ import { astroConfigBuildPlugin } from "../../../content/vite-plugin-content-ass
 import { astroHeadBuildPlugin } from "../../../vite-plugin-head/index.js";
 import { pluginAliasResolve } from "./plugin-alias-resolve.js";
 import { pluginAnalyzer } from "./plugin-analyzer.js";
+import { pluginChunks } from "./plugin-chunks.js";
 import { pluginComponentEntry } from "./plugin-component-entry.js";
+import { pluginContent } from "./plugin-content.js";
 import { pluginCSS } from "./plugin-css.js";
 import { pluginHoistedScripts } from "./plugin-hoisted-scripts.js";
 import { pluginInternals } from "./plugin-internals.js";
@@ -21,6 +23,7 @@ function registerAllPlugins({ internals, options, register }) {
   register(pluginRenderers(options));
   register(pluginMiddleware(options, internals));
   register(pluginPages(options, internals));
+  register(pluginContent(options, internals));
   register(pluginCSS(options, internals));
   register(astroHeadBuildPlugin(internals));
   register(pluginPrerender(options, internals));
@@ -28,6 +31,7 @@ function registerAllPlugins({ internals, options, register }) {
   register(pluginHoistedScripts(options, internals));
   register(pluginSSR(options, internals));
   register(pluginSSRSplit(options, internals));
+  register(pluginChunks());
 }
 export {
   registerAllPlugins

package/dist/core/build/plugins/plugin-alias-resolve.js

@@ -34,7 +34,7 @@ function matches(pattern, importee) {
 }
 function pluginAliasResolve(internals) {
   return {
-    build: "client",
+    targets: ["client"],
     hooks: {
       "build:before": () => {
         return {

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

@@ -239,7 +239,7 @@ function vitePluginAnalyzer(options, internals) {
 }
 function pluginAnalyzer(options, internals) {
   return {
-    build: "ssr",
+    targets: ["server"],
     hooks: {
       "build:before": () => {
         return {

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

@@ -0,0 +1,4 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroBuildPlugin } from '../plugin.js';
+export declare function vitePluginChunks(): VitePlugin;
+export declare function pluginChunks(): AstroBuildPlugin;

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

@@ -0,0 +1,31 @@
+import { extendManualChunks } from "./util.js";
+function vitePluginChunks() {
+  return {
+    name: "astro:chunks",
+    outputOptions(outputOptions) {
+      extendManualChunks(outputOptions, {
+        after(id) {
+          if (id.includes("astro/dist/runtime/server/")) {
+            return "astro/server";
+          }
+        }
+      });
+    }
+  };
+}
+function pluginChunks() {
+  return {
+    targets: ["server"],
+    hooks: {
+      "build:before": () => {
+        return {
+          vitePlugin: vitePluginChunks()
+        };
+      }
+    }
+  };
+}
+export {
+  pluginChunks,
+  vitePluginChunks
+};

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

@@ -55,7 +55,7 @@ function normalizeEntryId(id) {
 }
 function pluginComponentEntry(internals) {
   return {
-    build: "client",
+    targets: ["client"],
     hooks: {
       "build:before": () => {
         return {

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

@@ -0,0 +1,4 @@
+import { type BuildInternals } from '../internal.js';
+import type { AstroBuildPlugin } from '../plugin.js';
+import type { StaticBuildOptions } from '../types.js';
+export declare function pluginContent(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

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

@@ -0,0 +1,273 @@
+import { createHash } from "node:crypto";
+import fsMod from "node:fs";
+import { fileURLToPath } from "node:url";
+import pLimit from "p-limit";
+import { normalizePath } from "vite";
+import { CONTENT_RENDER_FLAG, PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
+import { hasContentFlag } from "../../../content/utils.js";
+import {
+  generateContentEntryFile,
+  generateLookupMap
+} from "../../../content/vite-plugin-content-virtual-mod.js";
+import { isServerLikeOutput } from "../../../prerender/utils.js";
+import { joinPaths, removeFileExtension, removeLeadingForwardSlash } from "../../path.js";
+import { addRollupInput } from "../add-rollup-input.js";
+import {} from "../internal.js";
+import { copyFiles } from "../static-build.js";
+import { encodeName } from "../util.js";
+import { extendManualChunks } from "./util.js";
+const CONTENT_CACHE_DIR = "./content/";
+const CONTENT_MANIFEST_FILE = "./manifest.json";
+const CONTENT_MANIFEST_VERSION = 0;
+const virtualEmptyModuleId = `virtual:empty-content`;
+const resolvedVirtualEmptyModuleId = `\0${virtualEmptyModuleId}`;
+function createContentManifest() {
+  return { version: -1, entries: [], serverEntries: [], clientEntries: [] };
+}
+function vitePluginContent(opts, lookupMap, internals) {
+  const { config } = opts.settings;
+  const { cacheDir } = config;
+  const distRoot = config.outDir;
+  const distContentRoot = new URL("./content/", distRoot);
+  const cachedChunks = new URL("./chunks/", opts.settings.config.cacheDir);
+  const distChunks = new URL("./chunks/", opts.settings.config.outDir);
+  const contentCacheDir = new URL(CONTENT_CACHE_DIR, cacheDir);
+  const contentManifestFile = new URL(CONTENT_MANIFEST_FILE, contentCacheDir);
+  const cache = contentCacheDir;
+  const cacheTmp = new URL("./.tmp/", cache);
+  let oldManifest = createContentManifest();
+  let newManifest = createContentManifest();
+  let entries;
+  let injectedEmptyFile = false;
+  if (fsMod.existsSync(contentManifestFile)) {
+    try {
+      const data = fsMod.readFileSync(contentManifestFile, { encoding: "utf8" });
+      oldManifest = JSON.parse(data);
+      internals.cachedClientEntries = oldManifest.clientEntries;
+    } catch {
+    }
+  }
+  return {
+    name: "@astro/plugin-build-content",
+    async options(options) {
+      let newOptions = Object.assign({}, options);
+      newManifest = await generateContentManifest(opts, lookupMap);
+      entries = getEntriesFromManifests(oldManifest, newManifest);
+      for (const { type, entry } of entries.buildFromSource) {
+        const fileURL = encodeURI(joinPaths(opts.settings.config.root.toString(), entry));
+        const input = fileURLToPath(fileURL);
+        const inputs = [`${input}?${collectionTypeToFlag(type)}`];
+        if (type === "content") {
+          inputs.push(`${input}?${CONTENT_RENDER_FLAG}`);
+        }
+        newOptions = addRollupInput(newOptions, inputs);
+      }
+      if (fsMod.existsSync(cachedChunks)) {
+        await copyFiles(cachedChunks, distChunks, true);
+      }
+      if (entries.buildFromSource.length === 0) {
+        newOptions = addRollupInput(newOptions, [virtualEmptyModuleId]);
+        injectedEmptyFile = true;
+      }
+      return newOptions;
+    },
+    outputOptions(outputOptions) {
+      const rootPath = normalizePath(fileURLToPath(opts.settings.config.root));
+      const srcPath = normalizePath(fileURLToPath(opts.settings.config.srcDir));
+      extendManualChunks(outputOptions, {
+        before(id, meta) {
+          if (id.startsWith(srcPath) && id.slice(srcPath.length).startsWith("content")) {
+            const info = meta.getModuleInfo(id);
+            if (info?.dynamicImporters.length === 1 && hasContentFlag(info.dynamicImporters[0], PROPAGATED_ASSET_FLAG)) {
+              const [srcRelativePath2] = id.replace(rootPath, "/").split("?");
+              const resultId = encodeName(
+                `${removeLeadingForwardSlash(removeFileExtension(srcRelativePath2))}.render.mjs`
+              );
+              return resultId;
+            }
+            const [srcRelativePath, flag] = id.replace(rootPath, "/").split("?");
+            const collectionEntry = findEntryFromSrcRelativePath(lookupMap, srcRelativePath);
+            if (collectionEntry) {
+              let suffix = ".mjs";
+              if (flag === PROPAGATED_ASSET_FLAG) {
+                suffix = ".entry.mjs";
+              }
+              id = removeLeadingForwardSlash(
+                removeFileExtension(encodeName(id.replace(srcPath, "/")))
+              ) + suffix;
+              return id;
+            }
+          }
+        }
+      });
+    },
+    resolveId(id) {
+      if (id === virtualEmptyModuleId) {
+        return resolvedVirtualEmptyModuleId;
+      }
+    },
+    async load(id) {
+      if (id === resolvedVirtualEmptyModuleId) {
+        return {
+          code: `// intentionally left empty!
+export default {}`
+        };
+      }
+    },
+    async generateBundle(_options, bundle) {
+      const code = await generateContentEntryFile({
+        settings: opts.settings,
+        fs: fsMod,
+        lookupMap,
+        IS_DEV: false,
+        IS_SERVER: false
+      });
+      this.emitFile({
+        type: "prebuilt-chunk",
+        code,
+        fileName: "content/entry.mjs"
+      });
+      if (!injectedEmptyFile)
+        return;
+      Object.keys(bundle).forEach((key) => {
+        const mod = bundle[key];
+        if (mod.type === "asset")
+          return;
+        if (mod.facadeModuleId === resolvedVirtualEmptyModuleId) {
+          delete bundle[key];
+        }
+      });
+    },
+    async writeBundle() {
+      const clientComponents = /* @__PURE__ */ new Set([
+        ...oldManifest.clientEntries,
+        ...internals.discoveredHydratedComponents.keys(),
+        ...internals.discoveredClientOnlyComponents.keys(),
+        ...internals.discoveredScripts
+      ]);
+      const serverComponents = /* @__PURE__ */ new Set([
+        ...oldManifest.serverEntries,
+        ...internals.discoveredHydratedComponents.keys()
+      ]);
+      newManifest.serverEntries = Array.from(serverComponents);
+      newManifest.clientEntries = Array.from(clientComponents);
+      await fsMod.promises.mkdir(contentCacheDir, { recursive: true });
+      await fsMod.promises.writeFile(contentManifestFile, JSON.stringify(newManifest), {
+        encoding: "utf8"
+      });
+      const cacheExists = fsMod.existsSync(cache);
+      fsMod.mkdirSync(cache, { recursive: true });
+      await fsMod.promises.mkdir(cacheTmp, { recursive: true });
+      await copyFiles(distContentRoot, cacheTmp, true);
+      if (cacheExists) {
+        await copyFiles(contentCacheDir, distContentRoot, false);
+      }
+      await copyFiles(cacheTmp, contentCacheDir);
+      await fsMod.promises.rm(cacheTmp, { recursive: true, force: true });
+    }
+  };
+}
+const entryCache = /* @__PURE__ */ new Map();
+function findEntryFromSrcRelativePath(lookupMap, srcRelativePath) {
+  let value = entryCache.get(srcRelativePath);
+  if (value)
+    return value;
+  for (const collection of Object.values(lookupMap)) {
+    for (const entry of Object.values(collection)) {
+      for (const entryFile of Object.values(entry)) {
+        if (entryFile === srcRelativePath) {
+          value = entryFile;
+          entryCache.set(srcRelativePath, entryFile);
+          return value;
+        }
+      }
+    }
+  }
+}
+function getEntriesFromManifests(oldManifest, newManifest) {
+  const { version: oldVersion, entries: oldEntries } = oldManifest;
+  const { version: newVersion, entries: newEntries } = newManifest;
+  let entries = { restoreFromCache: [], buildFromSource: [] };
+  const newEntryMap = new Map(newEntries);
+  if (oldVersion !== newVersion || oldEntries.length === 0) {
+    entries.buildFromSource = Array.from(newEntryMap.keys());
+    return entries;
+  }
+  const oldEntryHashMap = new Map(
+    oldEntries.map(([key, hash]) => [hash, key])
+  );
+  for (const [entry, hash] of newEntryMap) {
+    if (oldEntryHashMap.has(hash)) {
+      entries.restoreFromCache.push(entry);
+    } else {
+      entries.buildFromSource.push(entry);
+    }
+  }
+  return entries;
+}
+async function generateContentManifest(opts, lookupMap) {
+  let manifest = {
+    version: CONTENT_MANIFEST_VERSION,
+    entries: [],
+    serverEntries: [],
+    clientEntries: []
+  };
+  const limit = pLimit(10);
+  const promises = [];
+  for (const [collection, { type, entries }] of Object.entries(lookupMap)) {
+    for (const entry of Object.values(entries)) {
+      const key = { collection, type, entry };
+      const fileURL = new URL(encodeURI(joinPaths(opts.settings.config.root.toString(), entry)));
+      promises.push(
+        limit(async () => {
+          const data = await fsMod.promises.readFile(fileURL, { encoding: "utf8" });
+          manifest.entries.push([key, checksum(data)]);
+        })
+      );
+    }
+  }
+  await Promise.all(promises);
+  return manifest;
+}
+function checksum(data) {
+  return createHash("sha1").update(data).digest("base64");
+}
+function collectionTypeToFlag(type) {
+  const name = type[0].toUpperCase() + type.slice(1);
+  return `astro${name}CollectionEntry`;
+}
+function pluginContent(opts, internals) {
+  const cachedChunks = new URL("./chunks/", opts.settings.config.cacheDir);
+  const distChunks = new URL("./chunks/", opts.settings.config.outDir);
+  return {
+    targets: ["server"],
+    hooks: {
+      async "build:before"() {
+        if (!opts.settings.config.experimental.contentCollectionCache) {
+          return { vitePlugin: void 0 };
+        }
+        if (isServerLikeOutput(opts.settings.config)) {
+          return { vitePlugin: void 0 };
+        }
+        const lookupMap = await generateLookupMap({ settings: opts.settings, fs: fsMod });
+        return {
+          vitePlugin: vitePluginContent(opts, lookupMap, internals)
+        };
+      },
+      async "build:post"() {
+        if (!opts.settings.config.experimental.contentCollectionCache) {
+          return;
+        }
+        if (isServerLikeOutput(opts.settings.config)) {
+          return;
+        }
+        if (fsMod.existsSync(distChunks)) {
+          await copyFiles(distChunks, cachedChunks, true);
+        }
+      }
+    }
+  };
+}
+export {
+  pluginContent
+};