react-intlayer 8.4.4 → 8.4.5

package/dist/esm/html/HTMLRenderer.mjs

@@ -1,2 +1,56 @@
-"use client";import{useHTMLContext as e}from"./HTMLProvider.mjs";import{getHTML as t}from"@intlayer/core/interpreter";import{Fragment as n,createElement as r}from"react";import{jsx as i}from"react/jsx-runtime";import{HTML_TAGS as a}from"@intlayer/core/transpiler";const o=(()=>{let e={};for(let t of a)e[t]=({children:e,...n})=>r(t,n,e);return e})(),s=(e,{components:a}={})=>{let s={...o,...a};return i(n,{children:t(e,Object.fromEntries(Object.entries(s).filter(([,e])=>e).map(([e,t])=>[e,e=>r(t,e)])))})},c=({components:t}={})=>{let n=e();return e=>s(e,{components:{...n?.components,...t}})},l=({children:e=``,components:t})=>c({components:t})(e);export{l as HTMLRenderer,o as defaultHTMLComponents,s as renderHTML,c as useHTMLRenderer};
+'use client';
+
+import { useHTMLContext } from "./HTMLProvider.mjs";
+import { getHTML } from "@intlayer/core/interpreter";
+import { Fragment, createElement } from "react";
+import { jsx } from "react/jsx-runtime";
+import { HTML_TAGS } from "@intlayer/core/transpiler";
+
+//#region src/html/HTMLRenderer.tsx
+const createDefaultHTMLComponents = () => {
+	const components = {};
+	for (const tag of HTML_TAGS) components[tag] = ({ children, ...props }) => createElement(tag, props, children);
+	return components;
+};
+const defaultHTMLComponents = createDefaultHTMLComponents();
+/**
+* Renders HTML-like content to JSX with the provided components.
+*
+* This function does not use context from HTMLProvider. Use `useHTMLRenderer`
+* hook if you want to leverage provider context.
+*/
+const renderHTML = (content, { components } = {}) => {
+	const mergedComponents = {
+		...defaultHTMLComponents,
+		...components
+	};
+	return /* @__PURE__ */ jsx(Fragment, { children: getHTML(content, Object.fromEntries(Object.entries(mergedComponents).filter(([, Component]) => Component).map(([key, Component]) => [key, (props) => createElement(Component, props)]))) });
+};
+/**
+* Hook that returns a function to render HTML content.
+*
+* This hook considers the configuration from the `HTMLProvider` context if available,
+* falling back to the provided components.
+*/
+const useHTMLRenderer = ({ components } = {}) => {
+	const context = useHTMLContext();
+	return (content) => {
+		return renderHTML(content, { components: {
+			...context?.components,
+			...components
+		} });
+	};
+};
+/**
+* React component that renders HTML-like content to JSX.
+*
+* This component uses the components from the `HTMLProvider` context
+* if available.
+*/
+const HTMLRenderer = ({ children = "", components }) => {
+	return useHTMLRenderer({ components })(children);
+};
+
+//#endregion
+export { HTMLRenderer, defaultHTMLComponents, renderHTML, useHTMLRenderer };
 //# sourceMappingURL=HTMLRenderer.mjs.map

package/dist/esm/html/HTMLRenderer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRenderer.mjs","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"sourcesContent":["'use client';\n\nimport { getHTML } from '@intlayer/core/interpreter';\nimport { HTML_TAGS } from '@intlayer/core/transpiler';\nimport { createElement, type FC, Fragment, type JSX } from 'react';\nimport type { HTMLComponents } from './HTMLComponentTypes';\nimport { useHTMLContext } from './HTMLProvider';\n\nconst createDefaultHTMLComponents = (): HTMLComponents<'permissive', {}> => {\n  const components: HTMLComponents = {};\n\n  for (const tag of HTML_TAGS) {\n    components[tag] = ({ children, ...props }) =>\n      createElement(tag, props as any, children);\n  }\n\n  return components as HTMLComponents<'permissive', {}>;\n};\n\nexport const defaultHTMLComponents = createDefaultHTMLComponents();\n\nexport type RenderHTMLProps = {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n};\n\n/**\n * Renders HTML-like content to JSX with the provided components.\n *\n * This function does not use context from HTMLProvider. Use `useHTMLRenderer`\n * hook if you want to leverage provider context.\n */\nexport const renderHTML = (\n  content: string,\n  { components }: RenderHTMLProps = {}\n): JSX.Element => {\n  const mergedComponents = {\n    ...defaultHTMLComponents,\n    ...components,\n  };\n\n  // Wrap all components to ensure they are rendered via React.createElement\n  const wrappedComponents = Object.fromEntries(\n    Object.entries(mergedComponents)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: any) => createElement(Component as any, props),\n      ])\n  );\n\n  return <Fragment>{getHTML(content, wrappedComponents)}</Fragment>;\n};\n\n/**\n * Hook that returns a function to render HTML content.\n *\n * This hook considers the configuration from the `HTMLProvider` context if available,\n * falling back to the provided components.\n */\nexport const useHTMLRenderer = ({ components }: RenderHTMLProps = {}) => {\n  const context = useHTMLContext();\n\n  return (content: string) => {\n    return renderHTML(content, {\n      components: {\n        ...context?.components,\n        ...components,\n      },\n    });\n  };\n};\n\nexport type HTMLRendererProps = RenderHTMLProps & {\n  /**\n   * The HTML content to render as a string.\n   */\n  children: string;\n};\n\n/**\n * React component that renders HTML-like content to JSX.\n *\n * This component uses the components from the `HTMLProvider` context\n * if available.\n */\nexport const HTMLRenderer: FC<HTMLRendererProps> = ({\n  children = '',\n  components,\n}) => {\n  const render = useHTMLRenderer({ components });\n\n  return render(children);\n};\n"],"mappings":"wQAmBA,MAAa,OAX+D,CAC1E,IAAM,EAA6B,EAAE,CAErC,IAAK,IAAM,KAAO,EAChB,EAAW,IAAQ,CAAE,WAAU,GAAG,KAChC,EAAc,EAAK,EAAc,EAAS,CAG9C,OAAO,KAGyD,CAgBrD,GACX,EACA,CAAE,cAAgC,EAAE,GACpB,CAChB,IAAM,EAAmB,CACvB,GAAG,EACH,GAAG,EACJ,CAYD,OAAO,EAAC,EAAD,CAAA,SAAW,EAAQ,EATA,OAAO,YAC/B,OAAO,QAAQ,EAAiB,CAC7B,QAAQ,EAAG,KAAe,EAAU,CACpC,KAAK,CAAC,EAAK,KAAe,CACzB,EACC,GAAe,EAAc,EAAkB,EAAM,CACvD,CAAC,CACL,CAEoD,CAAY,CAAA,EAStD,GAAmB,CAAE,cAAgC,EAAE,GAAK,CACvE,IAAM,EAAU,GAAgB,CAEhC,MAAQ,IACC,EAAW,EAAS,CACzB,WAAY,CACV,GAAG,GAAS,WACZ,GAAG,EACJ,CACF,CAAC,EAiBO,GAAuC,CAClD,WAAW,GACX,gBAEe,EAAgB,CAAE,aAAY,CAAC,CAEhC,EAAS"}
+{"version":3,"file":"HTMLRenderer.mjs","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"sourcesContent":["'use client';\n\nimport { getHTML } from '@intlayer/core/interpreter';\nimport { HTML_TAGS } from '@intlayer/core/transpiler';\nimport { createElement, type FC, Fragment, type JSX } from 'react';\nimport type { HTMLComponents } from './HTMLComponentTypes';\nimport { useHTMLContext } from './HTMLProvider';\n\nconst createDefaultHTMLComponents = (): HTMLComponents<'permissive', {}> => {\n  const components: HTMLComponents = {};\n\n  for (const tag of HTML_TAGS) {\n    components[tag] = ({ children, ...props }) =>\n      createElement(tag, props as any, children);\n  }\n\n  return components as HTMLComponents<'permissive', {}>;\n};\n\nexport const defaultHTMLComponents = createDefaultHTMLComponents();\n\nexport type RenderHTMLProps = {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   */\n  components?: HTMLComponents<'permissive', {}>;\n};\n\n/**\n * Renders HTML-like content to JSX with the provided components.\n *\n * This function does not use context from HTMLProvider. Use `useHTMLRenderer`\n * hook if you want to leverage provider context.\n */\nexport const renderHTML = (\n  content: string,\n  { components }: RenderHTMLProps = {}\n): JSX.Element => {\n  const mergedComponents = {\n    ...defaultHTMLComponents,\n    ...components,\n  };\n\n  // Wrap all components to ensure they are rendered via React.createElement\n  const wrappedComponents = Object.fromEntries(\n    Object.entries(mergedComponents)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: any) => createElement(Component as any, props),\n      ])\n  );\n\n  return <Fragment>{getHTML(content, wrappedComponents)}</Fragment>;\n};\n\n/**\n * Hook that returns a function to render HTML content.\n *\n * This hook considers the configuration from the `HTMLProvider` context if available,\n * falling back to the provided components.\n */\nexport const useHTMLRenderer = ({ components }: RenderHTMLProps = {}) => {\n  const context = useHTMLContext();\n\n  return (content: string) => {\n    return renderHTML(content, {\n      components: {\n        ...context?.components,\n        ...components,\n      },\n    });\n  };\n};\n\nexport type HTMLRendererProps = RenderHTMLProps & {\n  /**\n   * The HTML content to render as a string.\n   */\n  children: string;\n};\n\n/**\n * React component that renders HTML-like content to JSX.\n *\n * This component uses the components from the `HTMLProvider` context\n * if available.\n */\nexport const HTMLRenderer: FC<HTMLRendererProps> = ({\n  children = '',\n  components,\n}) => {\n  const render = useHTMLRenderer({ components });\n\n  return render(children);\n};\n"],"mappings":";;;;;;;;;AAQA,MAAM,oCAAsE;CAC1E,MAAM,aAA6B,EAAE;AAErC,MAAK,MAAM,OAAO,UAChB,YAAW,QAAQ,EAAE,UAAU,GAAG,YAChC,cAAc,KAAK,OAAc,SAAS;AAG9C,QAAO;;AAGT,MAAa,wBAAwB,6BAA6B;;;;;;;AAgBlE,MAAa,cACX,SACA,EAAE,eAAgC,EAAE,KACpB;CAChB,MAAM,mBAAmB;EACvB,GAAG;EACH,GAAG;EACJ;AAYD,QAAO,oBAAC,UAAD,YAAW,QAAQ,SATA,OAAO,YAC/B,OAAO,QAAQ,iBAAiB,CAC7B,QAAQ,GAAG,eAAe,UAAU,CACpC,KAAK,CAAC,KAAK,eAAe,CACzB,MACC,UAAe,cAAc,WAAkB,MAAM,CACvD,CAAC,CACL,CAEoD,EAAY;;;;;;;;AASnE,MAAa,mBAAmB,EAAE,eAAgC,EAAE,KAAK;CACvE,MAAM,UAAU,gBAAgB;AAEhC,SAAQ,YAAoB;AAC1B,SAAO,WAAW,SAAS,EACzB,YAAY;GACV,GAAG,SAAS;GACZ,GAAG;GACJ,EACF,CAAC;;;;;;;;;AAiBN,MAAa,gBAAuC,EAClD,WAAW,IACX,iBACI;AAGJ,QAFe,gBAAgB,EAAE,YAAY,CAAC,CAEhC,SAAS"}

package/dist/esm/html/HTMLRendererPlugin.mjs

@@ -1,2 +1,22 @@
-"use client";import{useHTMLContext as e}from"./HTMLProvider.mjs";import{defaultHTMLComponents as t}from"./HTMLRenderer.mjs";import{getHTML as n}from"@intlayer/core/interpreter";import{createElement as r}from"react";const i=i=>{let{html:a,userComponents:o}=i,s=e()?.components||{},c={...t,...s,...o};return n(a,Object.fromEntries(Object.entries(c).filter(([,e])=>e).map(([e,t])=>[e,e=>r(t,e)])))};export{i as HTMLRendererPlugin};
+'use client';
+
+import { useHTMLContext } from "./HTMLProvider.mjs";
+import { defaultHTMLComponents } from "./HTMLRenderer.mjs";
+import { getHTML } from "@intlayer/core/interpreter";
+import { createElement } from "react";
+
+//#region src/html/HTMLRendererPlugin.tsx
+const HTMLRendererPlugin = (props) => {
+	const { html, userComponents } = props;
+	const globalComponents = useHTMLContext()?.components || {};
+	const mergedComponents = {
+		...defaultHTMLComponents,
+		...globalComponents,
+		...userComponents
+	};
+	return getHTML(html, Object.fromEntries(Object.entries(mergedComponents).filter(([, Component]) => Component).map(([key, Component]) => [key, (props) => createElement(Component, props)])));
+};
+
+//#endregion
+export { HTMLRendererPlugin };
 //# sourceMappingURL=HTMLRendererPlugin.mjs.map

package/dist/esm/html/HTMLRendererPlugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRendererPlugin.mjs","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"sourcesContent":["'use client';\n\nimport { getHTML } from '@intlayer/core/interpreter';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { createElement, type FC, type ReactNode } from 'react';\nimport { useHTMLContext } from './HTMLProvider';\nimport { defaultHTMLComponents } from './HTMLRenderer';\nimport type { ReactComponentProps } from './types';\n\ntype HTMLRendererPluginProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  html: string;\n  locale?: Locale;\n  userComponents?: Record<string, any>;\n};\n\nexport const HTMLRendererPlugin: FC<HTMLRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { html, userComponents } = props;\n  const context = useHTMLContext();\n  const globalComponents = context?.components || {};\n\n  const mergedComponents = {\n    ...defaultHTMLComponents,\n    ...globalComponents,\n    ...userComponents,\n  };\n\n  // Wrap all components to ensure they are rendered via React.createElement\n  // This is important because it allows React to handle the component's lifecycle,\n  // hooks, and Babel-injected variables correctly.\n  const wrappedComponents = Object.fromEntries(\n    Object.entries(mergedComponents)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: ReactComponentProps) => createElement(Component, props),\n      ])\n  );\n\n  return getHTML(html, wrappedComponents);\n};\n"],"mappings":"uNAkBA,MAAa,EACX,GACc,CACd,GAAM,CAAE,OAAM,kBAAmB,EAE3B,EADU,GAAgB,EACE,YAAc,EAAE,CAE5C,EAAmB,CACvB,GAAG,EACH,GAAG,EACH,GAAG,EACJ,CAcD,OAAO,EAAQ,EATW,OAAO,YAC/B,OAAO,QAAQ,EAAiB,CAC7B,QAAQ,EAAG,KAAe,EAAU,CACpC,KAAK,CAAC,EAAK,KAAe,CACzB,EACC,GAA+B,EAAc,EAAW,EAAM,CAChE,CAAC,CACL,CAEsC"}
+{"version":3,"file":"HTMLRendererPlugin.mjs","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"sourcesContent":["'use client';\n\nimport { getHTML } from '@intlayer/core/interpreter';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport { createElement, type FC, type ReactNode } from 'react';\nimport { useHTMLContext } from './HTMLProvider';\nimport { defaultHTMLComponents } from './HTMLRenderer';\nimport type { ReactComponentProps } from './types';\n\ntype HTMLRendererPluginProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  html: string;\n  locale?: Locale;\n  userComponents?: Record<string, any>;\n};\n\nexport const HTMLRendererPlugin: FC<HTMLRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { html, userComponents } = props;\n  const context = useHTMLContext();\n  const globalComponents = context?.components || {};\n\n  const mergedComponents = {\n    ...defaultHTMLComponents,\n    ...globalComponents,\n    ...userComponents,\n  };\n\n  // Wrap all components to ensure they are rendered via React.createElement\n  // This is important because it allows React to handle the component's lifecycle,\n  // hooks, and Babel-injected variables correctly.\n  const wrappedComponents = Object.fromEntries(\n    Object.entries(mergedComponents)\n      .filter(([, Component]) => Component)\n      .map(([key, Component]) => [\n        key,\n        (props: ReactComponentProps) => createElement(Component, props),\n      ])\n  );\n\n  return getHTML(html, wrappedComponents);\n};\n"],"mappings":";;;;;;;;AAkBA,MAAa,sBACX,UACc;CACd,MAAM,EAAE,MAAM,mBAAmB;CAEjC,MAAM,mBADU,gBAAgB,EACE,cAAc,EAAE;CAElD,MAAM,mBAAmB;EACvB,GAAG;EACH,GAAG;EACH,GAAG;EACJ;AAcD,QAAO,QAAQ,MATW,OAAO,YAC/B,OAAO,QAAQ,iBAAiB,CAC7B,QAAQ,GAAG,eAAe,UAAU,CACpC,KAAK,CAAC,KAAK,eAAe,CACzB,MACC,UAA+B,cAAc,WAAW,MAAM,CAChE,CAAC,CACL,CAEsC"}

package/dist/esm/html/index.mjs

@@ -1 +1,5 @@
-import{HTMLProvider as e,useHTMLContext as t}from"./HTMLProvider.mjs";import{HTMLRenderer as n,defaultHTMLComponents as r,renderHTML as i,useHTMLRenderer as a}from"./HTMLRenderer.mjs";import{HTMLRendererPlugin as o}from"./HTMLRendererPlugin.mjs";export{e as HTMLProvider,n as HTMLRenderer,o as HTMLRendererPlugin,r as defaultHTMLComponents,i as renderHTML,t as useHTMLContext,a as useHTMLRenderer};
+import { HTMLProvider, useHTMLContext } from "./HTMLProvider.mjs";
+import { HTMLRenderer, defaultHTMLComponents, renderHTML, useHTMLRenderer } from "./HTMLRenderer.mjs";
+import { HTMLRendererPlugin } from "./HTMLRendererPlugin.mjs";
+
+export { HTMLProvider, HTMLRenderer, HTMLRendererPlugin, defaultHTMLComponents, renderHTML, useHTMLContext, useHTMLRenderer };

package/dist/esm/index.mjs

@@ -1 +1,21 @@
-import{HTMLProvider as e}from"./html/HTMLProvider.mjs";import{HTMLRenderer as t,renderHTML as n,useHTMLRenderer as r}from"./html/HTMLRenderer.mjs";import{MarkdownProvider as i}from"./markdown/MarkdownProvider.mjs";import{MarkdownRenderer as a,renderMarkdown as o,useMarkdownRenderer as s}from"./markdown/MarkdownRenderer.mjs";import{getIntlayer as c}from"./getIntlayer.mjs";import{getDictionary as l}from"./getDictionary.mjs";import{localeCookie as u,localeInStorage as d,setLocaleCookie as f,setLocaleInStorage as p,useLocaleCookie as m,useLocaleStorage as h}from"./client/useLocaleStorage.mjs";import{IntlayerClientContext as g,IntlayerProvider as _,IntlayerProviderContent as v,useIntlayerContext as y}from"./client/IntlayerProvider.mjs";import{useIntl as b}from"./client/format/useIntl.mjs";import{t as x}from"./client/t.mjs";import{useDictionary as S}from"./client/useDictionary.mjs";import{useDictionaryAsync as C}from"./client/useDictionaryAsync.mjs";import{useLoadDynamic as w}from"./client/useLoadDynamic.mjs";import{useDictionaryDynamic as T}from"./client/useDictionaryDynamic.mjs";import{useI18n as E}from"./client/useI18n.mjs";import{useIntlayer as D}from"./client/useIntlayer.mjs";import{useLocale as O}from"./client/useLocale.mjs";import{useLocaleBase as k}from"./client/useLocaleBase.mjs";import{useRewriteURL as A}from"./client/useRewriteURL.mjs";export{e as HTMLProvider,t as HTMLRenderer,g as IntlayerClientContext,_ as IntlayerProvider,v as IntlayerProviderContent,i as MarkdownProvider,a as MarkdownRenderer,l as getDictionary,c as getIntlayer,u as localeCookie,d as localeInStorage,n as renderHTML,o as renderMarkdown,f as setLocaleCookie,p as setLocaleInStorage,x as t,S as useDictionary,C as useDictionaryAsync,T as useDictionaryDynamic,r as useHTMLRenderer,E as useI18n,b as useIntl,D as useIntlayer,y as useIntlayerContext,w as useLoadDynamic,O as useLocale,k as useLocaleBase,m as useLocaleCookie,h as useLocaleStorage,s as useMarkdownRenderer,A as useRewriteURL};
+import { HTMLProvider } from "./html/HTMLProvider.mjs";
+import { HTMLRenderer, renderHTML, useHTMLRenderer } from "./html/HTMLRenderer.mjs";
+import { MarkdownProvider } from "./markdown/MarkdownProvider.mjs";
+import { MarkdownRenderer, renderMarkdown, useMarkdownRenderer } from "./markdown/MarkdownRenderer.mjs";
+import { getIntlayer } from "./getIntlayer.mjs";
+import { getDictionary } from "./getDictionary.mjs";
+import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage } from "./client/useLocaleStorage.mjs";
+import { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, useIntlayerContext } from "./client/IntlayerProvider.mjs";
+import { useIntl } from "./client/format/useIntl.mjs";
+import { t } from "./client/t.mjs";
+import { useDictionary } from "./client/useDictionary.mjs";
+import { useDictionaryAsync } from "./client/useDictionaryAsync.mjs";
+import { useLoadDynamic } from "./client/useLoadDynamic.mjs";
+import { useDictionaryDynamic } from "./client/useDictionaryDynamic.mjs";
+import { useI18n } from "./client/useI18n.mjs";
+import { useIntlayer } from "./client/useIntlayer.mjs";
+import { useLocale } from "./client/useLocale.mjs";
+import { useLocaleBase } from "./client/useLocaleBase.mjs";
+import { useRewriteURL } from "./client/useRewriteURL.mjs";
+
+export { HTMLProvider, HTMLRenderer, IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, MarkdownProvider, MarkdownRenderer, getDictionary, getIntlayer, localeCookie, localeInStorage, renderHTML, renderMarkdown, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useHTMLRenderer, useI18n, useIntl, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage, useMarkdownRenderer, useRewriteURL };

package/dist/esm/markdown/MarkdownProvider.mjs

@@ -1,2 +1,78 @@
-"use client";import{compiler as e}from"./processor.mjs";import{createContext as t,useContext as n}from"react";import{jsx as r}from"react/jsx-runtime";const i=t(void 0),a=()=>n(i),o=(e,t={},n={},r)=>({...e,...t,forceBlock:t.forceBlock??e.forceBlock,forceInline:t.forceInline??e.forceInline,preserveFrontmatter:t.preserveFrontmatter??e.preserveFrontmatter,tagfilter:t.tagfilter??e.tagfilter,wrapper:r||e.wrapper,forceWrapper:!!(r||e.wrapper),components:{...e.components,...n}}),s=({children:t,components:n,wrapper:a,forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u,renderMarkdown:d})=>{let f={components:n,forceBlock:s,forceInline:c,wrapper:a,forceWrapper:!!a,preserveFrontmatter:l,tagfilter:u};return r(i.Provider,{value:{components:n,renderMarkdown:d?(e,t,n,a)=>r(i.Provider,{value:void 0,children:d?.(e,t,n,a)}):(t,n,r,i)=>e(t,o(f,n,r,i))},children:t})};export{s as MarkdownProvider,a as useMarkdownContext};
+'use client';
+
+import { compiler } from "./processor.mjs";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/markdown/MarkdownProvider.tsx
+const MarkdownContext = createContext(void 0);
+const useMarkdownContext = () => useContext(MarkdownContext);
+const mergeOptions = (baseOptions, options = {}, components = {}, wrapper) => {
+	return {
+		...baseOptions,
+		...options,
+		forceBlock: options.forceBlock ?? baseOptions.forceBlock,
+		forceInline: options.forceInline ?? baseOptions.forceInline,
+		preserveFrontmatter: options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,
+		tagfilter: options.tagfilter ?? baseOptions.tagfilter,
+		wrapper: wrapper || baseOptions.wrapper,
+		forceWrapper: !!(wrapper || baseOptions.wrapper),
+		components: {
+			...baseOptions.components,
+			...components
+		}
+	};
+};
+/**
+* Provider for the MarkdownRenderer component.
+*
+* It will provide the `renderMarkdown` function to the context, which can be used to render markdown.
+*
+* ```tsx
+* const content = useIntlayer('app');
+*
+* return (
+*   <div>
+*     {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider
+*   </div>
+* );
+* ```
+*
+* @example
+* ```tsx
+* <MarkdownProvider components={{ h1: CustomHeading }}>
+*   <MarkdownRenderer>
+*     {markdownContent}
+*   </MarkdownRenderer>
+* </MarkdownProvider>
+* ```
+*/
+const MarkdownProvider = ({ children, components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter, renderMarkdown: customRenderFn }) => {
+	const baseOptions = {
+		components,
+		forceBlock,
+		forceInline,
+		wrapper,
+		forceWrapper: !!wrapper,
+		preserveFrontmatter,
+		tagfilter
+	};
+	const defaultRenderMarkdown = (markdown, options, components, wrapper) => {
+		return compiler(markdown, mergeOptions(baseOptions, options, components, wrapper));
+	};
+	const customRenderMarkdownWrapper = (markdown, options, components, wrapper) => /* @__PURE__ */ jsx(MarkdownContext.Provider, {
+		value: void 0,
+		children: customRenderFn?.(markdown, options, components, wrapper)
+	});
+	return /* @__PURE__ */ jsx(MarkdownContext.Provider, {
+		value: {
+			components,
+			renderMarkdown: customRenderFn ? customRenderMarkdownWrapper : defaultRenderMarkdown
+		},
+		children
+	});
+};
+
+//#endregion
+export { MarkdownProvider, useMarkdownContext };
 //# sourceMappingURL=MarkdownProvider.mjs.map

package/dist/esm/markdown/MarkdownProvider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.mjs","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createContext,\n  type FC,\n  type HTMLAttributes,\n  type PropsWithChildren,\n  type ReactNode,\n  useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport { compiler, type MarkdownRendererOptions } from './processor';\n\nexport type MarkdownProviderOptions = {\n  /** Forces the compiler to always output content with a block-level wrapper. */\n  forceBlock?: boolean;\n  /** Forces the compiler to always output content with an inline wrapper. */\n  forceInline?: boolean;\n  /** Whether to preserve frontmatter in the markdown content. */\n  preserveFrontmatter?: boolean;\n  /** Whether to use the GitHub Tag Filter for security. */\n  tagfilter?: boolean;\n};\n\ntype MarkdownContextValue = {\n  components?: HTMLComponents<'permissive', {}>;\n  renderMarkdown: (\n    markdown: string,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => ReactNode;\n};\n\ntype MarkdownProviderProps = PropsWithChildren<\n  MarkdownProviderOptions & {\n    components?: HTMLComponents<'permissive', {}>;\n    wrapper?: FC<HTMLAttributes<HTMLElement>>;\n    renderMarkdown?: (\n      markdown: string,\n      options?: MarkdownProviderOptions,\n      components?: HTMLComponents<'permissive', {}>,\n      wrapper?: FC<HTMLAttributes<HTMLElement>>\n    ) => ReactNode;\n  }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue | undefined>(\n  undefined\n);\n\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n  baseOptions: MarkdownRendererOptions,\n  options: MarkdownProviderOptions = {},\n  components: HTMLComponents<'permissive', {}> = {},\n  wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n  return {\n    ...baseOptions,\n    ...options,\n    forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n    forceInline: options.forceInline ?? baseOptions.forceInline,\n    preserveFrontmatter:\n      options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n    tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n    wrapper: wrapper || baseOptions.wrapper,\n\n    forceWrapper: !!(wrapper || baseOptions.wrapper),\n    components: { ...baseOptions.components, ...components },\n  };\n};\n\n/**\n * Provider for the MarkdownRenderer component.\n *\n * It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n *\n * ```tsx\n * const content = useIntlayer('app');\n *\n * return (\n *   <div>\n *     {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n *   </div>\n * );\n * ```\n *\n * @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n *   <MarkdownRenderer>\n *     {markdownContent}\n *   </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n  children,\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown: customRenderFn,\n}) => {\n  const baseOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  // Standard internal renderer\n  const defaultRenderMarkdown = (\n    markdown: string,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => {\n    const mergedOptions = mergeOptions(\n      baseOptions,\n      options,\n      components,\n      wrapper\n    );\n\n    return compiler(markdown, mergedOptions);\n  };\n\n  // Wrapper for user-provided custom renderer\n  // Note: We wrap in a clean Provider to prevent infinite recursion\n  const customRenderMarkdownWrapper = (\n    markdown: string,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => (\n    <MarkdownContext.Provider value={undefined}>\n      {customRenderFn?.(markdown, options, components, wrapper)}\n    </MarkdownContext.Provider>\n  );\n\n  return (\n    <MarkdownContext.Provider\n      value={{\n        components,\n        renderMarkdown: customRenderFn\n          ? customRenderMarkdownWrapper\n          : defaultRenderMarkdown,\n      }}\n    >\n      {children}\n    </MarkdownContext.Provider>\n  );\n};\n"],"mappings":"sJA+CA,MAAM,EAAkB,EACtB,IAAA,GACD,CAEY,MAA2B,EAAW,EAAgB,CAE7D,GACJ,EACA,EAAmC,EAAE,CACrC,EAA+C,EAAE,CACjD,KAEO,CACL,GAAG,EACH,GAAG,EACH,WAAY,EAAQ,YAAc,EAAY,WAC9C,YAAa,EAAQ,aAAe,EAAY,YAChD,oBACE,EAAQ,qBAAuB,EAAY,oBAC7C,UAAW,EAAQ,WAAa,EAAY,UAC5C,QAAS,GAAW,EAAY,QAEhC,aAAc,CAAC,EAAE,GAAW,EAAY,SACxC,WAAY,CAAE,GAAG,EAAY,WAAY,GAAG,EAAY,CACzD,EA2BU,GAA+C,CAC1D,WACA,aACA,UACA,aACA,cACA,sBACA,YACA,eAAgB,KACZ,CACJ,IAAM,EAAuC,CAC3C,aACA,aACA,cACA,UACA,aAAc,CAAC,CAAC,EAChB,sBACA,YACD,CAgCD,OACE,EAAC,EAAgB,SAAjB,CACE,MAAO,CACL,aACA,eAAgB,GAdpB,EACA,EACA,EACA,IAEA,EAAC,EAAgB,SAAjB,CAA0B,MAAO,IAAA,YAC9B,IAAiB,EAAU,EAAS,EAAY,EAAQ,CAChC,CAAA,EAzB3B,EACA,EACA,EACA,IASO,EAAS,EAPM,EACpB,EACA,EACA,EACA,EACD,CAEuC,CAuBrC,CAEA,WACwB,CAAA"}
+{"version":3,"file":"MarkdownProvider.mjs","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createContext,\n  type FC,\n  type HTMLAttributes,\n  type PropsWithChildren,\n  type ReactNode,\n  useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport { compiler, type MarkdownRendererOptions } from './processor';\n\nexport type MarkdownProviderOptions = {\n  /** Forces the compiler to always output content with a block-level wrapper. */\n  forceBlock?: boolean;\n  /** Forces the compiler to always output content with an inline wrapper. */\n  forceInline?: boolean;\n  /** Whether to preserve frontmatter in the markdown content. */\n  preserveFrontmatter?: boolean;\n  /** Whether to use the GitHub Tag Filter for security. */\n  tagfilter?: boolean;\n};\n\ntype MarkdownContextValue = {\n  components?: HTMLComponents<'permissive', {}>;\n  renderMarkdown: (\n    markdown: string,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => ReactNode;\n};\n\ntype MarkdownProviderProps = PropsWithChildren<\n  MarkdownProviderOptions & {\n    components?: HTMLComponents<'permissive', {}>;\n    wrapper?: FC<HTMLAttributes<HTMLElement>>;\n    renderMarkdown?: (\n      markdown: string,\n      options?: MarkdownProviderOptions,\n      components?: HTMLComponents<'permissive', {}>,\n      wrapper?: FC<HTMLAttributes<HTMLElement>>\n    ) => ReactNode;\n  }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue | undefined>(\n  undefined\n);\n\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n  baseOptions: MarkdownRendererOptions,\n  options: MarkdownProviderOptions = {},\n  components: HTMLComponents<'permissive', {}> = {},\n  wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n  return {\n    ...baseOptions,\n    ...options,\n    forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n    forceInline: options.forceInline ?? baseOptions.forceInline,\n    preserveFrontmatter:\n      options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n    tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n    wrapper: wrapper || baseOptions.wrapper,\n\n    forceWrapper: !!(wrapper || baseOptions.wrapper),\n    components: { ...baseOptions.components, ...components },\n  };\n};\n\n/**\n * Provider for the MarkdownRenderer component.\n *\n * It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n *\n * ```tsx\n * const content = useIntlayer('app');\n *\n * return (\n *   <div>\n *     {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n *   </div>\n * );\n * ```\n *\n * @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n *   <MarkdownRenderer>\n *     {markdownContent}\n *   </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n  children,\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown: customRenderFn,\n}) => {\n  const baseOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  // Standard internal renderer\n  const defaultRenderMarkdown = (\n    markdown: string,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => {\n    const mergedOptions = mergeOptions(\n      baseOptions,\n      options,\n      components,\n      wrapper\n    );\n\n    return compiler(markdown, mergedOptions);\n  };\n\n  // Wrapper for user-provided custom renderer\n  // Note: We wrap in a clean Provider to prevent infinite recursion\n  const customRenderMarkdownWrapper = (\n    markdown: string,\n    options?: MarkdownProviderOptions,\n    components?: HTMLComponents<'permissive', {}>,\n    wrapper?: FC<HTMLAttributes<HTMLElement>>\n  ) => (\n    <MarkdownContext.Provider value={undefined}>\n      {customRenderFn?.(markdown, options, components, wrapper)}\n    </MarkdownContext.Provider>\n  );\n\n  return (\n    <MarkdownContext.Provider\n      value={{\n        components,\n        renderMarkdown: customRenderFn\n          ? customRenderMarkdownWrapper\n          : defaultRenderMarkdown,\n      }}\n    >\n      {children}\n    </MarkdownContext.Provider>\n  );\n};\n"],"mappings":";;;;;;;AA+CA,MAAM,kBAAkB,cACtB,OACD;AAED,MAAa,2BAA2B,WAAW,gBAAgB;AAEnE,MAAM,gBACJ,aACA,UAAmC,EAAE,EACrC,aAA+C,EAAE,EACjD,YAC4B;AAC5B,QAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;GAAY;EACzD;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BH,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;EACD;CAGD,MAAM,yBACJ,UACA,SACA,YACA,YACG;AAQH,SAAO,SAAS,UAPM,aACpB,aACA,SACA,YACA,QACD,CAEuC;;CAK1C,MAAM,+BACJ,UACA,SACA,YACA,YAEA,oBAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,QAAQ;EAChC;AAG7B,QACE,oBAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;GACL;EAEA;EACwB"}

package/dist/esm/markdown/MarkdownRenderer.mjs

@@ -1,2 +1,198 @@
-"use client";import{compiler as e}from"./processor.mjs";import{useMarkdownContext as t}from"./MarkdownProvider.mjs";import{Fragment as n,jsx as r}from"react/jsx-runtime";const i=(t,{components:n,wrapper:r,forceBlock:i,forceInline:a,preserveFrontmatter:o,tagfilter:s}={})=>e(t,{components:n,forceBlock:i,forceInline:a,wrapper:r,forceWrapper:!!r,preserveFrontmatter:o,tagfilter:s}),a=({components:e,wrapper:n,forceBlock:r,forceInline:a,preserveFrontmatter:o,tagfilter:s}={})=>{let c=t();return t=>c?c.renderMarkdown(t,{forceBlock:r,forceInline:a,preserveFrontmatter:o,tagfilter:s},e,n):i(t,{components:e,wrapper:n,forceBlock:r,forceInline:a,preserveFrontmatter:o,tagfilter:s})},o=({children:i=``,components:a,wrapper:o,forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u,renderMarkdown:d})=>{let f=t();return d?r(n,{children:d(i,{components:a,wrapper:o,forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u})}):f?r(n,{children:f.renderMarkdown(i,{forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u},a,o)}):r(n,{children:e(i,{components:a,forceBlock:s,forceInline:c,wrapper:o,forceWrapper:!!o,preserveFrontmatter:l,tagfilter:u})})};export{o as MarkdownRenderer,i as renderMarkdown,a as useMarkdownRenderer};
+'use client';
+
+import { compiler } from "./processor.mjs";
+import { useMarkdownContext } from "./MarkdownProvider.mjs";
+import { Fragment, jsx } from "react/jsx-runtime";
+
+//#region src/markdown/MarkdownRenderer.tsx
+/**
+* Renders markdown content to JSX with the provided components and options.
+*
+* This function does not use context from MarkdownProvider. Use `useMarkdownRenderer`
+* hook if you want to leverage provider context.
+*
+* @param content - The markdown string to render
+* @param props - Configuration options for rendering
+* @param props.components - Component overrides for HTML tags
+* @param props.wrapper - Wrapper component for multiple children
+* @returns JSX element representing the rendered markdown
+*
+* @example
+* ```tsx
+* import { renderMarkdown } from '@intlayer/react-intlayer/markdown';
+*
+* const markdown = '# Hello World\n\nThis is **bold** text.';
+* const jsx = renderMarkdown(markdown, {
+*   components: {
+*     h1: ({ children }) => <h1 className="title">{children}</h1>,
+*   },
+*   forceBlock: true,
+* });
+* ```
+*/
+const renderMarkdown = (content, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
+	return compiler(content, {
+		components,
+		forceBlock,
+		forceInline,
+		wrapper,
+		forceWrapper: !!wrapper,
+		preserveFrontmatter,
+		tagfilter
+	});
+};
+/**
+* Hook that returns a function to render markdown content.
+*
+* This hook considers the configuration from the `MarkdownProvider` context if available,
+* falling back to the provided props or default behavior.
+*
+* @param props - Optional configuration that will override context values
+* @param props.components - Component overrides for HTML tags (overrides context)
+* @param props.wrapper - Wrapper component (overrides context)
+* @returns A function that takes markdown content and returns JSX
+*
+* @example
+* ```tsx
+* import { useMarkdownRenderer } from '@intlayer/react-intlayer/markdown';
+*
+* function MyComponent() {
+*   const renderMarkdown = useMarkdownRenderer({
+*     components: {
+*       h1: ({ children }) => <h1 className="custom">{children}</h1>,
+*     },
+*   });
+*
+*   return (
+*     <div>
+*       {renderMarkdown('# Hello\n\nThis is **markdown**')}
+*     </div>
+*   );
+* }
+* ```
+*
+* @example
+* ```tsx
+* // With MarkdownProvider context
+* function App() {
+*   return (
+*     <MarkdownProvider
+*       components={{ h1: CustomHeading }}
+*       forceBlock={true}
+*     >
+*       <MyComponent />
+*     </MarkdownProvider>
+*   );
+* }
+* ```
+*/
+const useMarkdownRenderer = ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
+	const context = useMarkdownContext();
+	return (content) => {
+		if (context) return context.renderMarkdown(content, {
+			forceBlock,
+			forceInline,
+			preserveFrontmatter,
+			tagfilter
+		}, components, wrapper);
+		return renderMarkdown(content, {
+			components,
+			wrapper,
+			forceBlock,
+			forceInline,
+			preserveFrontmatter,
+			tagfilter
+		});
+	};
+};
+/**
+* React component that renders markdown content to JSX.
+*
+* This component uses the `renderMarkdown` function from the `MarkdownProvider` context
+* if available. Otherwise, it falls back to the default compiler with provided components
+* and options. You can also provide a custom `renderMarkdown` function prop to override
+* all rendering behavior.
+*
+* @example
+* ```tsx
+* import { MarkdownRenderer } from '@intlayer/react-intlayer/markdown';
+*
+* function MyComponent() {
+*   return (
+*     <MarkdownRenderer>
+*       {`# Hello World
+*
+* This is a paragraph with **bold** and *italic* text.
+*
+* - List item 1
+* - List item 2`}
+*     </MarkdownRenderer>
+*   );
+* }
+* ```
+*
+* @example
+* ```tsx
+* // With custom components
+* <MarkdownRenderer
+*   components={{
+*     h1: ({ children }) => <h1 className="text-4xl font-bold">{children}</h1>,
+*     a: ({ href, children }) => (
+*       <a href={href} className="text-blue-500 hover:underline">
+*         {children}
+*       </a>
+*     ),
+*   }}
+*   forceBlock={true}
+* >
+*   {markdownContent}
+* </MarkdownRenderer>
+* ```
+*
+* @example
+* ```tsx
+* // With MarkdownProvider context
+* function App() {
+*   return (
+*     <MarkdownProvider
+*       components={{ h1: CustomHeading }}
+*       forceBlock={true}
+*     >
+*       <MarkdownRenderer>
+*         {markdownContent}
+*       </MarkdownRenderer>
+*     </MarkdownProvider>
+*   );
+* }
+* ```
+*/
+const MarkdownRenderer = ({ children = "", components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter, renderMarkdown }) => {
+	const context = useMarkdownContext();
+	if (renderMarkdown) return /* @__PURE__ */ jsx(Fragment, { children: renderMarkdown(children, {
+		components,
+		wrapper,
+		forceBlock,
+		forceInline,
+		preserveFrontmatter,
+		tagfilter
+	}) });
+	if (context) return /* @__PURE__ */ jsx(Fragment, { children: context.renderMarkdown(children, {
+		forceBlock,
+		forceInline,
+		preserveFrontmatter,
+		tagfilter
+	}, components, wrapper) });
+	return /* @__PURE__ */ jsx(Fragment, { children: compiler(children, {
+		components,
+		forceBlock,
+		forceInline,
+		wrapper,
+		forceWrapper: !!wrapper,
+		preserveFrontmatter,
+		tagfilter
+	}) });
+};
+
+//#endregion
+export { MarkdownRenderer, renderMarkdown, useMarkdownRenderer };
 //# sourceMappingURL=MarkdownRenderer.mjs.map

package/dist/esm/markdown/MarkdownRenderer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.mjs","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"sourcesContent":["'use client';\n\nimport type { FC, HTMLAttributes, JSX, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  type MarkdownProviderOptions,\n  useMarkdownContext,\n} from './MarkdownProvider';\nimport { compiler, type MarkdownRendererOptions } from './processor';\n\n/**\n * Props for rendering markdown content.\n *\n * @example\n * ```tsx\n * const props: RenderMarkdownProps = {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"text-3xl\">{children}</h1>,\n *     p: ({ children }) => <p className=\"text-gray-700\">{children}</p>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   options: {\n *     forceBlock: true,\n *     preserveFrontmatter: false,\n *     tagfilter: true,\n *   },\n * };\n * ```\n */\nexport type RenderMarkdownProps = MarkdownProviderOptions & {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * components={{\n   *   h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n   *   a: ({ href, children }) => <Link to={href}>{children}</Link>,\n   * }}\n   * ```\n   */\n  components?: HTMLComponents<'permissive', {}>;\n  /**\n   * Wrapper element or component to be used when there are multiple children.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * wrapper={({ children }) => <div className=\"markdown-content\">{children}</div>}\n   * ```\n   */\n  wrapper?: FC<HTMLAttributes<HTMLElement>>;\n};\n\n/**\n * Renders markdown content to JSX with the provided components and options.\n *\n * This function does not use context from MarkdownProvider. Use `useMarkdownRenderer`\n * hook if you want to leverage provider context.\n *\n * @param content - The markdown string to render\n * @param props - Configuration options for rendering\n * @param props.components - Component overrides for HTML tags\n * @param props.wrapper - Wrapper component for multiple children\n * @returns JSX element representing the rendered markdown\n *\n * @example\n * ```tsx\n * import { renderMarkdown } from '@intlayer/react-intlayer/markdown';\n *\n * const markdown = '# Hello World\\n\\nThis is **bold** text.';\n * const jsx = renderMarkdown(markdown, {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   forceBlock: true,\n * });\n * ```\n */\nexport const renderMarkdown = (\n  content: string,\n  {\n    components,\n    wrapper,\n    forceBlock,\n    forceInline,\n    preserveFrontmatter,\n    tagfilter,\n  }: RenderMarkdownProps = {}\n): JSX.Element => {\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return compiler(content, internalOptions);\n};\n\n/**\n * Hook that returns a function to render markdown content.\n *\n * This hook considers the configuration from the `MarkdownProvider` context if available,\n * falling back to the provided props or default behavior.\n *\n * @param props - Optional configuration that will override context values\n * @param props.components - Component overrides for HTML tags (overrides context)\n * @param props.wrapper - Wrapper component (overrides context)\n * @returns A function that takes markdown content and returns JSX\n *\n * @example\n * ```tsx\n * import { useMarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   const renderMarkdown = useMarkdownRenderer({\n *     components: {\n *       h1: ({ children }) => <h1 className=\"custom\">{children}</h1>,\n *     },\n *   });\n *\n *   return (\n *     <div>\n *       {renderMarkdown('# Hello\\n\\nThis is **markdown**')}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MyComponent />\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const useMarkdownRenderer = ({\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n}: RenderMarkdownProps = {}) => {\n  const context = useMarkdownContext();\n\n  return (content: string) => {\n    if (context) {\n      return context.renderMarkdown(\n        content,\n        {\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        },\n        components,\n        wrapper\n      );\n    }\n\n    return renderMarkdown(content, {\n      components,\n      wrapper,\n      forceBlock,\n      forceInline,\n      preserveFrontmatter,\n      tagfilter,\n    });\n  };\n};\n\n/**\n * Props for the MarkdownRenderer component.\n *\n * @example\n * ```tsx\n * const props: MarkdownRendererProps = {\n *   children: '# Hello World\\n\\nThis is **bold** text.',\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   forceBlock: true,\n * };\n * ```\n */\nexport type MarkdownRendererProps = RenderMarkdownProps & {\n  /**\n   * The markdown content to render as a string.\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer>\n   *   {`# Title\\n\\nParagraph with **bold** text.`}\n   * </MarkdownRenderer>\n   * ```\n   */\n  children: string;\n  /**\n   * Custom render function for markdown.\n   * If provided, it will overwrite context and default rendering.\n   *\n   * @param markdown - The markdown string to render\n   * @param options - Optional rendering options\n   * @returns React node representing the rendered markdown\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer\n   *   renderMarkdown={(md, opts) => {\n   *     // Custom rendering logic\n   *     return <div dangerouslySetInnerHTML={{ __html: customParser(md) }} />;\n   *   }}\n   * >\n   *   {markdownContent}\n   * </MarkdownRenderer>\n   * ```\n   */\n  renderMarkdown?: (\n    markdown: string,\n    options?: {\n      components?: HTMLComponents<'permissive', {}>;\n      wrapper?: FC;\n      forceBlock?: boolean;\n      forceInline?: boolean;\n      preserveFrontmatter?: boolean;\n      tagfilter?: boolean;\n    }\n  ) => ReactNode;\n};\n\n/**\n * React component that renders markdown content to JSX.\n *\n * This component uses the `renderMarkdown` function from the `MarkdownProvider` context\n * if available. Otherwise, it falls back to the default compiler with provided components\n * and options. You can also provide a custom `renderMarkdown` function prop to override\n * all rendering behavior.\n *\n * @example\n * ```tsx\n * import { MarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   return (\n *     <MarkdownRenderer>\n *       {`# Hello World\n *\n * This is a paragraph with **bold** and *italic* text.\n *\n * - List item 1\n * - List item 2`}\n *     </MarkdownRenderer>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom components\n * <MarkdownRenderer\n *   components={{\n *     h1: ({ children }) => <h1 className=\"text-4xl font-bold\">{children}</h1>,\n *     a: ({ href, children }) => (\n *       <a href={href} className=\"text-blue-500 hover:underline\">\n *         {children}\n *       </a>\n *     ),\n *   }}\n *   forceBlock={true}\n * >\n *   {markdownContent}\n * </MarkdownRenderer>\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MarkdownRenderer>\n *         {markdownContent}\n *       </MarkdownRenderer>\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const MarkdownRenderer: FC<MarkdownRendererProps> = ({\n  children = '',\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown,\n}) => {\n  const context = useMarkdownContext();\n\n  if (renderMarkdown) {\n    return (\n      <>\n        {renderMarkdown(children, {\n          components,\n          wrapper,\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        })}\n      </>\n    );\n  }\n\n  if (context) {\n    return (\n      <>\n        {context.renderMarkdown(\n          children,\n          {\n            forceBlock,\n            forceInline,\n            preserveFrontmatter,\n            tagfilter,\n          },\n          components,\n          wrapper\n        )}\n      </>\n    );\n  }\n\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return <>{compiler(children, internalOptions)}</>;\n};\n"],"mappings":"0KAiFA,MAAa,GACX,EACA,CACE,aACA,UACA,aACA,cACA,sBACA,aACuB,EAAE,GAapB,EAAS,EAViC,CAC/C,aACA,aACA,cACA,UACA,aAAc,CAAC,CAAC,EAChB,sBACA,YACD,CAEwC,CAgD9B,GAAuB,CAClC,aACA,UACA,aACA,cACA,sBACA,aACuB,EAAE,GAAK,CAC9B,IAAM,EAAU,GAAoB,CAEpC,MAAQ,IACF,EACK,EAAQ,eACb,EACA,CACE,aACA,cACA,sBACA,YACD,CACD,EACA,EACD,CAGI,EAAe,EAAS,CAC7B,aACA,UACA,aACA,cACA,sBACA,YACD,CAAC,EA6HO,GAA+C,CAC1D,WAAW,GACX,aACA,UACA,aACA,cACA,sBACA,YACA,oBACI,CACJ,IAAM,EAAU,GAAoB,CA8CpC,OA5CI,EAEA,EAAA,EAAA,CAAA,SACG,EAAe,EAAU,CACxB,aACA,UACA,aACA,cACA,sBACA,YACD,CAAC,CACD,CAAA,CAIH,EAEA,EAAA,EAAA,CAAA,SACG,EAAQ,eACP,EACA,CACE,aACA,cACA,sBACA,YACD,CACD,EACA,EACD,CACA,CAAA,CAeA,EAAA,EAAA,CAAA,SAAG,EAAS,EAV8B,CAC/C,aACA,aACA,cACA,UACA,aAAc,CAAC,CAAC,EAChB,sBACA,YACD,CAE4C,CAAI,CAAA"}
+{"version":3,"file":"MarkdownRenderer.mjs","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"sourcesContent":["'use client';\n\nimport type { FC, HTMLAttributes, JSX, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  type MarkdownProviderOptions,\n  useMarkdownContext,\n} from './MarkdownProvider';\nimport { compiler, type MarkdownRendererOptions } from './processor';\n\n/**\n * Props for rendering markdown content.\n *\n * @example\n * ```tsx\n * const props: RenderMarkdownProps = {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"text-3xl\">{children}</h1>,\n *     p: ({ children }) => <p className=\"text-gray-700\">{children}</p>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   options: {\n *     forceBlock: true,\n *     preserveFrontmatter: false,\n *     tagfilter: true,\n *   },\n * };\n * ```\n */\nexport type RenderMarkdownProps = MarkdownProviderOptions & {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * components={{\n   *   h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n   *   a: ({ href, children }) => <Link to={href}>{children}</Link>,\n   * }}\n   * ```\n   */\n  components?: HTMLComponents<'permissive', {}>;\n  /**\n   * Wrapper element or component to be used when there are multiple children.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * wrapper={({ children }) => <div className=\"markdown-content\">{children}</div>}\n   * ```\n   */\n  wrapper?: FC<HTMLAttributes<HTMLElement>>;\n};\n\n/**\n * Renders markdown content to JSX with the provided components and options.\n *\n * This function does not use context from MarkdownProvider. Use `useMarkdownRenderer`\n * hook if you want to leverage provider context.\n *\n * @param content - The markdown string to render\n * @param props - Configuration options for rendering\n * @param props.components - Component overrides for HTML tags\n * @param props.wrapper - Wrapper component for multiple children\n * @returns JSX element representing the rendered markdown\n *\n * @example\n * ```tsx\n * import { renderMarkdown } from '@intlayer/react-intlayer/markdown';\n *\n * const markdown = '# Hello World\\n\\nThis is **bold** text.';\n * const jsx = renderMarkdown(markdown, {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   forceBlock: true,\n * });\n * ```\n */\nexport const renderMarkdown = (\n  content: string,\n  {\n    components,\n    wrapper,\n    forceBlock,\n    forceInline,\n    preserveFrontmatter,\n    tagfilter,\n  }: RenderMarkdownProps = {}\n): JSX.Element => {\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return compiler(content, internalOptions);\n};\n\n/**\n * Hook that returns a function to render markdown content.\n *\n * This hook considers the configuration from the `MarkdownProvider` context if available,\n * falling back to the provided props or default behavior.\n *\n * @param props - Optional configuration that will override context values\n * @param props.components - Component overrides for HTML tags (overrides context)\n * @param props.wrapper - Wrapper component (overrides context)\n * @returns A function that takes markdown content and returns JSX\n *\n * @example\n * ```tsx\n * import { useMarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   const renderMarkdown = useMarkdownRenderer({\n *     components: {\n *       h1: ({ children }) => <h1 className=\"custom\">{children}</h1>,\n *     },\n *   });\n *\n *   return (\n *     <div>\n *       {renderMarkdown('# Hello\\n\\nThis is **markdown**')}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MyComponent />\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const useMarkdownRenderer = ({\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n}: RenderMarkdownProps = {}) => {\n  const context = useMarkdownContext();\n\n  return (content: string) => {\n    if (context) {\n      return context.renderMarkdown(\n        content,\n        {\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        },\n        components,\n        wrapper\n      );\n    }\n\n    return renderMarkdown(content, {\n      components,\n      wrapper,\n      forceBlock,\n      forceInline,\n      preserveFrontmatter,\n      tagfilter,\n    });\n  };\n};\n\n/**\n * Props for the MarkdownRenderer component.\n *\n * @example\n * ```tsx\n * const props: MarkdownRendererProps = {\n *   children: '# Hello World\\n\\nThis is **bold** text.',\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   forceBlock: true,\n * };\n * ```\n */\nexport type MarkdownRendererProps = RenderMarkdownProps & {\n  /**\n   * The markdown content to render as a string.\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer>\n   *   {`# Title\\n\\nParagraph with **bold** text.`}\n   * </MarkdownRenderer>\n   * ```\n   */\n  children: string;\n  /**\n   * Custom render function for markdown.\n   * If provided, it will overwrite context and default rendering.\n   *\n   * @param markdown - The markdown string to render\n   * @param options - Optional rendering options\n   * @returns React node representing the rendered markdown\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer\n   *   renderMarkdown={(md, opts) => {\n   *     // Custom rendering logic\n   *     return <div dangerouslySetInnerHTML={{ __html: customParser(md) }} />;\n   *   }}\n   * >\n   *   {markdownContent}\n   * </MarkdownRenderer>\n   * ```\n   */\n  renderMarkdown?: (\n    markdown: string,\n    options?: {\n      components?: HTMLComponents<'permissive', {}>;\n      wrapper?: FC;\n      forceBlock?: boolean;\n      forceInline?: boolean;\n      preserveFrontmatter?: boolean;\n      tagfilter?: boolean;\n    }\n  ) => ReactNode;\n};\n\n/**\n * React component that renders markdown content to JSX.\n *\n * This component uses the `renderMarkdown` function from the `MarkdownProvider` context\n * if available. Otherwise, it falls back to the default compiler with provided components\n * and options. You can also provide a custom `renderMarkdown` function prop to override\n * all rendering behavior.\n *\n * @example\n * ```tsx\n * import { MarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   return (\n *     <MarkdownRenderer>\n *       {`# Hello World\n *\n * This is a paragraph with **bold** and *italic* text.\n *\n * - List item 1\n * - List item 2`}\n *     </MarkdownRenderer>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom components\n * <MarkdownRenderer\n *   components={{\n *     h1: ({ children }) => <h1 className=\"text-4xl font-bold\">{children}</h1>,\n *     a: ({ href, children }) => (\n *       <a href={href} className=\"text-blue-500 hover:underline\">\n *         {children}\n *       </a>\n *     ),\n *   }}\n *   forceBlock={true}\n * >\n *   {markdownContent}\n * </MarkdownRenderer>\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MarkdownRenderer>\n *         {markdownContent}\n *       </MarkdownRenderer>\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const MarkdownRenderer: FC<MarkdownRendererProps> = ({\n  children = '',\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown,\n}) => {\n  const context = useMarkdownContext();\n\n  if (renderMarkdown) {\n    return (\n      <>\n        {renderMarkdown(children, {\n          components,\n          wrapper,\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        })}\n      </>\n    );\n  }\n\n  if (context) {\n    return (\n      <>\n        {context.renderMarkdown(\n          children,\n          {\n            forceBlock,\n            forceInline,\n            preserveFrontmatter,\n            tagfilter,\n          },\n          components,\n          wrapper\n        )}\n      </>\n    );\n  }\n\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return <>{compiler(children, internalOptions)}</>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,MAAa,kBACX,SACA,EACE,YACA,SACA,YACA,aACA,qBACA,cACuB,EAAE,KACX;AAYhB,QAAO,SAAS,SAViC;EAC/C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;EACD,CAEwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgD3C,MAAa,uBAAuB,EAClC,YACA,SACA,YACA,aACA,qBACA,cACuB,EAAE,KAAK;CAC9B,MAAM,UAAU,oBAAoB;AAEpC,SAAQ,YAAoB;AAC1B,MAAI,QACF,QAAO,QAAQ,eACb,SACA;GACE;GACA;GACA;GACA;GACD,EACD,YACA,QACD;AAGH,SAAO,eAAe,SAAS;GAC7B;GACA;GACA;GACA;GACA;GACA;GACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HN,MAAa,oBAA+C,EAC1D,WAAW,IACX,YACA,SACA,YACA,aACA,qBACA,WACA,qBACI;CACJ,MAAM,UAAU,oBAAoB;AAEpC,KAAI,eACF,QACE,0CACG,eAAe,UAAU;EACxB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,EACD;AAIP,KAAI,QACF,QACE,0CACG,QAAQ,eACP,UACA;EACE;EACA;EACA;EACA;EACD,EACD,YACA,QACD,EACA;AAeP,QAAO,0CAAG,SAAS,UAV8B;EAC/C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;EACD,CAE4C,EAAI"}

package/dist/esm/markdown/MarkdownRendererPlugin.mjs

@@ -1,2 +1,17 @@
-"use client";import{useMarkdownContext as e}from"./MarkdownProvider.mjs";const t=t=>{let{children:n,options:r,components:i}=t,a=e();return(a?.renderMarkdown??(e=>e))(n,r,{...a?.components??{},...i??{}})};export{t as MarkdownRendererPlugin};
+'use client';
+
+import { useMarkdownContext } from "./MarkdownProvider.mjs";
+
+//#region src/markdown/MarkdownRendererPlugin.tsx
+const MarkdownRendererPlugin = (props) => {
+	const { children, options, components } = props;
+	const context = useMarkdownContext();
+	return (context?.renderMarkdown ?? ((md) => md))(children, options, {
+		...context?.components ?? {},
+		...components ?? {}
+	});
+};
+
+//#endregion
+export { MarkdownRendererPlugin };
 //# sourceMappingURL=MarkdownRendererPlugin.mjs.map

package/dist/esm/markdown/MarkdownRendererPlugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRendererPlugin.mjs","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"sourcesContent":["'use client';\n\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { FC, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  type MarkdownProviderOptions,\n  useMarkdownContext,\n} from './MarkdownProvider';\n\ntype MarkdownRendererPluginProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: LocalesValues;\n  children: string;\n  options?: MarkdownProviderOptions;\n  components?: HTMLComponents<'permissive', {}>;\n};\n\nexport const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { children, options, components } = props;\n  const context = useMarkdownContext();\n  const renderMarkdown = context?.renderMarkdown ?? ((md) => md);\n  const contentToRender = children;\n\n  return renderMarkdown(contentToRender, options, {\n    ...(context?.components ?? {}),\n    ...(components ?? {}),\n  });\n};\n"],"mappings":"yEAoBA,MAAa,EACX,GACc,CACd,GAAM,CAAE,WAAU,UAAS,cAAe,EACpC,EAAU,GAAoB,CAIpC,OAHuB,GAAS,iBAAoB,GAAO,IACnC,EAEe,EAAS,CAC9C,GAAI,GAAS,YAAc,EAAE,CAC7B,GAAI,GAAc,EAAE,CACrB,CAAC"}
+{"version":3,"file":"MarkdownRendererPlugin.mjs","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"sourcesContent":["'use client';\n\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { FC, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  type MarkdownProviderOptions,\n  useMarkdownContext,\n} from './MarkdownProvider';\n\ntype MarkdownRendererPluginProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: LocalesValues;\n  children: string;\n  options?: MarkdownProviderOptions;\n  components?: HTMLComponents<'permissive', {}>;\n};\n\nexport const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { children, options, components } = props;\n  const context = useMarkdownContext();\n  const renderMarkdown = context?.renderMarkdown ?? ((md) => md);\n  const contentToRender = children;\n\n  return renderMarkdown(contentToRender, options, {\n    ...(context?.components ?? {}),\n    ...(components ?? {}),\n  });\n};\n"],"mappings":";;;;;AAoBA,MAAa,0BACX,UACc;CACd,MAAM,EAAE,UAAU,SAAS,eAAe;CAC1C,MAAM,UAAU,oBAAoB;AAIpC,SAHuB,SAAS,oBAAoB,OAAO,KACnC,UAEe,SAAS;EAC9C,GAAI,SAAS,cAAc,EAAE;EAC7B,GAAI,cAAc,EAAE;EACrB,CAAC"}

package/dist/esm/markdown/index.mjs

@@ -1 +1,7 @@
-import{LegacyMarkdownRenderer as e,RuleType as t,compile as n,compileMarkdown as r,compiler as i,sanitizer as a,slugify as o}from"./processor.mjs";import{MarkdownProvider as s,useMarkdownContext as c}from"./MarkdownProvider.mjs";import{MarkdownRenderer as l,renderMarkdown as u,useMarkdownRenderer as d}from"./MarkdownRenderer.mjs";import{MarkdownRendererPlugin as f}from"./MarkdownRendererPlugin.mjs";import p,{createReactRuntime as m}from"./runtime.mjs";export{e as LegacyMarkdownRenderer,s as MarkdownProvider,l as MarkdownRenderer,f as MarkdownRendererPlugin,t as RuleType,n as compile,r as compileMarkdown,i as compiler,m as createReactRuntime,p as reactRuntime,u as renderMarkdown,a as sanitizer,o as slugify,c as useMarkdownContext,d as useMarkdownRenderer};
+import { LegacyMarkdownRenderer, RuleType, compile, compileMarkdown, compiler, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "./processor.mjs";
+import { MarkdownProvider, useMarkdownContext } from "./MarkdownProvider.mjs";
+import { MarkdownRenderer, renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.mjs";
+import { MarkdownRendererPlugin } from "./MarkdownRendererPlugin.mjs";
+import reactRuntime, { createReactRuntime } from "./runtime.mjs";
+
+export { LegacyMarkdownRenderer, MarkdownProvider, MarkdownRenderer, MarkdownRendererPlugin, RuleType, compile, compileMarkdown, compiler, createReactRuntime, reactRuntime, renderMarkdown, defaultSanitizer as sanitizer, defaultSlugify as slugify, useMarkdownContext, useMarkdownRenderer };

package/dist/esm/markdown/processor.mjs

@@ -1,2 +1,59 @@
-import{RuleType as e,compile as t,sanitizer as n,slugify as r}from"@intlayer/core/markdown";import{Fragment as i,cloneElement as a,createElement as o}from"react";const s={createElement:o,cloneElement:a,Fragment:i,normalizeProps:(e,t)=>t},c=(e=``,n={})=>{let{createElement:r,disableAutoLink:i,disableParsingRawHTML:a,enforceAtxHeadings:o,forceBlock:c,forceInline:l,forceWrapper:u,namedCodesToUnicode:d,components:f,renderRule:p,sanitizer:m,slugify:h,wrapper:g,preserveFrontmatter:_,tagfilter:v}=n;return t(e,{runtime:r?{...s,createElement:r}:s,components:f,namedCodesToUnicode:d,sanitizer:m,slugify:h},{disableAutoLink:i,disableParsingRawHTML:a,enforceAtxHeadings:o,forceBlock:c,forceInline:l,forceWrapper:u,renderRule:p,wrapper:g,preserveFrontmatter:_,tagfilter:v})},l=c,u=c,d=({children:e=``,options:t,...n})=>(process.env.NODE_ENV!==`production`&&typeof e!=`string`&&console.error(`intlayer: <Markdown> component only accepts a single string as a child, received:`,e),a(l(e,t),n));export{d as LegacyMarkdownRenderer,e as RuleType,u as compile,c as compileMarkdown,l as compiler,n as sanitizer,r as slugify};
+import { RuleType, compile as compile$1, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core/markdown";
+import { Fragment, cloneElement, createElement } from "react";
+
+//#region src/markdown/processor.tsx
+/**
+* it's a fork
+* [markdown-to-jsx v7.7.14](https://github.com/quantizor/markdown-to-jsx) from quantizor
+* [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown) from Khan Academy.
+*/
+/**
+* Default React runtime for markdown rendering.
+*/
+const DEFAULT_RUNTIME = {
+	createElement,
+	cloneElement,
+	Fragment,
+	normalizeProps: (_tag, props) => props
+};
+/**
+* Compile markdown to React elements.
+* This is the primary export - use this for new code.
+*/
+const compileMarkdown = (markdown = "", options = {}) => {
+	const { createElement: customCreateElement, disableAutoLink, disableParsingRawHTML, enforceAtxHeadings, forceBlock, forceInline, forceWrapper, namedCodesToUnicode, components, renderRule, sanitizer, slugify, wrapper, preserveFrontmatter, tagfilter } = options;
+	return compile$1(markdown, {
+		runtime: customCreateElement ? {
+			...DEFAULT_RUNTIME,
+			createElement: customCreateElement
+		} : DEFAULT_RUNTIME,
+		components,
+		namedCodesToUnicode,
+		sanitizer,
+		slugify
+	}, {
+		disableAutoLink,
+		disableParsingRawHTML,
+		enforceAtxHeadings,
+		forceBlock,
+		forceInline,
+		forceWrapper,
+		renderRule,
+		wrapper,
+		preserveFrontmatter,
+		tagfilter
+	});
+};
+const compiler = compileMarkdown;
+const compile = compileMarkdown;
+/**
+* React component that renders markdown to JSX (legacy).
+*/
+const LegacyMarkdownRenderer = ({ children = "", options, ...props }) => {
+	if (process.env.NODE_ENV !== "production" && typeof children !== "string") console.error("intlayer: <Markdown> component only accepts a single string as a child, received:", children);
+	return cloneElement(compiler(children, options), props);
+};
+
+//#endregion
+export { LegacyMarkdownRenderer, RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
 //# sourceMappingURL=processor.mjs.map