@astrojs/markdown-remark 3.1.0 → 3.2.0

package/dist/frontmatter-injection.d.ts

@@ -3,6 +3,10 @@ import type { MarkdownAstroData } from './types.js';
 export declare class InvalidAstroDataError extends TypeError {
 }
 export declare function safelyGetAstroData(vfileData: Data): MarkdownAstroData | InvalidAstroDataError;
+export declare function setVfileFrontmatter(vfile: VFile, frontmatter: Record<string, any>): void;
+/**
+ * @deprecated Use `setVfileFrontmatter` instead
+ */
 export declare function toRemarkInitializeAstroData({ userFrontmatter, }: {
     userFrontmatter: Record<string, any>;
 }): () => (tree: any, vfile: VFile) => void;

package/dist/frontmatter-injection.js

@@ -19,6 +19,11 @@ function safelyGetAstroData(vfileData) {
   }
   return astro;
 }
+function setVfileFrontmatter(vfile, frontmatter) {
+  vfile.data ??= {};
+  vfile.data.astro ??= {};
+  vfile.data.astro.frontmatter = frontmatter;
+}
 function toRemarkInitializeAstroData({
   userFrontmatter
 }) {
@@ -31,5 +36,6 @@ function toRemarkInitializeAstroData({
 export {
   InvalidAstroDataError,
   safelyGetAstroData,
+  setVfileFrontmatter,
   toRemarkInitializeAstroData
 };

package/dist/index.d.ts

@@ -1,9 +1,18 @@
-import type { AstroMarkdownOptions, MarkdownRenderingOptions, MarkdownRenderingResult } from './types';
+import type { AstroMarkdownOptions, MarkdownProcessor, MarkdownRenderingOptions, MarkdownRenderingResult } from './types.js';
+export { InvalidAstroDataError, setVfileFrontmatter } from './frontmatter-injection.js';
 export { rehypeHeadingIds } from './rehype-collect-headings.js';
 export { remarkCollectImages } from './remark-collect-images.js';
 export { remarkPrism } from './remark-prism.js';
 export { remarkShiki } from './remark-shiki.js';
 export * from './types.js';
 export declare const markdownConfigDefaults: Omit<Required<AstroMarkdownOptions>, 'drafts'>;
-/** Shared utility for rendering markdown */
+/**
+ * Create a markdown preprocessor to render multiple markdown files
+ */
+export declare function createMarkdownProcessor(opts?: AstroMarkdownOptions): Promise<MarkdownProcessor>;
+/**
+ * Shared utility for rendering markdown
+ *
+ * @deprecated Use `createMarkdownProcessor` instead for better performance
+ */
 export declare function renderMarkdown(content: string, opts: MarkdownRenderingOptions): Promise<MarkdownRenderingResult>;

package/dist/index.js

@@ -1,4 +1,8 @@
-import { toRemarkInitializeAstroData } from "./frontmatter-injection.js";
+import {
+  InvalidAstroDataError,
+  safelyGetAstroData,
+  setVfileFrontmatter
+} from "./frontmatter-injection.js";
 import { loadPlugins } from "./load-plugins.js";
 import { rehypeHeadingIds } from "./rehype-collect-headings.js";
 import { remarkCollectImages } from "./remark-collect-images.js";
@@ -7,12 +11,13 @@ import { remarkShiki } from "./remark-shiki.js";
 import rehypeRaw from "rehype-raw";
 import rehypeStringify from "rehype-stringify";
 import remarkGfm from "remark-gfm";
-import markdown from "remark-parse";
-import markdownToHtml from "remark-rehype";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
 import remarkSmartypants from "remark-smartypants";
 import { unified } from "unified";
 import { VFile } from "vfile";
 import { rehypeImages } from "./rehype-images.js";
+import { InvalidAstroDataError as InvalidAstroDataError2, setVfileFrontmatter as setVfileFrontmatter2 } from "./frontmatter-injection.js";
 import { rehypeHeadingIds as rehypeHeadingIds2 } from "./rehype-collect-headings.js";
 import { remarkCollectImages as remarkCollectImages2 } from "./remark-collect-images.js";
 import { remarkPrism as remarkPrism2 } from "./remark-prism.js";
@@ -32,21 +37,20 @@ const markdownConfigDefaults = {
   smartypants: true
 };
 const isPerformanceBenchmark = Boolean(process.env.ASTRO_PERFORMANCE_BENCHMARK);
-async function renderMarkdown(content, opts) {
-  let {
-    fileURL,
+async function createMarkdownProcessor(opts) {
+  const {
     syntaxHighlight = markdownConfigDefaults.syntaxHighlight,
     shikiConfig = markdownConfigDefaults.shikiConfig,
     remarkPlugins = markdownConfigDefaults.remarkPlugins,
     rehypePlugins = markdownConfigDefaults.rehypePlugins,
-    remarkRehype = markdownConfigDefaults.remarkRehype,
+    remarkRehype: remarkRehypeOptions = markdownConfigDefaults.remarkRehype,
     gfm = markdownConfigDefaults.gfm,
-    smartypants = markdownConfigDefaults.smartypants,
-    frontmatter: userFrontmatter = {}
-  } = opts;
-  const input = new VFile({ value: content, path: fileURL });
-  let parser = unified().use(markdown).use(toRemarkInitializeAstroData({ userFrontmatter })).use([]);
-  if (!isPerformanceBenchmark && gfm) {
+    smartypants = markdownConfigDefaults.smartypants
+  } = opts ?? {};
+  const loadedRemarkPlugins = await Promise.all(loadPlugins(remarkPlugins));
+  const loadedRehypePlugins = await Promise.all(loadPlugins(rehypePlugins));
+  const parser = unified().use(remarkParse);
+  if (!isPerformanceBenchmark) {
     if (gfm) {
       parser.use(remarkGfm);
     }
@@ -54,11 +58,9 @@ async function renderMarkdown(content, opts) {
       parser.use(remarkSmartypants);
     }
   }
-  const loadedRemarkPlugins = await Promise.all(loadPlugins(remarkPlugins));
-  const loadedRehypePlugins = await Promise.all(loadPlugins(rehypePlugins));
-  loadedRemarkPlugins.forEach(([plugin, pluginOpts]) => {
-    parser.use([[plugin, pluginOpts]]);
-  });
+  for (const [plugin, pluginOpts] of loadedRemarkPlugins) {
+    parser.use(plugin, pluginOpts);
+  }
   if (!isPerformanceBenchmark) {
     if (syntaxHighlight === "shiki") {
       parser.use(remarkShiki, shikiConfig);
@@ -67,37 +69,61 @@ async function renderMarkdown(content, opts) {
     }
     parser.use(remarkCollectImages);
   }
-  parser.use([
-    [
-      markdownToHtml,
-      {
-        allowDangerousHtml: true,
-        passThrough: [],
-        ...remarkRehype
-      }
-    ]
-  ]);
-  loadedRehypePlugins.forEach(([plugin, pluginOpts]) => {
-    parser.use([[plugin, pluginOpts]]);
+  parser.use(remarkRehype, {
+    allowDangerousHtml: true,
+    passThrough: [],
+    ...remarkRehypeOptions
   });
+  for (const [plugin, pluginOpts] of loadedRehypePlugins) {
+    parser.use(plugin, pluginOpts);
+  }
   parser.use(rehypeImages());
   if (!isPerformanceBenchmark) {
-    parser.use([rehypeHeadingIds]);
+    parser.use(rehypeHeadingIds);
   }
-  parser.use([rehypeRaw]).use(rehypeStringify, { allowDangerousHtml: true });
-  let vfile;
-  try {
-    vfile = await parser.process(input);
-  } catch (err) {
-    err = prefixError(err, `Failed to parse Markdown file "${input.path}"`);
-    console.error(err);
-    throw err;
-  }
-  const headings = vfile?.data.__astroHeadings || [];
+  parser.use(rehypeRaw).use(rehypeStringify, { allowDangerousHtml: true });
+  return {
+    async render(content, renderOpts) {
+      const vfile = new VFile({ value: content, path: renderOpts?.fileURL });
+      setVfileFrontmatter(vfile, renderOpts?.frontmatter ?? {});
+      const result = await parser.process(vfile).catch((err) => {
+        err = prefixError(err, `Failed to parse Markdown file "${vfile.path}"`);
+        console.error(err);
+        throw err;
+      });
+      const astroData = safelyGetAstroData(result.data);
+      if (astroData instanceof InvalidAstroDataError) {
+        throw astroData;
+      }
+      return {
+        code: String(result.value),
+        metadata: {
+          headings: result.data.__astroHeadings ?? [],
+          imagePaths: result.data.imagePaths ?? /* @__PURE__ */ new Set(),
+          frontmatter: astroData.frontmatter ?? {}
+        },
+        // Compat for `renderMarkdown` only. Do not use!
+        __renderMarkdownCompat: {
+          result
+        }
+      };
+    }
+  };
+}
+async function renderMarkdown(content, opts) {
+  const processor = await createMarkdownProcessor(opts);
+  const result = await processor.render(content, {
+    fileURL: opts.fileURL,
+    frontmatter: opts.frontmatter
+  });
   return {
-    metadata: { headings, source: content, html: String(vfile.value) },
-    code: String(vfile.value),
-    vfile
+    code: result.code,
+    metadata: {
+      headings: result.metadata.headings,
+      source: content,
+      html: result.code
+    },
+    vfile: result.__renderMarkdownCompat.result
   };
 }
 function prefixError(err, prefix) {
@@ -118,10 +144,13 @@ ${err.message}`;
   return wrappedError;
 }
 export {
+  InvalidAstroDataError2 as InvalidAstroDataError,
+  createMarkdownProcessor,
   markdownConfigDefaults,
   rehypeHeadingIds2 as rehypeHeadingIds,
   remarkCollectImages2 as remarkCollectImages,
   remarkPrism2 as remarkPrism,
   remarkShiki2 as remarkShiki,
-  renderMarkdown
+  renderMarkdown,
+  setVfileFrontmatter2 as setVfileFrontmatter
 };

package/dist/load-plugins.js

@@ -9,7 +9,7 @@ async function importPlugin(p) {
       return importResult2.default;
     } catch {
     }
-    const resolved = await importMetaResolve(p, cwdUrlStr);
+    const resolved = importMetaResolve(p, cwdUrlStr);
     const importResult = await import(resolved);
     return importResult.default;
   }

package/dist/remark-collect-images.d.ts

@@ -1,2 +1,2 @@
-import type { MarkdownVFile } from './types';
+import type { MarkdownVFile } from './types.js';
 export declare function remarkCollectImages(): (tree: any, vfile: MarkdownVFile) => void;

package/dist/remark-collect-images.js

@@ -1,12 +1,23 @@
+import { definitions } from "mdast-util-definitions";
 import { visit } from "unist-util-visit";
 function remarkCollectImages() {
   return function(tree, vfile) {
     if (typeof vfile?.path !== "string")
       return;
+    const definition = definitions(tree);
     const imagePaths = /* @__PURE__ */ new Set();
-    visit(tree, "image", (node) => {
-      if (shouldOptimizeImage(node.url))
-        imagePaths.add(node.url);
+    visit(tree, ["image", "imageReference"], (node) => {
+      if (node.type === "image") {
+        if (shouldOptimizeImage(node.url))
+          imagePaths.add(node.url);
+      }
+      if (node.type === "imageReference") {
+        const imageDefinition = definition(node.identifier);
+        if (imageDefinition) {
+          if (shouldOptimizeImage(imageDefinition.url))
+            imagePaths.add(imageDefinition.url);
+        }
+      }
     });
     vfile.data.imagePaths = imagePaths;
   };

package/dist/types.d.ts

@@ -37,12 +37,25 @@ export interface ImageMetadata {
     height: number;
     type: string;
 }
-export interface MarkdownRenderingOptions extends AstroMarkdownOptions {
+export interface MarkdownProcessor {
+    render: (content: string, opts?: MarkdownProcessorRenderOptions) => Promise<MarkdownProcessorRenderResult>;
+}
+export interface MarkdownProcessorRenderOptions {
     /** @internal */
     fileURL?: URL;
     /** Used for frontmatter injection plugins */
     frontmatter?: Record<string, any>;
 }
+export interface MarkdownProcessorRenderResult {
+    code: string;
+    metadata: {
+        headings: MarkdownHeading[];
+        imagePaths: Set<string>;
+        frontmatter: Record<string, any>;
+    };
+}
+export interface MarkdownRenderingOptions extends AstroMarkdownOptions, MarkdownProcessorRenderOptions {
+}
 export interface MarkdownHeading {
     depth: number;
     slug: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/markdown-remark",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "type": "module",
   "author": "withastro",
   "license": "MIT",
@@ -20,12 +20,13 @@
     "dist"
   ],
   "peerDependencies": {
-    "astro": "^3.0.11"
+    "astro": "^3.1.0"
   },
   "dependencies": {
     "@astrojs/prism": "^3.0.0",
     "github-slugger": "^2.0.0",
     "import-meta-resolve": "^3.0.0",
+    "mdast-util-definitions": "^6.0.0",
     "rehype-raw": "^6.1.1",
     "rehype-stringify": "^9.0.4",
     "remark-gfm": "^3.0.1",