astro 2.4.3 → 2.4.5

package/dist/assets/services/service.js

@@ -1,4 +1,5 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { joinPaths } from "../../core/path.js";
 import { VALID_OPTIMIZABLE_FORMATS } from "../consts.js";
 import { isESMImportedImage } from "../internal.js";
 function isLocalService(service) {
@@ -87,7 +88,7 @@ const baseService = {
     options.height && searchParams.append("h", options.height.toString());
     options.quality && searchParams.append("q", options.quality.toString());
     options.format && searchParams.append("f", options.format);
-    return "/_image?" + searchParams;
+    return joinPaths(import.meta.env.BASE_URL, "/_image?") + searchParams;
   },
   parseURL(url) {
     const params = url.searchParams;

package/dist/assets/vite-plugin-assets.js

@@ -6,7 +6,12 @@ import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { error } from "../core/logger/core.js";
-import { appendForwardSlash, joinPaths, prependForwardSlash } from "../core/path.js";
+import {
+  appendForwardSlash,
+  joinPaths,
+  prependForwardSlash,
+  removeQueryString
+} from "../core/path.js";
 import { VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { isESMImportedImage } from "./internal.js";
 import { isLocalService } from "./services/service.js";
@@ -184,7 +189,8 @@ function assets({
         resolvedConfig = viteConfig;
       },
       async load(id) {
-        if (/\.(jpeg|jpg|png|tiff|webp|gif|svg)$/.test(id)) {
+        const cleanedUrl = removeQueryString(id);
+        if (/\.(jpeg|jpg|png|tiff|webp|gif|svg)$/.test(cleanedUrl)) {
           const meta = await emitESMImage(id, this.meta.watchMode, this.emitFile, settings);
           return `export default ${JSON.stringify(meta)}`;
         }

package/dist/content/runtime.d.ts

@@ -1,16 +1,18 @@
-type GlobResult = Record<string, () => Promise<any>>;
+type LazyImport = () => Promise<any>;
+type GlobResult = Record<string, LazyImport>;
 type CollectionToEntryMap = Record<string, GlobResult>;
+type GetEntryImport = (collection: string, lookupId: string) => Promise<LazyImport>;
 export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
     globResult: GlobResult;
     contentDir: string;
 }): CollectionToEntryMap;
-export declare function createGetCollection({ collectionToEntryMap, collectionToRenderEntryMap, }: {
+export declare function createGetCollection({ collectionToEntryMap, getRenderEntryImport, }: {
     collectionToEntryMap: CollectionToEntryMap;
-    collectionToRenderEntryMap: CollectionToEntryMap;
+    getRenderEntryImport: GetEntryImport;
 }): (collection: string, filter?: ((entry: any) => unknown) | undefined) => Promise<any[]>;
-export declare function createGetEntryBySlug({ getCollection, collectionToRenderEntryMap, }: {
-    getCollection: ReturnType<typeof createGetCollection>;
-    collectionToRenderEntryMap: CollectionToEntryMap;
+export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, }: {
+    getEntryImport: GetEntryImport;
+    getRenderEntryImport: GetEntryImport;
 }): (collection: string, slug: string) => Promise<{
     id: any;
     slug: any;

package/dist/content/runtime.js

@@ -20,16 +20,15 @@ function createCollectionToGlobResultMap({
     if (segments.length <= 1)
       continue;
     const collection = segments[0];
-    const entryId = segments.slice(1).join("/");
     collectionToGlobResultMap[collection] ??= {};
-    collectionToGlobResultMap[collection][entryId] = globResult[key];
+    collectionToGlobResultMap[collection][key] = globResult[key];
   }
   return collectionToGlobResultMap;
 }
 const cacheEntriesByCollection = /* @__PURE__ */ new Map();
 function createGetCollection({
   collectionToEntryMap,
-  collectionToRenderEntryMap
+  getRenderEntryImport
 }) {
   return async function getCollection(collection, filter) {
     const lazyImports = Object.values(collectionToEntryMap[collection] ?? {});
@@ -50,7 +49,7 @@ function createGetCollection({
               return render({
                 collection: entry.collection,
                 id: entry.id,
-                collectionToRenderEntryMap
+                renderEntryImport: await getRenderEntryImport(collection, entry.slug)
               });
             }
           };
@@ -66,22 +65,14 @@ function createGetCollection({
   };
 }
 function createGetEntryBySlug({
-  getCollection,
-  collectionToRenderEntryMap
+  getEntryImport,
+  getRenderEntryImport
 }) {
   return async function getEntryBySlug(collection, slug) {
-    const entries = await getCollection(collection);
-    let candidate = void 0;
-    for (let entry2 of entries) {
-      if (entry2.slug === slug) {
-        candidate = entry2;
-        break;
-      }
-    }
-    if (typeof candidate === "undefined") {
+    const entryImport = await getEntryImport(collection, slug);
+    if (typeof entryImport !== "function")
       return void 0;
-    }
-    const entry = candidate;
+    const entry = await entryImport();
     return {
       id: entry.id,
       slug: entry.slug,
@@ -92,7 +83,7 @@ function createGetEntryBySlug({
         return render({
           collection: entry.collection,
           id: entry.id,
-          collectionToRenderEntryMap
+          renderEntryImport: await getRenderEntryImport(collection, slug)
         });
       }
     };
@@ -101,17 +92,16 @@ function createGetEntryBySlug({
 async function render({
   collection,
   id,
-  collectionToRenderEntryMap
+  renderEntryImport
 }) {
-  var _a, _b;
+  var _a;
   const UnexpectedRenderError = new AstroError({
     ...AstroErrorData.UnknownContentCollectionError,
     message: `Unexpected error while rendering ${String(collection)} \u2192 ${String(id)}.`
   });
-  const lazyImport = (_a = collectionToRenderEntryMap[collection]) == null ? void 0 : _a[id];
-  if (typeof lazyImport !== "function")
+  if (typeof renderEntryImport !== "function")
     throw UnexpectedRenderError;
-  const baseMod = await lazyImport();
+  const baseMod = await renderEntryImport();
   if (baseMod == null || typeof baseMod !== "object")
     throw UnexpectedRenderError;
   const { collectedStyles, collectedLinks, collectedScripts, getMod } = baseMod;
@@ -158,7 +148,7 @@ async function render({
   });
   return {
     Content,
-    headings: ((_b = mod.getHeadings) == null ? void 0 : _b.call(mod)) ?? [],
+    headings: ((_a = mod.getHeadings) == null ? void 0 : _a.call(mod)) ?? [],
     remarkPluginFrontmatter: mod.frontmatter ?? {}
   };
 }

package/dist/content/types-generator.js

@@ -6,16 +6,15 @@ import { normalizePath } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { info, warn } from "../core/logger/core.js";
 import { isRelativePath } from "../core/path.js";
-import { CONTENT_TYPES_FILE } from "./consts.js";
+import { CONTENT_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
 import {
-  getContentEntryExts,
+  getContentEntryConfigByExtMap,
   getContentPaths,
   getEntryInfo,
   getEntrySlug,
   getEntryType,
   loadContentConfig,
-  NoCollectionError,
-  parseFrontmatter
+  NoCollectionError
 } from "./utils.js";
 class UnsupportedFileTypeError extends Error {
 }
@@ -28,7 +27,8 @@ async function createContentTypesGenerator({
 }) {
   const contentTypes = {};
   const contentPaths = getContentPaths(settings.config, fs);
-  const contentEntryExts = getContentEntryExts(settings);
+  const contentEntryConfigByExt = getContentEntryConfigByExtMap(settings);
+  const contentEntryExts = [...contentEntryConfigByExt.keys()];
   let events = [];
   let debounceTimeout;
   const typeTemplateContent = await fs.promises.readFile(contentPaths.typesTemplate, "utf-8");
@@ -139,12 +139,22 @@ async function createContentTypesGenerator({
       }
       return { shouldGenerateTypes: false };
     }
-    const { id, collection } = entryInfo;
+    const { id, collection, slug: generatedSlug } = entryInfo;
+    const contentEntryType = contentEntryConfigByExt.get(path.extname(event.entry.pathname));
+    if (!contentEntryType)
+      return { shouldGenerateTypes: false };
     const collectionKey = JSON.stringify(collection);
     const entryKey = JSON.stringify(id);
     switch (event.name) {
       case "add":
-        const addedSlug = await parseSlug({ fs, event, entryInfo });
+        const addedSlug = await getEntrySlug({
+          generatedSlug,
+          id,
+          collection,
+          fileUrl: event.entry,
+          contentEntryType,
+          fs
+        });
         if (!(collectionKey in contentTypes)) {
           addCollection(contentTypes, collectionKey);
         }
@@ -158,7 +168,14 @@ async function createContentTypesGenerator({
         }
         return { shouldGenerateTypes: true };
       case "change":
-        const changedSlug = await parseSlug({ fs, event, entryInfo });
+        const changedSlug = await getEntrySlug({
+          generatedSlug,
+          id,
+          collection,
+          fileUrl: event.entry,
+          contentEntryType,
+          fs
+        });
         if (((_b = (_a = contentTypes[collectionKey]) == null ? void 0 : _a[entryKey]) == null ? void 0 : _b.slug) !== changedSlug) {
           setEntry(contentTypes, collectionKey, entryKey, changedSlug);
           return { shouldGenerateTypes: true };
@@ -224,6 +241,7 @@ async function createContentTypesGenerator({
         contentConfig: observable.status === "loaded" ? observable.config : void 0,
         contentEntryTypes: settings.contentEntryTypes
       });
+      invalidateVirtualMod(viteServer);
       if (observable.status === "loaded" && ["info", "warn"].includes(logLevel)) {
         warnNonexistentCollections({
           logging,
@@ -235,21 +253,18 @@ async function createContentTypesGenerator({
   }
   return { init, queueEvent };
 }
+function invalidateVirtualMod(viteServer) {
+  const virtualMod = viteServer.moduleGraph.getModuleById("\0" + VIRTUAL_MODULE_ID);
+  if (!virtualMod)
+    return;
+  viteServer.moduleGraph.invalidateModule(virtualMod);
+}
 function addCollection(contentMap, collectionKey) {
   contentMap[collectionKey] = {};
 }
 function removeCollection(contentMap, collectionKey) {
   delete contentMap[collectionKey];
 }
-async function parseSlug({
-  fs,
-  event,
-  entryInfo
-}) {
-  const rawContents = await fs.promises.readFile(event.entry, "utf-8");
-  const { data: frontmatter } = parseFrontmatter(rawContents, fileURLToPath(event.entry));
-  return getEntrySlug({ ...entryInfo, unvalidatedSlug: frontmatter.slug });
-}
 function setEntry(contentTypes, collectionKey, entryKey, slug) {
   contentTypes[collectionKey][entryKey] = { slug };
 }

package/dist/content/utils.d.ts

@@ -4,7 +4,7 @@ import fsMod from 'node:fs';
 import type { PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
-import type { AstroConfig, AstroSettings } from '../@types/astro.js';
+import type { AstroConfig, AstroSettings, ContentEntryType } from '../@types/astro.js';
 export declare const collectionConfigParser: z.ZodObject<{
     schema: z.ZodOptional<z.ZodAny>;
 }, "strip", z.ZodTypeAny, {
@@ -47,8 +47,11 @@ export type EntryInfo = {
 export declare const msg: {
     collectionConfigMissing: (collection: string) => string;
 };
-export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }: EntryInfo & {
-    unvalidatedSlug?: unknown;
+export declare function parseEntrySlug({ id, collection, generatedSlug, frontmatterSlug, }: {
+    id: string;
+    collection: string;
+    generatedSlug: string;
+    frontmatterSlug?: unknown;
 }): string;
 export declare function getEntryData(entry: EntryInfo & {
     unvalidatedData: Record<string, unknown>;
@@ -57,13 +60,15 @@ export declare function getEntryData(entry: EntryInfo & {
     [x: string]: unknown;
 }>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
+export declare function getContentEntryConfigByExtMap(settings: Pick<AstroSettings, 'contentEntryTypes'>): Map<string, ContentEntryType>;
 export declare class NoCollectionError extends Error {
 }
 export declare function getEntryInfo(params: Pick<ContentPaths, 'contentDir'> & {
-    entry: URL;
+    entry: string | URL;
     allowFilesOutsideCollection?: true;
 }): EntryInfo;
 export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], experimentalAssets: boolean): 'content' | 'config' | 'ignored' | 'unsupported';
+export declare function hasUnderscoreBelowContentDirectoryPath(fileUrl: URL, contentDir: ContentPaths['contentDir']): boolean;
 /**
  * Match YAML exception handling from Astro core errors
  * @see 'astro/src/core/errors.ts'
@@ -113,4 +118,17 @@ export type ContentPaths = {
     };
 };
 export declare function getContentPaths({ srcDir, root }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod): ContentPaths;
+/**
+ * Check for slug in content entry frontmatter and validate the type,
+ * falling back to the `generatedSlug` if none is found.
+ */
+export declare function getEntrySlug({ id, collection, generatedSlug, contentEntryType, fileUrl, fs, }: {
+    fs: typeof fsMod;
+    id: string;
+    collection: string;
+    generatedSlug: string;
+    fileUrl: URL;
+    contentEntryType: Pick<ContentEntryType, 'getEntryInfo'>;
+}): Promise<string>;
+export declare function getExtGlob(exts: string[]): string;
 export {};

package/dist/content/utils.js

@@ -26,14 +26,14 @@ const contentConfigParser = z.object({
 const msg = {
   collectionConfigMissing: (collection) => `${collection} does not have a config. We suggest adding one for type safety!`
 };
-function getEntrySlug({
+function parseEntrySlug({
   id,
   collection,
-  slug,
-  unvalidatedSlug
+  generatedSlug,
+  frontmatterSlug
 }) {
   try {
-    return z.string().default(slug).parse(unvalidatedSlug);
+    return z.string().default(generatedSlug).parse(frontmatterSlug);
   } catch {
     throw new AstroError({
       ...AstroErrorData.InvalidContentEntrySlugError,
@@ -91,6 +91,15 @@ async function getEntryData(entry, collectionConfig, pluginContext, settings) {
 function getContentEntryExts(settings) {
   return settings.contentEntryTypes.map((t) => t.extensions).flat();
 }
+function getContentEntryConfigByExtMap(settings) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entryType of settings.contentEntryTypes) {
+    for (const ext of entryType.extensions) {
+      map.set(ext, entryType);
+    }
+  }
+  return map;
+}
 class NoCollectionError extends Error {
 }
 function getEntryInfo({
@@ -98,7 +107,10 @@ function getEntryInfo({
   contentDir,
   allowFilesOutsideCollection = false
 }) {
-  const rawRelativePath = path.relative(fileURLToPath(contentDir), fileURLToPath(entry));
+  const rawRelativePath = path.relative(
+    fileURLToPath(contentDir),
+    typeof entry === "string" ? entry : fileURLToPath(entry)
+  );
   const rawCollection = path.dirname(rawRelativePath).split(path.sep).shift();
   const isOutsideCollection = rawCollection === ".." || rawCollection === ".";
   if (!rawCollection || !allowFilesOutsideCollection && isOutsideCollection)
@@ -238,11 +250,38 @@ function search(fs, srcDir) {
   }
   return { exists: false, url: paths[0] };
 }
+async function getEntrySlug({
+  id,
+  collection,
+  generatedSlug,
+  contentEntryType,
+  fileUrl,
+  fs
+}) {
+  let contents;
+  try {
+    contents = await fs.promises.readFile(fileUrl, "utf-8");
+  } catch (e) {
+    throw new AstroError(AstroErrorData.UnknownContentCollectionError, { cause: e });
+  }
+  const { slug: frontmatterSlug } = await contentEntryType.getEntryInfo({
+    fileUrl,
+    contents: await fs.promises.readFile(fileUrl, "utf-8")
+  });
+  return parseEntrySlug({ generatedSlug, frontmatterSlug, id, collection });
+}
+function getExtGlob(exts) {
+  return exts.length === 1 ? (
+    // Wrapping {...} breaks when there is only one extension
+    exts[0]
+  ) : `{${exts.join(",")}}`;
+}
 export {
   NoCollectionError,
   collectionConfigParser,
   contentConfigParser,
   contentObservable,
+  getContentEntryConfigByExtMap,
   getContentEntryExts,
   getContentPaths,
   getDotAstroTypeReference,
@@ -250,8 +289,11 @@ export {
   getEntryInfo,
   getEntrySlug,
   getEntryType,
+  getExtGlob,
   globalContentConfigObserver,
+  hasUnderscoreBelowContentDirectoryPath,
   loadContentConfig,
   msg,
+  parseEntrySlug,
   parseFrontmatter
 };

package/dist/content/vite-plugin-content-assets.js

@@ -11,7 +11,6 @@ import {
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER
 } from "./consts.js";
-import { getContentEntryExts } from "./utils.js";
 function isPropagatedAsset(viteId) {
   const flags = new URLSearchParams(viteId.split("?")[1]);
   return flags.has(PROPAGATED_ASSET_FLAG);
@@ -21,7 +20,6 @@ function astroContentAssetPropagationPlugin({
   settings
 }) {
   let devModuleLoader;
-  const contentEntryExts = getContentEntryExts(settings);
   return {
     name: "astro:content-asset-propagation",
     configureServer(server) {

package/dist/content/vite-plugin-content-imports.js

@@ -6,14 +6,15 @@ import { AstroError } from "../core/errors/errors.js";
 import { escapeViteEnvReferences, getFileInfo } from "../vite-plugin-utils/index.js";
 import { CONTENT_FLAG } from "./consts.js";
 import {
+  getContentEntryConfigByExtMap,
   getContentEntryExts,
   getContentPaths,
   getEntryData,
   getEntryInfo,
-  getEntrySlug,
   getEntryType,
   globalContentConfigObserver,
-  NoCollectionError
+  NoCollectionError,
+  parseEntrySlug
 } from "./utils.js";
 function isContentFlagImport(viteId) {
   const flags = new URLSearchParams(viteId.split("?")[1]);
@@ -37,12 +38,7 @@ function astroContentImportPlugin({
 }) {
   const contentPaths = getContentPaths(settings.config, fs);
   const contentEntryExts = getContentEntryExts(settings);
-  const contentEntryExtToParser = /* @__PURE__ */ new Map();
-  for (const entryType of settings.contentEntryTypes) {
-    for (const ext of entryType.extensions) {
-      contentEntryExtToParser.set(ext, entryType);
-    }
-  }
+  const contentEntryConfigByExt = getContentEntryConfigByExtMap(settings);
   const plugins = [
     {
       name: "astro:content-imports",
@@ -131,7 +127,7 @@ function astroContentImportPlugin({
     const contentConfig = await getContentConfigFromGlobal();
     const rawContents = await fs.promises.readFile(fileId, "utf-8");
     const fileExt = extname(fileId);
-    if (!contentEntryExtToParser.has(fileExt)) {
+    if (!contentEntryConfigByExt.has(fileExt)) {
       throw new AstroError({
         ...AstroErrorData.UnknownContentCollectionError,
         message: `No parser found for content entry ${JSON.stringify(
@@ -139,13 +135,13 @@ function astroContentImportPlugin({
         )}. Did you apply an integration for this file type?`
       });
     }
-    const contentEntryParser = contentEntryExtToParser.get(fileExt);
+    const contentEntryConfig = contentEntryConfigByExt.get(fileExt);
     const {
       rawData,
       body,
-      slug: unvalidatedSlug,
+      slug: frontmatterSlug,
       data: unvalidatedData
-    } = await contentEntryParser.getEntryInfo({
+    } = await contentEntryConfig.getEntryInfo({
       fileUrl: pathToFileURL(fileId),
       contents: rawContents
     });
@@ -157,7 +153,12 @@ function astroContentImportPlugin({
       throw entryInfoResult;
     const { id, slug: generatedSlug, collection } = entryInfoResult;
     const _internal = { filePath: fileId, rawData };
-    const slug = getEntrySlug({ id, collection, slug: generatedSlug, unvalidatedSlug });
+    const slug = parseEntrySlug({
+      id,
+      collection,
+      generatedSlug,
+      frontmatterSlug
+    });
     const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
     let data = collectionConfig ? await getEntryData(
       { id, collection, slug, _internal, unvalidatedData },

package/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -1,7 +1,21 @@
+/// <reference types="node" />
+import fsMod from 'node:fs';
 import type { Plugin } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
+import { getContentEntryConfigByExtMap, type ContentPaths } from './utils.js';
 interface AstroContentVirtualModPluginParams {
     settings: AstroSettings;
 }
 export declare function astroContentVirtualModPlugin({ settings, }: AstroContentVirtualModPluginParams): Plugin;
+/**
+ * Generate a map from a collection + slug to the local file path.
+ * This is used internally to resolve entry imports when using `getEntryBySlug()`.
+ * @see `src/content/virtual-mod.mjs`
+ */
+export declare function getStringifiedLookupMap({ contentPaths, contentEntryConfigByExt, root, fs, }: {
+    contentEntryConfigByExt: ReturnType<typeof getContentEntryConfigByExtMap>;
+    contentPaths: Pick<ContentPaths, 'contentDir' | 'cacheDir'>;
+    root: URL;
+    fs: typeof fsMod;
+}): Promise<string>;
 export {};

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,25 +1,26 @@
+import glob from "fast-glob";
 import fsMod from "node:fs";
-import * as path from "node:path";
-import { normalizePath } from "vite";
-import { appendForwardSlash, prependForwardSlash } from "../core/path.js";
+import { extname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { rootRelativePath } from "../core/util.js";
 import { VIRTUAL_MODULE_ID } from "./consts.js";
-import { getContentEntryExts, getContentPaths } from "./utils.js";
+import {
+  getContentEntryConfigByExtMap,
+  getContentPaths,
+  getEntryInfo,
+  getEntrySlug,
+  getExtGlob,
+  hasUnderscoreBelowContentDirectoryPath,
+  NoCollectionError
+} from "./utils.js";
 function astroContentVirtualModPlugin({
   settings
 }) {
   const contentPaths = getContentPaths(settings.config);
-  const relContentDir = normalizePath(
-    appendForwardSlash(
-      prependForwardSlash(
-        path.relative(settings.config.root.pathname, contentPaths.contentDir.pathname)
-      )
-    )
-  );
-  const contentEntryExts = getContentEntryExts(settings);
-  const extGlob = contentEntryExts.length === 1 ? (
-    // Wrapping {...} breaks when there is only one extension
-    contentEntryExts[0]
-  ) : `{${contentEntryExts.join(",")}}`;
+  const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
+  const contentEntryConfigByExt = getContentEntryConfigByExtMap(settings);
+  const contentEntryExts = [...contentEntryConfigByExt.keys()];
+  const extGlob = getExtGlob(contentEntryExts);
   const entryGlob = `${relContentDir}**/*${extGlob}`;
   const virtualModContents = fsMod.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("@@ENTRY_GLOB_PATH@@", entryGlob).replace("@@RENDER_ENTRY_GLOB_PATH@@", entryGlob);
   const astroContentVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
@@ -31,15 +32,71 @@ function astroContentVirtualModPlugin({
         return astroContentVirtualModuleId;
       }
     },
-    load(id) {
+    async load(id) {
+      const stringifiedLookupMap = await getStringifiedLookupMap({
+        fs: fsMod,
+        contentPaths,
+        contentEntryConfigByExt,
+        root: settings.config.root
+      });
       if (id === astroContentVirtualModuleId) {
         return {
-          code: virtualModContents
+          code: virtualModContents.replace(
+            "/* @@LOOKUP_MAP_ASSIGNMENT@@ */",
+            `lookupMap = ${stringifiedLookupMap};`
+          )
         };
       }
     }
   };
 }
+async function getStringifiedLookupMap({
+  contentPaths,
+  contentEntryConfigByExt,
+  root,
+  fs
+}) {
+  const { contentDir } = contentPaths;
+  const globOpts = {
+    absolute: true,
+    cwd: fileURLToPath(root),
+    fs: {
+      readdir: fs.readdir.bind(fs),
+      readdirSync: fs.readdirSync.bind(fs)
+    }
+  };
+  const relContentDir = rootRelativePath(root, contentDir, false);
+  const contentGlob = await glob(
+    `${relContentDir}**/*${getExtGlob([...contentEntryConfigByExt.keys()])}`,
+    globOpts
+  );
+  let filePathByLookupId = {};
+  await Promise.all(
+    contentGlob.filter((e) => !hasUnderscoreBelowContentDirectoryPath(pathToFileURL(e), contentDir)).map(async (filePath) => {
+      const info = getEntryInfo({ contentDir, entry: filePath });
+      if (info instanceof NoCollectionError)
+        return;
+      const contentEntryType = contentEntryConfigByExt.get(extname(filePath));
+      if (!contentEntryType)
+        return;
+      const { id, collection, slug: generatedSlug } = info;
+      const slug = await getEntrySlug({
+        id,
+        collection,
+        generatedSlug,
+        fs,
+        fileUrl: pathToFileURL(filePath),
+        contentEntryType
+      });
+      filePathByLookupId[collection] = {
+        ...filePathByLookupId[collection],
+        [slug]: rootRelativePath(root, filePath)
+      };
+    })
+  );
+  return JSON.stringify(filePathByLookupId);
+}
 export {
-  astroContentVirtualModPlugin
+  astroContentVirtualModPlugin,
+  getStringifiedLookupMap
 };

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.4.3";
+const ASTRO_VERSION = "2.4.5";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -53,7 +53,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.4.3";
+  const currentVersion = "2.4.5";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.4.3";
+  const version = "2.4.5";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.4.3"}`
+        `v${"2.4.5"}`
       )} ${headline}`
     );
   }

package/dist/core/util.d.ts

@@ -37,7 +37,7 @@ export declare function isPage(file: URL, settings: AstroSettings): boolean;
 export declare function isEndpoint(file: URL, settings: AstroSettings): boolean;
 export declare function isModeServerWithNoAdapter(settings: AstroSettings): boolean;
 export declare function relativeToSrcDir(config: AstroConfig, idOrUrl: URL | string): string;
-export declare function rootRelativePath(root: URL, idOrUrl: URL | string): string;
+export declare function rootRelativePath(root: URL, idOrUrl: URL | string, shouldPrependForwardSlash?: boolean): string;
 export declare function emoji(char: string, fallback: string): string;
 /**
  * Simulate Vite's resolve and import analysis so we can import the id as an URL

package/dist/core/util.js

@@ -114,7 +114,7 @@ function relativeToSrcDir(config, idOrUrl) {
   }
   return id.slice(slash(fileURLToPath(config.srcDir)).length);
 }
-function rootRelativePath(root, idOrUrl) {
+function rootRelativePath(root, idOrUrl, shouldPrependForwardSlash = true) {
   let id;
   if (typeof idOrUrl !== "string") {
     id = unwrapId(viteID(idOrUrl));
@@ -125,7 +125,7 @@ function rootRelativePath(root, idOrUrl) {
   if (id.startsWith(normalizedRoot)) {
     id = id.slice(normalizedRoot.length);
   }
-  return prependForwardSlash(id);
+  return shouldPrependForwardSlash ? prependForwardSlash(id) : id;
 }
 function emoji(char, fallback) {
   return process.platform !== "win32" ? char : fallback;

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

@@ -5,20 +5,22 @@ const getConfigAlias = (settings) => {
   if (!tsConfig || !tsConfigPath || !tsConfig.compilerOptions)
     return null;
   const { baseUrl, paths } = tsConfig.compilerOptions;
-  if (!baseUrl || !paths)
+  if (!baseUrl)
     return null;
   const resolvedBaseUrl = path.resolve(path.dirname(tsConfigPath), baseUrl);
   const aliases = [];
-  for (const [alias, values] of Object.entries(paths)) {
-    const find = new RegExp(
-      `^${[...alias].map(
-        (segment) => segment === "*" ? "(.+)" : segment.replace(/[\\^$*+?.()|[\]{}]/, "\\$&")
-      ).join("")}$`
-    );
-    let matchId = 0;
-    for (const value of values) {
-      const replacement = [...normalizePath(path.resolve(resolvedBaseUrl, value))].map((segment) => segment === "*" ? `$${++matchId}` : segment === "$" ? "$$" : segment).join("");
-      aliases.push({ find, replacement });
+  if (paths) {
+    for (const [alias, values] of Object.entries(paths)) {
+      const find = new RegExp(
+        `^${[...alias].map(
+          (segment) => segment === "*" ? "(.+)" : segment.replace(/[\\^$*+?.()|[\]{}]/, "\\$&")
+        ).join("")}$`
+      );
+      let matchId = 0;
+      for (const value of values) {
+        const replacement = [...normalizePath(path.resolve(resolvedBaseUrl, value))].map((segment) => segment === "*" ? `$${++matchId}` : segment === "$" ? "$$" : segment).join("");
+        aliases.push({ find, replacement });
+      }
     }
   }
   aliases.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",

package/src/content/template/virtual-mod.mjs

@@ -28,6 +28,18 @@ const collectionToEntryMap = createCollectionToGlobResultMap({
 	contentDir,
 });
 
+let lookupMap = {};
+/* @@LOOKUP_MAP_ASSIGNMENT@@ */
+
+function createGlobLookup(glob) {
+	return async (collection, lookupId) => {
+		const filePath = lookupMap[collection]?.[lookupId];
+
+		if (!filePath) return undefined;
+		return glob[collection][filePath];
+	};
+}
+
 const renderEntryGlob = import.meta.glob('@@RENDER_ENTRY_GLOB_PATH@@', {
 	query: { astroPropagatedAssets: true },
 });
@@ -38,10 +50,10 @@ const collectionToRenderEntryMap = createCollectionToGlobResultMap({
 
 export const getCollection = createGetCollection({
 	collectionToEntryMap,
-	collectionToRenderEntryMap,
+	getRenderEntryImport: createGlobLookup(collectionToRenderEntryMap),
 });
 
 export const getEntryBySlug = createGetEntryBySlug({
-	getCollection,
-	collectionToRenderEntryMap,
+	getEntryImport: createGlobLookup(collectionToEntryMap),
+	getRenderEntryImport: createGlobLookup(collectionToRenderEntryMap),
 });