`
${children}
`,
})}
/>
```
`.value` is the rendered HTML string, while `String()` / `.toString()` give back the raw Markdown source:
```astro
myMarkdownContent.value // "
…
"
String(myMarkdownContent) // "# …"
myMarkdownContent.toString() // "# …"
```
And you can access your markdown metadata like :
```astro
myMarkdownContent.metadata
myMarkdownContent.metadata.title
```
### 2. Helper Utilities (Markdown Strings Only)
These utilities render **raw Markdown strings** and are independent of `useIntlayer`. Use them when you need to render Markdown from sources other than your dictionaries.
#### `` Component
Render a Markdown string with specific options.
```tsx
import { MarkdownRenderer } from "react-intlayer/markdown";
{"# My Title"}
```
#### `useMarkdownRenderer()` Hook
Get a pre-configured renderer function.
```tsx
import { useMarkdownRenderer } from "react-intlayer/markdown";
const renderMarkdown = useMarkdownRenderer({
forceBlock: true,
components: { h1: (props) => }
});
return renderMarkdown("# My Title");
```
#### `renderMarkdown()` Utility
Standalone utility for rendering outside of components.
```tsx
import { renderMarkdown } from "react-intlayer/markdown";
const jsx = renderMarkdown("# My Title", { forceBlock: true });
```
#### `` Component
Render a Markdown string with specific options.
```tsx
import { MarkdownRenderer } from "next-intlayer/markdown";
{"# My Title"}
```
#### `useMarkdownRenderer()` Hook
Get a pre-configured renderer function.
```tsx
import { useMarkdownRenderer } from "next-intlayer/markdown";
const renderMarkdown = useMarkdownRenderer({
forceBlock: true,
components: { h1: (props) => }
});
return renderMarkdown("# My Title");
```
#### `renderMarkdown()` Utility
Standalone utility for rendering outside of components.
```tsx
import { renderMarkdown } from "next-intlayer/markdown";
const jsx = renderMarkdown("# My Title", { forceBlock: true });
```
#### `` Component
```vue
```
#### `` Component
```svelte
```
#### `useMarkdownRenderer()` Hook
```svelte
{@html render("# My Title")}
```
#### `renderMarkdown()` Utility
```svelte
{@html renderMarkdown("# My Title")}
```
#### `` Component
```tsx
import { MarkdownRenderer } from "preact-intlayer/markdown";
{"# My Title"}
```
#### `useMarkdownRenderer()` Hook
```tsx
import { useMarkdownRenderer } from "preact-intlayer/markdown";
const render = useMarkdownRenderer();
return {render("# My Title")}
;
```
#### `renderMarkdown()` Utility
```tsx
import { renderMarkdown } from "preact-intlayer/markdown";
return {renderMarkdown("# My Title")}
;
```
#### `` Component
```tsx
import { MarkdownRenderer } from "solid-intlayer/markdown";
{"# My Title"}
```
#### `useMarkdownRenderer()` Hook
```tsx
import { useMarkdownRenderer } from "solid-intlayer/markdown";
const render = useMarkdownRenderer();
return {render("# My Title")}
;
```
#### `renderMarkdown()` Utility
```tsx
import { renderMarkdown } from "solid-intlayer/markdown";
return {renderMarkdown("# My Title")}
;
```
#### `IntlayerMarkdownService` Service
Render a Markdown string using the service.
```typescript
import { IntlayerMarkdownService } from "angular-intlayer/markdown";
export class MyComponent {
constructor(private markdownService: IntlayerMarkdownService) {}
renderMarkdown(markdown: string) {
return this.markdownService.renderMarkdown(markdown);
}
}
```
#### `useMarkdownRenderer()` Hook
Get a renderer function pre-configured by `installIntlayerMarkdown()`. It returns an HTML string.
```tsx
import { useMarkdownRenderer } from "remix-intlayer/markdown";
const renderMarkdown = useMarkdownRenderer({ forceBlock: true });
return ;
```
#### `renderMarkdown()` Utility
Standalone utility that ignores the global configuration.
```tsx
import { renderMarkdown } from "remix-intlayer/markdown";
const html = renderMarkdown("# My Title", { forceBlock: true });
```
#### `useMarkdownRenderer()` Hook
Get a renderer function pre-configured by `installIntlayerMarkdown()`. It returns an HTML string.
```astro
---
import { useMarkdownRenderer } from "astro-intlayer/markdown";
const renderMarkdown = useMarkdownRenderer({ forceBlock: true });
---
```
#### `renderMarkdown()` Utility
Standalone utility that ignores the global configuration.
```astro
---
import { renderMarkdown } from "astro-intlayer/markdown";
const html = renderMarkdown("# My Title", { forceBlock: true });
---
```
## Global Configuration with `MarkdownProvider`
`MarkdownProvider` (or its framework equivalent) configures the Markdown rendering pipeline for your entire application. It applies to both the automatic `useIntlayer` rendering and the helper utilities. Options set here are the defaults, `.use()` overrides them at the node level.
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "react-intlayer/markdown";
export const AppProvider = ({ children }) => (
,
a: ({ href, ...props }) => ,
MyCustomJSXComponent: (props) => ,
}}
>
{children}
);
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "react-intlayer/markdown";
export const AppProvider = ({ children }) => (
{
// Use dynamic import to reduce the bundle size of your application
const { renderMarkdown } = await import('react-intlayer/markdown');
return renderMarkdown(md);
}}
>
{children}
);
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "next-intlayer/markdown";
export const AppProvider = ({ children }) => (
,
a: ({ href, ...props }) => ,
MyCustomJSXComponent: (props) => ,
}}
>
{children}
);
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "next-intlayer/markdown";
export const AppProvider = ({ children }) => (
{
// Use dynamic import to reduce the bundle size of your application
const { renderMarkdown } = await import('next-intlayer/markdown');
return renderMarkdown(md);
}}
>
{children}
);
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
```typescript fileName="main.ts"
import { createApp } from "vue";
import { intlayer } from "vue-intlayer";
import { intlayerMarkdown } from "vue-intlayer/markdown";
import App from "./App.vue";
const app = createApp(App);
app.use(intlayer);
app.use(intlayerMarkdown, {
components: {
h1: (props) =>
h('h1', { style: { color: 'orange' }, ...props }, props.children),
ComponentDemo: () => h('div', { style: { background: 'grey' } }, 'DEMO'),
bold: (props) => h('strong', props),
code: (props) => h('code', props),
},
});
app.mount("#app");
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```typescript fileName="main.ts"
import { createApp } from "vue";
import { intlayer } from "vue-intlayer";
import { intlayerMarkdown } from "vue-intlayer/markdown";
import App from "./App.vue";
const app = createApp(App);
app.use(intlayer);
app.use(intlayerMarkdown, {
renderMarkdown: async (md) => {
const { renderMarkdown } = await import('vue-intlayer/markdown');
return renderMarkdown(md);
},
});
app.mount("#app");
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
```svelte fileName="App.svelte"
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```svelte fileName="App.svelte"
{
const { renderMarkdown } = await import('svelte-intlayer/markdown');
return renderMarkdown(md);
}}
>
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "preact-intlayer/markdown";
export const AppProvider = ({ children }) => (
{children}
,
}}
>
{children}
);
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "preact-intlayer/markdown";
export const AppProvider = ({ children }) => (
{
const { renderMarkdown } = await import('preact-intlayer/markdown');
return renderMarkdown(md);
}}
>
{children}
);
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "solid-intlayer/markdown";
export const AppProvider = (props) => (
{props.children}
,
}}
>
{props.children}
);
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```tsx fileName="AppProvider.tsx"
import { MarkdownProvider } from "solid-intlayer/markdown";
export const AppProvider = (props) => (
{
const { renderMarkdown } = await import('solid-intlayer/markdown');
return renderMarkdown(md);
}}
>
{props.children}
);
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
```typescript fileName="app.config.ts"
import { createIntlayerMarkdownProvider } from "angular-intlayer/markdown";
export const appConfig: ApplicationConfig = {
providers: [
createIntlayerMarkdownProvider({
components: {
h1: { class: "text-2xl font-bold" },
},
}),
],
};
```
> MDX is supported, any component name used inside your Markdown (e.g. ``) is resolved against the `components` map.
You can also use your own markdown renderer:
```typescript fileName="app.config.ts"
import { createIntlayerMarkdownProvider } from "angular-intlayer/markdown";
export const appConfig: ApplicationConfig = {
providers: [
createIntlayerMarkdownProvider({
renderMarkdown: async (md) => {
const { renderMarkdown } = await import('angular-intlayer/markdown');
return renderMarkdown(md);
},
}),
],
};
```
> Importing your Markdown renderer dynamically is a good way to reduce the bundle size of your application.
Remix has no component tree to hold a provider, so the configuration is installed once, as a singleton, at server start. It configures the renderer returned by `useMarkdownRenderer()`. The `md` nodes returned by `useIntlayer` are rendered with the default compiler; override their tags per node with `.use()`.
```typescript fileName="src/router.ts"
import { installIntlayerMarkdown } from "remix-intlayer/markdown";
installIntlayerMarkdown({
forceBlock: true,
components: {
h1: ({ children }) => `${children}
`,
},
});
```
You can also use your own markdown renderer:
```typescript fileName="src/router.ts"
import { installIntlayerMarkdown } from "remix-intlayer/markdown";
installIntlayerMarkdown({
renderMarkdown: async (md) => {
const { marked } = await import("marked");
return marked(md) as string;
},
});
```
> Use `installIntlayerMarkdownDynamic(async () => …)` to load the renderer itself lazily; the loader runs on the first call only.
Astro has no component tree to hold a provider, so the configuration is installed once, as a singleton, in the middleware (server) and in a client `
Loading...
```
Svelte does not have a Suspense API equivalent. Use an `{#await}` block to handle async rendering of Markdown content.
```svelte fileName="MyComponent.svelte"
{#await $content.markdownContent}
Loading...
{:then rendered}
{@html rendered}
{/await}
```
Preact supports React's Suspense API via `preact/compat`.
```tsx fileName="MyComponent.tsx"
import { useIntlayer } from "preact-intlayer";
import { Suspense } from "preact/compat";
const MyComponent = () => {
const markdownContent = useIntlayer("my-markdown");
return (
Loading... }>{markdownContent}
);
};
```