@astrojs/markdoc
This Astro integration enables the usage of Markdoc to create components, pages, and content collection entries.
Why Markdoc?
Section titled Why Markdoc?Markdoc allows you to enhance your Markdown with Astro components. If you have existing content authored in Markdoc, this integration allows you to bring those files to your Astro project using content collections.
Installation
Section titled InstallationQuick Install
Section titled Quick InstallThe astro add
command-line tool automates the installation for you. Run one of the following commands in a new terminal window. (If you aren’t sure which package manager you’re using, run the first command.) Then, follow the prompts, and type “y” in the terminal (meaning “yes”) for each one.
# Using NPM
npx astro add markdoc
# Using Yarn
yarn astro add markdoc
# Using PNPM
pnpm astro add markdoc
If you run into any issues, feel free to report them to us on GitHub and try the manual installation steps below.
Manual Install
Section titled Manual InstallFirst, install the @astrojs/markdoc
package using your package manager. If you’re using npm or aren’t sure, run this in the terminal:
npm install @astrojs/markdoc
Then, apply this integration to your astro.config.*
file using the integrations
property:
import { defineConfig } from 'astro/config';
import markdoc from '@astrojs/markdoc';
export default defineConfig({
// ...
integrations: [markdoc()],
});
Editor Integration
Section titled Editor IntegrationVS Code supports Markdown by default. However, for Markdoc editor support, you may wish to add the following setting in your VSCode config. This ensures authoring Markdoc files provides a Markdown-like editor experience.
"files.associations": {
"*.mdoc": "markdown"
}
Usage
Section titled UsageMarkdoc files can only be used within content collections. Add entries to any content collection using the .mdoc
extension:
src/content/docs/
why-markdoc.mdoc
quick-start.mdoc
Then, query your collection using the Content Collection APIs:
---
import { getEntryBySlug } from 'astro:content';
const entry = await getEntryBySlug('docs', 'why-markdoc');
const { Content } = await entry.render();
---
<!--Access frontmatter properties with `data`-->
<h1>{entry.data.title}</h1>
<!--Render Markdoc contents with the Content component-->
<Content />
📚 See the Astro Content Collection docs for more information.
Configuration
Section titled Configuration@astrojs/markdoc
offers configuration options to use all of Markdoc’s features and connect UI components to your content.
Using components
Section titled Using componentsYou can add Astro and UI framework components (React, Vue, Svelte, etc.) to your Markdoc using both Markdoc tags and HTML element nodes.
Render Markdoc tags as Astro components
Section titled Render Markdoc tags as Astro componentsYou may configure Markdoc tags that map to components. You can configure a new tag from your astro.config
using the tags
attribute.
import { defineConfig } from 'astro/config';
import markdoc from '@astrojs/markdoc';
// https://astro.build/config
export default defineConfig({
integrations: [
markdoc({
tags: {
aside: {
render: 'Aside',
attributes: {
// Component props as attribute definitions
// See Markdoc's documentation on defining attributes
// https://markdoc.dev/docs/attributes#defining-attributes
type: { type: String },
}
},
},
}),
],
});
Then, you can wire this render name ('Aside'
) to a component from the components
prop via the <Content />
component. Note the object key name (Aside
in this case) should match the render name:
---
import { getEntryBySlug } from 'astro:content';
import Aside from '../components/Aside.astro';
const entry = await getEntryBySlug('docs', 'why-markdoc');
const { Content } = await entry.render();
---
<Content
components={{ Aside }}
/>
Render Markdoc nodes / HTML elements as Astro components
Section titled Render Markdoc nodes / HTML elements as Astro componentsYou may also want to map standard HTML elements like headings and paragraphs to components. For this, you can configure a custom Markdoc node. This example overrides Markdoc’s heading
node to render a Heading
component, passing the built-in level
attribute as a prop:
import { defineConfig } from 'astro/config';
import markdoc from '@astrojs/markdoc';
// https://astro.build/config
export default defineConfig({
integrations: [
markdoc({
nodes: {
heading: {
render: 'Heading',
// Markdoc requires type defs for each attribute.
// These should mirror the `Props` type of the component
// you are rendering.
// See Markdoc's documentation on defining attributes
// https://markdoc.dev/docs/attributes#defining-attributes
attributes: {
level: { type: String },
}
},
},
}),
],
});
Now, you can map the string passed to render ('Heading'
in this example) to a component import. This is configured from the <Content />
component used to render your Markdoc using the components
prop:
---
import { getEntryBySlug } from 'astro:content';
import Heading from '../components/Heading.astro';
const entry = await getEntryBySlug('docs', 'why-markdoc');
const { Content } = await entry.render();
---
<Content
components={{ Heading }}
/>
Now, all Markdown headings will render with the Heading.astro
component. This example uses a level 3 heading, automatically passing level: 3
as the component prop:
### I'm a level 3 heading!
📚 Find all of Markdoc’s built-in nodes and node attributes on their documentation.
Use client-side UI components
Section titled Use client-side UI componentsToday, the components
prop does not support the client:
directive for hydrating components. To embed client-side components, create a wrapper .astro
file to import your component and apply a client:
directive manually.
This example wraps a Aside.tsx
component with a ClientAside.astro
wrapper:
---
import Aside from './Aside';
---
<Aside client:load />
This component can be applied via the components
prop:
---
import { getEntryBySlug } from 'astro:content';
import ClientAside from '../components/ClientAside.astro';
const entry = await getEntryBySlug('docs', 'why-markdoc');
const { Content } = await entry.render();
---
<Content
components={{
Aside: ClientAside,
}}
/>
Access frontmatter and content collection information from your templates
Section titled Access frontmatter and content collection information from your templatesYou can access content collection information from your Markdoc templates using the $entry
variable. This includes the entry slug
, collection
name, and frontmatter data
parsed by your content collection schema (if any). This example renders the title
frontmatter property as a heading:
---
title: Welcome to Markdoc 👋
---
# {% $entry.data.title %}
The $entry
object matches the CollectionEntry
type, excluding the .render()
property.
Markdoc config
Section titled Markdoc configThe Markdoc integration accepts all Markdoc configuration options, including tags and functions.
You can pass these options from the markdoc()
integration in your astro.config
. This example adds a global getCountryEmoji
function:
import { defineConfig } from 'astro/config';
import markdoc from '@astrojs/markdoc';
// https://astro.build/config
export default defineConfig({
integrations: [
markdoc({
functions: {
getCountryEmoji: {
transform(parameters) {
const [country] = Object.values(parameters);
const countryToEmojiMap = {
japan: '🇯🇵',
spain: '🇪🇸',
france: '🇫🇷',
}
return countryToEmojiMap[country] ?? '🏳'
},
},
},
}),
],
});
Now, you can call this function from any Markdoc content entry:
¡Hola {% getCountryEmoji("spain") %}!
📚 See the Markdoc documentation for more on using variables or functions in your content.
Define Markdoc configuration at runtime
Section titled Define Markdoc configuration at runtimeYou may need to define Markdoc configuration at the component level, rather than the astro.config.mjs
level. This is useful when mapping props and SSR parameters to Markdoc variables.
Astro recommends running the Markdoc transform step manually. This allows you to define your configuration and call Markdoc’s rendering functions in a .astro
file directly, ignoring any Markdoc config in your astro.config.mjs
.
You will need to install the @markdoc/markdoc
package into your project first:
# Using NPM
npm install @markdoc/markdoc
# Using Yarn
yarn add @markdoc/markdoc
# Using PNPM
pnpm add @markdoc/markdoc
Now, you can define Markdoc configuration options using Markdock.transform()
.
This example defines an abTestGroup
Markdoc variable based on an SSR param, transforming the raw entry body
. The result is rendered using the Renderer
component provided by @astrojs/markdoc
:
---
import Markdoc from '@markdoc/markdoc';
import { Renderer } from '@astrojs/markdoc/components';
import { getEntryBySlug } from 'astro:content';
const { body } = await getEntryBySlug('docs', 'with-ab-test');
const ast = Markdoc.parse(body);
const content = Markdoc.transform({
variables: { abTestGroup: Astro.params.abTestGroup },
}, ast);
---
<Renderer {content} components={{ /* same `components` prop used by the `Content` component */ }} />
Examples
Section titled Examples- The Astro Markdoc starter template shows how to use Markdoc files in your Astro project.
Troubleshooting
Section titled TroubleshootingFor help, check out the #support
channel on Discord. Our friendly Support Squad members are here to help!
You can also check our Astro Integration Documentation for more on integrations.
Contributing
Section titled ContributingThis package is maintained by Astro’s Core team. You’re welcome to submit an issue or PR!
Changelog
Section titled ChangelogSee CHANGELOG.md for a history of changes to this integration.