astro 2.1.4 → 2.1.5

package/dist/@types/astro.d.ts

@@ -5,6 +5,7 @@ import type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, Rehype
 import type * as babel from '@babel/core';
 import type { OutgoingHttpHeaders } from 'http';
 import type { AddressInfo } from 'net';
+import type * as rollup from 'rollup';
 import type { TsConfigJson } from 'tsconfig-resolver';
 import type * as vite from 'vite';
 import type { z } from 'zod';
@@ -956,12 +957,26 @@ export interface InjectedRoute {
 export interface AstroConfig extends z.output<typeof AstroConfigSchema> {
     integrations: AstroIntegration[];
 }
+export type ContentEntryModule = {
+    id: string;
+    collection: string;
+    slug: string;
+    body: string;
+    data: Record<string, unknown>;
+    _internal: {
+        rawData: string;
+        filePath: string;
+    };
+};
 export interface ContentEntryType {
     extensions: string[];
     getEntryInfo(params: {
         fileUrl: URL;
         contents: string;
     }): GetEntryInfoReturnType | Promise<GetEntryInfoReturnType>;
+    getRenderModule?(params: {
+        entry: ContentEntryModule;
+    }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
 }
 type GetEntryInfoReturnType = {

package/dist/content/vite-plugin-content-imports.d.ts

@@ -5,4 +5,4 @@ import type { AstroSettings } from '../@types/astro.js';
 export declare function astroContentImportPlugin({ fs, settings, }: {
     fs: typeof fsMod;
     settings: AstroSettings;
-}): Plugin;
+}): Plugin[];

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

@@ -13,12 +13,25 @@ import {
   getEntrySlug,
   getEntryType,
   globalContentConfigObserver,
+  NoCollectionError,
   patchAssets
 } from "./utils.js";
 function isContentFlagImport(viteId, contentEntryExts) {
   const { searchParams, pathname } = new URL(viteId, "file://");
   return searchParams.has(CONTENT_FLAG) && contentEntryExts.some((ext) => pathname.endsWith(ext));
 }
+function getContentRendererByViteId(viteId, settings) {
+  let ext = viteId.split(".").pop();
+  if (!ext)
+    return void 0;
+  for (const contentEntryType of settings.contentEntryTypes) {
+    if (Boolean(contentEntryType.getRenderModule) && contentEntryType.extensions.includes("." + ext)) {
+      return contentEntryType.getRenderModule;
+    }
+  }
+  return void 0;
+}
+const CHOKIDAR_MODIFIED_EVENTS = ["add", "unlink", "change"];
 function astroContentImportPlugin({
   fs,
   settings
@@ -31,98 +44,171 @@ function astroContentImportPlugin({
       contentEntryExtToParser.set(ext, entryType);
     }
   }
-  return {
-    name: "astro:content-imports",
-    async load(id) {
-      const { fileId } = getFileInfo(id, settings.config);
-      if (isContentFlagImport(id, contentEntryExts)) {
-        const observable = globalContentConfigObserver.get();
-        if (observable.status === "init") {
-          throw new AstroError({
-            ...AstroErrorData.UnknownContentCollectionError,
-            message: "Content config failed to load."
-          });
-        }
-        if (observable.status === "error") {
-          throw observable.error;
-        }
-        let contentConfig = observable.status === "loaded" ? observable.config : void 0;
-        if (observable.status === "loading") {
-          contentConfig = await new Promise((resolve) => {
-            const unsubscribe = globalContentConfigObserver.subscribe((ctx) => {
-              if (ctx.status === "loaded") {
-                resolve(ctx.config);
-                unsubscribe();
-              } else if (ctx.status === "error") {
-                resolve(void 0);
-                unsubscribe();
-              }
-            });
-          });
-        }
-        const rawContents = await fs.promises.readFile(fileId, "utf-8");
-        const fileExt = extname(fileId);
-        if (!contentEntryExtToParser.has(fileExt)) {
-          throw new AstroError({
-            ...AstroErrorData.UnknownContentCollectionError,
-            message: `No parser found for content entry ${JSON.stringify(
-              fileId
-            )}. Did you apply an integration for this file type?`
+  const plugins = [
+    {
+      name: "astro:content-imports",
+      async load(viteId) {
+        if (isContentFlagImport(viteId, contentEntryExts)) {
+          const { fileId } = getFileInfo(viteId, settings.config);
+          const { id, slug, collection, body, data, _internal } = await setContentEntryModuleCache({
+            fileId,
+            pluginContext: this
           });
-        }
-        const contentEntryParser = contentEntryExtToParser.get(fileExt);
-        const info = await contentEntryParser.getEntryInfo({
-          fileUrl: pathToFileURL(fileId),
-          contents: rawContents
-        });
-        const generatedInfo = getEntryInfo({
-          entry: pathToFileURL(fileId),
-          contentDir: contentPaths.contentDir
-        });
-        if (generatedInfo instanceof Error)
-          return;
-        const _internal = { filePath: fileId, rawData: info.rawData };
-        const slug = getEntrySlug({ ...generatedInfo, unvalidatedSlug: info.slug });
-        const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[generatedInfo.collection];
-        let data = collectionConfig ? await getEntryData(
-          { ...generatedInfo, _internal, unvalidatedData: info.data },
-          collectionConfig
-        ) : info.data;
-        await patchAssets(data, this.meta.watchMode, this.emitFile, settings);
-        const code = escapeViteEnvReferences(`
-export const id = ${JSON.stringify(generatedInfo.id)};
-export const collection = ${JSON.stringify(generatedInfo.collection)};
+          const code = escapeViteEnvReferences(`
+export const id = ${JSON.stringify(id)};
+export const collection = ${JSON.stringify(collection)};
 export const slug = ${JSON.stringify(slug)};
-export const body = ${JSON.stringify(info.body)};
+export const body = ${JSON.stringify(body)};
 export const data = ${devalue.uneval(data)};
 export const _internal = {
 	filePath: ${JSON.stringify(_internal.filePath)},
 	rawData: ${JSON.stringify(_internal.rawData)},
 };
 `);
-        return { code };
-      }
-    },
-    configureServer(viteServer) {
-      viteServer.watcher.on("all", async (event, entry) => {
-        if (["add", "unlink", "change"].includes(event) && getEntryType(entry, contentPaths, contentEntryExts) === "config") {
-          for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
-            if (isContentFlagImport(modUrl, contentEntryExts)) {
-              const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
-              if (mod) {
-                viteServer.moduleGraph.invalidateModule(mod);
+          return { code };
+        }
+      },
+      configureServer(viteServer) {
+        viteServer.watcher.on("all", async (event, entry) => {
+          if (CHOKIDAR_MODIFIED_EVENTS.includes(event) && getEntryType(entry, contentPaths, contentEntryExts) === "config") {
+            for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
+              if (isContentFlagImport(modUrl, contentEntryExts) || Boolean(getContentRendererByViteId(modUrl, settings))) {
+                const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
+                if (mod) {
+                  viteServer.moduleGraph.invalidateModule(mod);
+                }
               }
             }
           }
+        });
+      },
+      async transform(code, id) {
+        if (isContentFlagImport(id, contentEntryExts)) {
+          return { code: escapeViteEnvReferences(code) };
+        }
+      }
+    }
+  ];
+  if (settings.contentEntryTypes.some((t) => t.getRenderModule)) {
+    plugins.push({
+      name: "astro:content-render-imports",
+      async load(viteId) {
+        const contentRenderer = getContentRendererByViteId(viteId, settings);
+        if (!contentRenderer)
+          return;
+        const { fileId } = getFileInfo(viteId, settings.config);
+        const entry = await getContentEntryModuleFromCache(fileId);
+        if (!entry) {
+          throw new AstroError({
+            ...AstroErrorData.UnknownContentCollectionError,
+            message: `Unable to render ${JSON.stringify(
+              fileId
+            )}. Did you import this module directly without using a content collection query?`
+          });
         }
+        return contentRenderer({ entry });
+      }
+    });
+  }
+  const contentEntryModuleByIdCache = /* @__PURE__ */ new Map();
+  function isAwaitingQueue(cacheEntry) {
+    return typeof cacheEntry === "object" && cacheEntry != null && "awaitingQueue" in cacheEntry;
+  }
+  function getContentEntryModuleFromCache(id) {
+    const cacheEntry = contentEntryModuleByIdCache.get(id);
+    if (isAwaitingQueue(cacheEntry)) {
+      return new Promise((resolve, reject) => {
+        cacheEntry.awaitingQueue.push(resolve);
+      });
+    } else if (cacheEntry) {
+      return Promise.resolve(cacheEntry);
+    }
+    return Promise.resolve(void 0);
+  }
+  async function setContentEntryModuleCache({
+    fileId,
+    pluginContext
+  }) {
+    contentEntryModuleByIdCache.set(fileId, { awaitingQueue: [] });
+    const contentConfig = await getContentConfigFromGlobal();
+    const rawContents = await fs.promises.readFile(fileId, "utf-8");
+    const fileExt = extname(fileId);
+    if (!contentEntryExtToParser.has(fileExt)) {
+      throw new AstroError({
+        ...AstroErrorData.UnknownContentCollectionError,
+        message: `No parser found for content entry ${JSON.stringify(
+          fileId
+        )}. Did you apply an integration for this file type?`
       });
-    },
-    async transform(code, id) {
-      if (isContentFlagImport(id, contentEntryExts)) {
-        return { code: escapeViteEnvReferences(code) };
+    }
+    const contentEntryParser = contentEntryExtToParser.get(fileExt);
+    const {
+      rawData,
+      body,
+      slug: unvalidatedSlug,
+      data: unvalidatedData
+    } = await contentEntryParser.getEntryInfo({
+      fileUrl: pathToFileURL(fileId),
+      contents: rawContents
+    });
+    const entryInfoResult = getEntryInfo({
+      entry: pathToFileURL(fileId),
+      contentDir: contentPaths.contentDir
+    });
+    if (entryInfoResult instanceof NoCollectionError)
+      throw entryInfoResult;
+    const { id, slug: generatedSlug, collection } = entryInfoResult;
+    const _internal = { filePath: fileId, rawData };
+    const slug = getEntrySlug({ id, collection, slug: generatedSlug, unvalidatedSlug });
+    const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
+    let data = collectionConfig ? await getEntryData({ id, collection, slug, _internal, unvalidatedData }, collectionConfig) : unvalidatedData;
+    await patchAssets(data, pluginContext.meta.watchMode, pluginContext.emitFile, settings);
+    const contentEntryModule = {
+      id,
+      slug,
+      collection,
+      data,
+      body,
+      _internal
+    };
+    const cacheEntry = contentEntryModuleByIdCache.get(fileId);
+    if (isAwaitingQueue(cacheEntry)) {
+      for (const resolve of cacheEntry.awaitingQueue) {
+        resolve(contentEntryModule);
       }
     }
-  };
+    contentEntryModuleByIdCache.set(fileId, contentEntryModule);
+    return contentEntryModule;
+  }
+  return plugins;
+}
+async function getContentConfigFromGlobal() {
+  const observable = globalContentConfigObserver.get();
+  if (observable.status === "init") {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: "Content config failed to load."
+    });
+  }
+  if (observable.status === "error") {
+    throw observable.error;
+  }
+  let contentConfig = observable.status === "loaded" ? observable.config : void 0;
+  if (observable.status === "loading") {
+    contentConfig = await new Promise((resolve) => {
+      const unsubscribe = globalContentConfigObserver.subscribe((ctx) => {
+        if (ctx.status === "loaded") {
+          resolve(ctx.config);
+          unsubscribe();
+        }
+        if (ctx.status === "error") {
+          resolve(void 0);
+          unsubscribe();
+        }
+      });
+    });
+  }
+  return contentConfig;
 }
 export {
   astroContentImportPlugin

package/dist/core/constants.js

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

package/dist/core/dev/dev.js

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

package/dist/core/errors/dev/vite.js

@@ -72,6 +72,7 @@ function enhanceViteSSRError({
   return safeError;
 }
 const ALTERNATIVE_JS_EXTS = ["cjs", "mjs"];
+const ALTERNATIVE_MD_EXTS = ["mdoc"];
 async function getViteErrorPayload(err) {
   var _a, _b, _c, _d, _e, _f;
   let plugin = err.plugin;
@@ -93,6 +94,9 @@ async function getViteErrorPayload(err) {
   if (ALTERNATIVE_JS_EXTS.includes(highlighterLang ?? "")) {
     highlighterLang = "js";
   }
+  if (ALTERNATIVE_MD_EXTS.includes(highlighterLang ?? "")) {
+    highlighterLang = "md";
+  }
   const highlightedCode = err.fullCode ? highlighter.codeToHtml(err.fullCode, {
     lang: highlighterLang,
     lineOptions: ((_c = err.loc) == null ? void 0 : _c.line) ? [{ line: err.loc.line, classes: ["error-line"] }] : void 0

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.1.4";
+  const version = "2.1.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.1.4"}`
+        `v${"2.1.5"}`
       )} ${headline}`
     );
   }

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

@@ -1,4 +1,3 @@
-import fs from "fs";
 import path from "path";
 import slash from "slash";
 const getConfigAlias = (paths, baseUrl) => {
@@ -43,13 +42,14 @@ function configAliasVitePlugin({
         };
       }
     },
-    resolveId(id) {
-      if (id.startsWith(".") || id.startsWith("/"))
+    async resolveId(id, importer, options) {
+      if (id.startsWith(".") || path.isAbsolute(id))
         return;
       const resolved = path.posix.join(resolvedBaseUrl, id);
-      if (fs.existsSync(resolved)) {
-        return resolved;
-      }
+      return await this.resolve(resolved, importer, {
+        skipSelf: true,
+        ...options
+      });
     }
   };
 }

package/dist/vite-plugin-markdown/index.js

@@ -5,12 +5,8 @@ import {
 } from "@astrojs/markdown-remark/dist/internal.js";
 import fs from "fs";
 import matter from "gray-matter";
-import npath from "node:path";
 import { fileURLToPath } from "node:url";
-import { pathToFileURL } from "url";
 import { normalizePath } from "vite";
-import { imageMetadata } from "../assets/index.js";
-import imageSize from "../assets/vendor/image-size/index.js";
 import { AstroError, AstroErrorData, MarkdownError } from "../core/errors/index.js";
 import { warn } from "../core/logger/core.js";
 import { isMarkdownFile } from "../core/util.js";
@@ -42,26 +38,10 @@ function safeMatter(source, id) {
 const astroJsxRuntimeModulePath = normalizePath(
   fileURLToPath(new URL("../jsx-runtime/index.js", import.meta.url))
 );
+const astroServerRuntimeModulePath = normalizePath(
+  fileURLToPath(new URL("../runtime/server/index.js", import.meta.url))
+);
 function markdown({ settings, logging }) {
-  const markdownAssetMap = /* @__PURE__ */ new Map();
-  let imageService = void 0;
-  async function resolveImage(fileId, path) {
-    const resolved = await this.resolve(path, fileId);
-    if (!resolved)
-      return path;
-    const rel = npath.relative(normalizePath(fileURLToPath(settings.config.root)), resolved.id);
-    const buffer = await fs.promises.readFile(resolved.id);
-    if (markdownAssetMap.has(resolved.id)) {
-      return `ASTRO_ASSET_MD_${markdownAssetMap.get(resolved.id)}`;
-    }
-    const file = this.emitFile({
-      type: "asset",
-      name: rel,
-      source: buffer
-    });
-    markdownAssetMap.set(resolved.id, file);
-    return `ASTRO_ASSET_MD_${file}`;
-  }
   return {
     enforce: "pre",
     name: "astro:markdown",
@@ -74,20 +54,12 @@ function markdown({ settings, logging }) {
         const { fileId, fileUrl } = getFileInfo(id, settings.config);
         const rawFile = await fs.promises.readFile(fileId, "utf-8");
         const raw = safeMatter(rawFile, id);
-        if (settings.config.experimental.assets) {
-          imageService = (await import(settings.config.image.service)).default;
-        }
         const renderResult = await renderMarkdown(raw.content, {
           ...settings.config.markdown,
           fileURL: new URL(`file://${fileId}`),
           frontmatter: raw.data,
-          experimentalAssets: settings.config.experimental.assets,
-          imageService,
-          assetsDir: new URL("./assets/", settings.config.srcDir),
-          resolveImage: this.meta.watchMode ? void 0 : resolveImage.bind(this, fileId),
-          getImageMetadata: imageSize
+          experimentalAssets: settings.config.experimental.assets
         });
-        this;
         let html = renderResult.code;
         const { headings } = renderResult.metadata;
         let imagePaths = [];
@@ -96,7 +68,10 @@ function markdown({ settings, logging }) {
           imagePaths = await Promise.all(
             paths.map(async (imagePath) => {
               var _a;
-              return ((_a = await this.resolve(imagePath)) == null ? void 0 : _a.id) ?? imagePath;
+              return {
+                raw: imagePath,
+                absolute: ((_a = await this.resolve(imagePath, id)) == null ? void 0 : _a.id) ?? imagePath
+              };
             })
           );
         }
@@ -115,14 +90,25 @@ function markdown({ settings, logging }) {
         }
         const code = escapeViteEnvReferences(`
 				import { Fragment, jsx as h } from ${JSON.stringify(astroJsxRuntimeModulePath)};
+				import { spreadAttributes } from ${JSON.stringify(astroServerRuntimeModulePath)};
+
 				${layout ? `import Layout from ${JSON.stringify(layout)};` : ""}
-				${settings.config.experimental.assets ? 'import { getConfiguredImageService } from "astro:assets";\ngetConfiguredImageService();' : ""}
+				${settings.config.experimental.assets ? 'import { getImage } from "astro:assets";' : ""}
 
-				const images = {
-					${imagePaths.map((entry) => `'${entry}': await import('${entry}')`)}
+				export const images = {
+					${imagePaths.map(
+          (entry) => `'${entry.raw}': await getImage({src: (await import("${entry.absolute}")).default})`
+        )}
 				}
 
-				const html = ${JSON.stringify(html)};
+				function updateImageReferences(html) {
+					return html.replaceAll(
+						/__ASTRO_IMAGE_="(.+)"/gm,
+						(full, imagePath) => spreadAttributes({src: images[imagePath].src, ...images[imagePath].attributes})
+					);
+				}
+
+				const html = updateImageReferences(${JSON.stringify(html)});
 
 				export const frontmatter = ${JSON.stringify(frontmatter)};
 				export const file = ${JSON.stringify(fileId)};
@@ -172,31 +158,6 @@ function markdown({ settings, logging }) {
           }
         };
       }
-    },
-    async generateBundle(_opts, bundle) {
-      for (const [, output] of Object.entries(bundle)) {
-        if (output.type === "asset")
-          continue;
-        if (markdownAssetMap.size) {
-          const optimizedPaths = /* @__PURE__ */ new Map();
-          for (const [filename, hash] of markdownAssetMap) {
-            const image = await imageMetadata(pathToFileURL(filename));
-            if (!image) {
-              continue;
-            }
-            const fileName = this.getFileName(hash);
-            image.src = npath.join(settings.config.base, fileName);
-            const options = { src: image };
-            const validatedOptions = (imageService == null ? void 0 : imageService.validateOptions) ? imageService.validateOptions(options) : options;
-            const optimized = globalThis.astroAsset.addStaticImage(validatedOptions);
-            optimizedPaths.set(hash, optimized);
-          }
-          output.code = output.code.replaceAll(/ASTRO_ASSET_MD_([0-9a-z]{8})/gm, (_str, hash) => {
-            const optimizedName = optimizedPaths.get(hash);
-            return optimizedName || this.getFileName(hash);
-          });
-        }
-      }
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -95,7 +95,7 @@
   "dependencies": {
     "@astrojs/compiler": "^1.2.0",
     "@astrojs/language-server": "^0.28.3",
-    "@astrojs/markdown-remark": "^2.1.1",
+    "@astrojs/markdown-remark": "^2.1.2",
     "@astrojs/telemetry": "^2.1.0",
     "@astrojs/webapi": "^2.1.0",
     "@babel/core": "^7.18.2",