react-intlayer 8.0.0-canary.1 → 8.0.0-canary.2

package/dist/types/html/HTMLRenderer.d.ts

@@ -0,0 +1,46 @@
+import { ReactHTMLComponent } from "./types.js";
+import { FC, JSX } from "react";
+
+//#region src/html/HTMLRenderer.d.ts
+declare const defaultHTMLComponents: Record<string, ReactHTMLComponent>;
+type RenderHTMLProps = {
+  /**
+   * Component overrides for HTML tags.
+   * Allows you to customize how specific HTML elements are rendered.
+   */
+  components?: Record<string, any>;
+};
+/**
+ * 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.
+ */
+declare const renderHTML: (content: string, {
+  components
+}?: RenderHTMLProps) => JSX.Element;
+/**
+ * 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.
+ */
+declare const useHTMLRenderer: ({
+  components
+}?: RenderHTMLProps) => (content: string) => JSX.Element;
+type HTMLRendererProps = RenderHTMLProps & {
+  /**
+   * The HTML content to render as a string.
+   */
+  children: string;
+};
+/**
+ * React component that renders HTML-like content to JSX.
+ *
+ * This component uses the components from the `HTMLProvider` context
+ * if available.
+ */
+declare const HTMLRenderer: FC<HTMLRendererProps>;
+//#endregion
+export { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLRenderer };
+//# sourceMappingURL=HTMLRenderer.d.ts.map

package/dist/types/html/HTMLRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;;cAuBa,qBAAA,EAAqB,MAAA,SAAA,kBAAA;AAAA,KAEtB,eAAA;EAFC;;;;EAOX,UAAA,GAAa,MAAA;AAAA;;;;;AASf;;cAAa,UAAA,GACX,OAAA;EACA;AAAA,IAAgB,eAAA,KACf,GAAA,CAAI,OAAA;;;;;;;cAyBM,eAAA;EAAmB;AAAA,IAAgB,eAAA,MAGtC,OAAA,aAAe,GAAA,CAAA,OAAA;AAAA,KAUb,iBAAA,GAAoB,eAAA;EAvCd;;;EA2ChB,QAAA;AAAA;AAjBF;;;;;;AAAA,cA0Ba,YAAA,EAAc,EAAA,CAAG,iBAAA"}

package/dist/types/html/HTMLRendererPlugin.d.ts

@@ -1,12 +1,7 @@
-import { FC, ReactNode } from "react";
+import { FC } from "react";
 import { KeyPath, Locale } from "@intlayer/types";
 
 //#region src/html/HTMLRendererPlugin.d.ts
-type HTMLTagComponent = (props: {
-  children?: ReactNode;
-  [key: string]: any;
-}) => ReactNode;
-declare const defaultHTMLComponents: Record<string, HTMLTagComponent>;
 type HTMLRendererPluginProps = {
   dictionaryKey: string;
   keyPath: KeyPath[];
@@ -16,5 +11,5 @@ type HTMLRendererPluginProps = {
 };
 declare const HTMLRendererPlugin: FC<HTMLRendererPluginProps>;
 //#endregion
-export { HTMLRendererPlugin, defaultHTMLComponents };
+export { HTMLRendererPlugin };
 //# sourceMappingURL=HTMLRendererPlugin.d.ts.map

package/dist/types/html/HTMLRendererPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"sourcesContent":[],"mappings":";;;;KASK,gBAAA;aACQ;EADR,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,GAAA;AAgBL,CAAA,EAAA,GAbM,SAaO;AAER,cAFQ,qBAEe,EAFM,MAEN,CAAA,MAAA,EAFM,gBAEN,CAAA;KAAvB,uBAAA,GAEM;EAEA,aAAA,EAAA,MAAA;EACQ,OAAA,EAHR,OAGQ,EAAA;EAAM,IAAA,EAAA,MAAA;EAGZ,MAAA,CAAA,EAJF,MAIE;mBAHM;;cAGN,oBAAoB,GAAG"}
+{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";;;;KAWK,uBAAA;EACH,aAAA;EACA,OAAA,EAAS,OAAA;EACT,IAAA;EACA,MAAA,GAAS,MAAA;EACT,cAAA,GAAiB,MAAA;AAAA;AAAA,cAGN,kBAAA,EAAoB,EAAA,CAAG,uBAAA"}

package/dist/types/html/index.d.ts

@@ -1,3 +1,5 @@
 import { HTMLProvider, useHTMLContext } from "./HTMLProvider.js";
-import { HTMLRendererPlugin, defaultHTMLComponents } from "./HTMLRendererPlugin.js";
-export { HTMLProvider, HTMLRendererPlugin, defaultHTMLComponents, useHTMLContext };
+import { ExtractTags, ReactComponentProps, ReactHTMLComponent, ReactHTMLComponentMap } from "./types.js";
+import { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLRenderer } from "./HTMLRenderer.js";
+import { HTMLRendererPlugin } from "./HTMLRendererPlugin.js";
+export { ExtractTags, HTMLProvider, HTMLRenderer, HTMLRendererPlugin, HTMLRendererProps, ReactComponentProps, ReactHTMLComponent, ReactHTMLComponentMap, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLContext, useHTMLRenderer };

package/dist/types/html/types.d.ts

@@ -0,0 +1,26 @@
+import { BaseHTMLProps, ExtractTags } from "@intlayer/core";
+import { ReactNode } from "react";
+
+//#region src/html/types.d.ts
+/**
+ * Props for React HTML components
+ * Extends base HTML props with ReactNode children
+ */
+interface ReactComponentProps extends BaseHTMLProps {
+  children?: ReactNode;
+}
+/**
+ * React HTML component function type
+ */
+type ReactHTMLComponent = (props: ReactComponentProps) => ReactNode;
+/**
+ * Component map type for React
+ * - Standard HTML tags are optional (Partial)
+ * - Custom components are required
+ */
+type ReactHTMLComponentMap<T = never> = (T extends Record<string, any> ? { [K in keyof T]: (props: T[K] & {
+  children?: ReactNode;
+}) => ReactNode } : T extends string ? { [K in T]: ReactHTMLComponent } : {}) & Partial<Record<string, ReactHTMLComponent>>;
+//#endregion
+export { type ExtractTags, ReactComponentProps, ReactHTMLComponent, ReactHTMLComponentMap };
+//# sourceMappingURL=types.d.ts.map

package/dist/types/html/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;;;;;AAOA;;UAAiB,mBAAA,SAA4B,aAAA;EAC3C,QAAA,GAAW,SAAA;AAAA;;;;KAMD,kBAAA,IAAsB,KAAA,EAAO,mBAAA,KAAwB,SAAA;AAAjE;;;;;AAAA,KAOY,qBAAA,eAAoC,CAAA,SAAU,MAAA,8BACxC,CAAA,IAAK,KAAA,EAAO,CAAA,CAAE,CAAA;EAAO,QAAA,GAAW,SAAA;AAAA,MAAgB,SAAA,KAC9D,CAAA,0BACU,CAAA,GAAI,kBAAA,WAEhB,OAAA,CAAQ,MAAA,SAAe,kBAAA"}

package/dist/types/index.d.ts

@@ -15,8 +15,10 @@ import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, use
 import { getDictionary } from "./getDictionary.js";
 import { getIntlayer } from "./getIntlayer.js";
 import { HTMLProvider } from "./html/HTMLProvider.js";
+import { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, renderHTML, useHTMLRenderer } from "./html/HTMLRenderer.js";
+import "./html/index.js";
 import { MarkdownProvider } from "./markdown/MarkdownProvider.js";
-import { MarkdownRenderer } from "./markdown/MarkdownRenderer.js";
+import { MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer } from "./markdown/MarkdownRenderer.js";
 import "./markdown/index.js";
 import { LocalesValues } from "@intlayer/types";
 
@@ -25,5 +27,5 @@ declare module '@intlayer/core' {
   interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginReact<T, S, L> {}
 }
 //#endregion
-export { HTMLProvider, IntlayerClientContext, type IntlayerNode, IntlayerProvider, IntlayerProviderContent, type IntlayerProviderProps, MarkdownProvider, MarkdownRenderer, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage };
+export { HTMLProvider, HTMLRenderer, type HTMLRendererProps, IntlayerClientContext, type IntlayerNode, IntlayerProvider, IntlayerProviderContent, type IntlayerProviderProps, MarkdownProvider, MarkdownRenderer, type MarkdownRendererProps, type RenderHTMLProps, type RenderMarkdownProps, getDictionary, getIntlayer, localeCookie, localeInStorage, renderHTML, renderMarkdown, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useHTMLRenderer, useI18n, useIntl, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage, useMarkdownRenderer };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;+CAI+C,uBACnC,wBAAwB,GAAG,GAAG"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,kBAAA,iBAAmC,aAAA,UACnC,uBAAA,CAAwB,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA"}

package/dist/types/markdown/MarkdownProvider.d.ts

@@ -2,51 +2,49 @@ import { Overrides } from "@intlayer/core";
 import { FC, PropsWithChildren, ReactNode } from "react";
 
 //#region src/markdown/MarkdownProvider.d.ts
-type RenderMarkdownOptions = {
+type MarkdownProviderOptions = {
+  /** Forces the compiler to always output content with a block-level wrapper. */forceBlock?: boolean; /** Forces the compiler to always output content with an inline wrapper. */
+  forceInline?: boolean; /** Whether to preserve frontmatter in the markdown content. */
+  preserveFrontmatter?: boolean; /** Whether to use the GitHub Tag Filter for security. */
+  tagfilter?: boolean;
+};
+type RenderMarkdownOptions = MarkdownProviderOptions & {
   components?: Overrides;
-  wrapper?: FC;
-  options?: MarkdownProviderOptions;
+  wrapper?: FC<any>;
 };
 type MarkdownContextValue = {
   renderMarkdown: (markdown: string, components?: Overrides | RenderMarkdownOptions) => ReactNode;
 };
-/**
- * Refined options for the MarkdownProvider.
- */
-type MarkdownProviderOptions = {
-  /**
-   * Forces the compiler to always output content with a block-level wrapper.
-   */
-  forceBlock?: boolean;
-  /**
-   * Whether to preserve frontmatter in the markdown content.
-   */
-  preserveFrontmatter?: boolean;
-  /**
-   * Whether to use the GitHub Tag Filter.
-   */
-  tagfilter?: boolean;
-};
-type MarkdownProviderProps = PropsWithChildren<{
-  /**
-   * Component overrides for HTML tags.
-   */
+type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
   components?: Overrides;
-  /**
-   * Wrapper element or component to be used when there are multiple children.
-   */
   wrapper?: any;
-  /**
-   * Markdown processor options.
-   */
-  options?: MarkdownProviderOptions;
-  /**
-   * Custom render function for markdown.
-   * If provided, it will overwrite all rules and default rendering.
-   */
-  renderMarkdown?: (markdown: string, overrides?: Overrides) => ReactNode;
+  renderMarkdown?: (markdown: string, overrides?: Overrides | RenderMarkdownOptions) => ReactNode;
 }>;
 declare const useMarkdownContext: () => MarkdownContextValue;
+/**
+ * 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>
+ * ```
+ */
 declare const MarkdownProvider: FC<MarkdownProviderProps>;
 //#endregion
 export { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext };

package/dist/types/markdown/MarkdownProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":[],"mappings":";;;;KAYK,qBAAA;eACU;EADV,OAAA,CAAA,EAEO,EAFP;EACU,OAAA,CAAA,EAEH,uBAFG;CACH;KAIP,oBAAA,GAHO;EAAuB,cAAA,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,UAAA,CAAA,EAMlB,SANkB,GAMN,qBANM,EAAA,GAO5B,SAP4B;AAAA,CAAA;;;;AAOnB,KAMJ,uBAAA,GANI;EAMJ;AAaV;;EAcU,UAAA,CAAA,EAAA,OAAA;EAKsC;;;EAjBJ,mBAAA,CAAA,EAAA,OAAA;EAwBjC;AAEb;;;;KA1BK,qBAAA,GAAwB;;;;eAId;;;;;;;;YAQH;;;;;kDAKsC,cAAc;;cAOnD,0BAAkB;cAElB,kBAAkB,GAAG"}
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KAYY,uBAAA;iFAEV,UAAA,YAFiC;EAIjC,WAAA,YAJiC;EAMjC,mBAAA,YAFA;EAIA,SAAA;AAAA;AAAA,KAGG,qBAAA,GAAwB,uBAAA;EAC3B,UAAA,GAAa,SAAA;EACb,OAAA,GAAU,EAAA;AAAA;AAAA,KAGP,oBAAA;EACH,cAAA,GACE,QAAA,UACA,UAAA,GAAa,SAAA,GAAY,qBAAA,KACtB,SAAA;AAAA;AAAA,KAGF,qBAAA,GAAwB,iBAAA,CAC3B,uBAAA;EACE,UAAA,GAAa,SAAA;EACb,OAAA;EACA,cAAA,IACE,QAAA,UACA,SAAA,GAAY,SAAA,GAAY,qBAAA,KACrB,SAAA;AAAA;AAAA,cAQI,kBAAA,QAAkB,oBAAA;;;;;AAzBjB;;;;;;;;;;;;;;;;AAOE;;;;cAsGH,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}

package/dist/types/markdown/MarkdownRenderer.d.ts

@@ -1,36 +1,258 @@
 import { MarkdownProviderOptions } from "./MarkdownProvider.js";
 import { Overrides } from "@intlayer/core";
-import { FC } from "react";
+import * as react0 from "react";
+import { FC, JSX, ReactNode } from "react";
 
 //#region src/markdown/MarkdownRenderer.d.ts
-type MarkdownRendererProps = {
-  /**
-   * The markdown content to render.
-   */
-  children: string;
+/**
+ * Props for rendering markdown content.
+ *
+ * @example
+ * ```tsx
+ * const props: RenderMarkdownProps = {
+ *   components: {
+ *     h1: ({ children }) => <h1 className="text-3xl">{children}</h1>,
+ *     p: ({ children }) => <p className="text-gray-700">{children}</p>,
+ *   },
+ *   wrapper: ({ children }) => <article>{children}</article>,
+ *   options: {
+ *     forceBlock: true,
+ *     preserveFrontmatter: false,
+ *     tagfilter: true,
+ *   },
+ * };
+ * ```
+ */
+type RenderMarkdownProps = MarkdownProviderOptions & {
   /**
    * Component overrides for HTML tags.
+   * Allows you to customize how specific HTML elements are rendered.
    * Only used if not wrapped in a MarkdownProvider.
+   *
+   * @example
+   * ```tsx
+   * components={{
+   *   h1: ({ children }) => <h1 className="title">{children}</h1>,
+   *   a: ({ href, children }) => <Link to={href}>{children}</Link>,
+   * }}
+   * ```
    */
   components?: Overrides;
   /**
    * Wrapper element or component to be used when there are multiple children.
    * Only used if not wrapped in a MarkdownProvider.
+   *
+   * @example
+   * ```tsx
+   * wrapper={({ children }) => <div className="markdown-content">{children}</div>}
+   * ```
    */
   wrapper?: FC;
+};
+/**
+ * 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,
+ * });
+ * ```
+ */
+declare const renderMarkdown: (content: string, {
+  components,
+  wrapper,
+  forceBlock,
+  forceInline,
+  preserveFrontmatter,
+  tagfilter
+}?: RenderMarkdownProps) => JSX.Element;
+/**
+ * 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>
+ *   );
+ * }
+ * ```
+ */
+declare const useMarkdownRenderer: ({
+  components,
+  wrapper,
+  forceBlock,
+  forceInline,
+  preserveFrontmatter,
+  tagfilter
+}?: RenderMarkdownProps) => (content: string) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react0.ReactPortal | react0.ReactElement<unknown, string | react0.JSXElementConstructor<any>> | Iterable<ReactNode>> | JSX.Element;
+/**
+ * Props for the MarkdownRenderer component.
+ *
+ * @example
+ * ```tsx
+ * const props: MarkdownRendererProps = {
+ *   children: '# Hello World\n\nThis is **bold** text.',
+ *   components: {
+ *     h1: ({ children }) => <h1 className="title">{children}</h1>,
+ *   },
+ *   wrapper: ({ children }) => <article>{children}</article>,
+ *   forceBlock: true,
+ * };
+ * ```
+ */
+type MarkdownRendererProps = RenderMarkdownProps & {
   /**
-   * Markdown processor options.
-   * Only used if not wrapped in a MarkdownProvider.
+   * The markdown content to render as a string.
+   *
+   * @example
+   * ```tsx
+   * <MarkdownRenderer>
+   *   {`# Title\n\nParagraph with **bold** text.`}
+   * </MarkdownRenderer>
+   * ```
    */
-  options?: MarkdownProviderOptions;
+  children: string;
+  /**
+   * Custom render function for markdown.
+   * If provided, it will overwrite context and default rendering.
+   *
+   * @param markdown - The markdown string to render
+   * @param options - Optional rendering options
+   * @returns React node representing the rendered markdown
+   *
+   * @example
+   * ```tsx
+   * <MarkdownRenderer
+   *   renderMarkdown={(md, opts) => {
+   *     // Custom rendering logic
+   *     return <div dangerouslySetInnerHTML={{ __html: customParser(md) }} />;
+   *   }}
+   * >
+   *   {markdownContent}
+   * </MarkdownRenderer>
+   * ```
+   */
+  renderMarkdown?: (markdown: string, options?: {
+    components?: Overrides;
+    wrapper?: FC;
+    forceBlock?: boolean;
+    forceInline?: boolean;
+    preserveFrontmatter?: boolean;
+    tagfilter?: boolean;
+  }) => ReactNode;
 };
 /**
- * React component that renders markdown to JSX.
+ * 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>
+ * ```
  *
- * It uses the renderMarkdown function from the MarkdownProvider context if available.
- * Otherwise, it falls back to the default compiler with provided components and options.
+ * @example
+ * ```tsx
+ * // With MarkdownProvider context
+ * function App() {
+ *   return (
+ *     <MarkdownProvider
+ *       components={{ h1: CustomHeading }}
+ *       forceBlock={true}
+ *     >
+ *       <MarkdownRenderer>
+ *         {markdownContent}
+ *       </MarkdownRenderer>
+ *     </MarkdownProvider>
+ *   );
+ * }
+ * ```
  */
 declare const MarkdownRenderer: FC<MarkdownRendererProps>;
 //#endregion
-export { MarkdownRenderer };
+export { MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer };
 //# sourceMappingURL=MarkdownRenderer.d.ts.map

package/dist/types/markdown/MarkdownRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"sourcesContent":[],"mappings":";;;;;KAQK,qBAAA;;AAHuB;;EAiBhB,QAAA,EAAA,MAAA;EAKA;;AASZ;;eAnBe;;;;;YAKH;;;;;YAKA;;;;;;;;cASC,kBAAkB,GAAG"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;;AA2BA;;;;;;;;;;;;;;;AAoDA;KApDY,mBAAA,GAAsB,uBAAA;;;;;;;;;;;;;;EAchC,UAAA,GAAa,SAAA;EAwCb;;;;;;;;;EA9BA,OAAA,GAAU,EAAA;AAAA;;;;;AAkGZ;;;;;;;;;;;;;;;;;;;;;cAtEa,cAAA,GACX,OAAA;EACA,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOG,mBAAA,KACF,GAAA,CAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GP;;;;;;;;;;;;;;;;;;;;cAhDa,mBAAA;EAAuB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOjC,mBAAA,MAGO,OAAA,kDAAe,QAAA,CAAA,SAAA,IAAA,OAAA,sCAAA,MAAA,CAAA,WAAA,GAAA,MAAA,CAAA,YAAA,mBAAA,MAAA,CAAA,qBAAA,SAAA,QAAA,CAAA,SAAA,KAAA,GAAA,CAAA,OAAA;;;;;AAgJzB;;;;;;;;;;;KA1GY,qBAAA,GAAwB,mBAAA;;;;;;;;;;;EAWlC,QAAA;;;;;;;;;;;;;;;;;;;;;EAqBA,cAAA,IACE,QAAA,UACA,OAAA;IACE,UAAA,GAAa,SAAA;IACb,OAAA,GAAU,EAAA;IACV,UAAA;IACA,WAAA;IACA,mBAAA;IACA,SAAA;EAAA,MAEC,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgEM,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}

package/dist/types/markdown/MarkdownRendererPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"sourcesContent":[],"mappings":";;;;KAaK,2BAAA;;EAAA,OAAA,EAEM,OAFN,EAAA;EAQQ,MAAA,CAAA,EALF,aAKE;EAkBR,QAAA,EAAA,MAAA;EAIQ,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,GAAA;;cAtBA,wBAAwB,GAAG;KAkBnC,6BAAA,GAAgC;mBAClB;;cAGN,0BAA0B,GAAG"}
+{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;KASK,2BAAA;EACH,aAAA;EACA,OAAA,EAAS,OAAA;EACT,MAAA,GAAS,aAAA;EACT,QAAA;EAAA,CACC,GAAA;AAAA;AAAA,cAGU,sBAAA,EAAwB,EAAA,CAAG,2BAAA;AAAA,KAkBnC,6BAAA,GAAgC,2BAAA;EACnC,eAAA,EAAiB,OAAA;AAAA;AAAA,cAGN,wBAAA,EAA0B,EAAA,CAAG,6BAAA"}

package/dist/types/markdown/index.d.ts

@@ -1,6 +1,6 @@
 import { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext } from "./MarkdownProvider.js";
-import { MarkdownRenderer } from "./MarkdownRenderer.js";
+import { MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.js";
 import { MarkdownMetadataRenderer, MarkdownRendererPlugin } from "./MarkdownRendererPlugin.js";
 import { LegacyMarkdownRenderer, MarkdownRendererOptions, Overrides as CoreOverrides, ParseState, ParserResult, RuleOutput, RuleType, State, compile, compileMarkdown, compiler, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "./processor.js";
 import reactRuntime, { createReactRuntime } from "./runtime.js";
-export { LegacyMarkdownRenderer, MarkdownMetadataRenderer, MarkdownProvider, MarkdownProviderOptions, MarkdownRenderer, MarkdownRendererOptions, MarkdownRendererPlugin, CoreOverrides as Overrides, ParseState, ParserResult, RuleOutput, RuleType, State, compile, compileMarkdown, compiler, createReactRuntime, reactRuntime, defaultSanitizer as sanitizer, defaultSlugify as slugify, useMarkdownContext };
+export { LegacyMarkdownRenderer, MarkdownMetadataRenderer, MarkdownProvider, MarkdownProviderOptions, MarkdownRenderer, MarkdownRendererOptions, MarkdownRendererPlugin, MarkdownRendererProps, CoreOverrides as Overrides, ParseState, ParserResult, RenderMarkdownProps, RuleOutput, RuleType, State, compile, compileMarkdown, compiler, createReactRuntime, reactRuntime, renderMarkdown, defaultSanitizer as sanitizer, defaultSlugify as slugify, useMarkdownContext, useMarkdownRenderer };

package/dist/types/markdown/processor.d.ts

@@ -2,7 +2,6 @@ import { Overrides as CoreOverrides, ParseState, ParserResult, RenderRuleHook, R
 import { FC, HTMLAttributes, JSX, ReactNode, createElement } from "react";
 
 //#region src/markdown/processor.d.ts
-
 type HTMLTags = keyof JSX.IntrinsicElements;
 type State = ParseState;
 /**

package/dist/types/markdown/processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"sourcesContent":[],"mappings":";;;;;KAoCK,QAAA,GAaU,MAbO,GAAA,CAAI,iBAaX;KAXV,KAAA,GAAQ,UAYI;;;;AAuDiB,KA9DtB,uBAAA,GAA0B,OA8DJ,CAAA;EA9DI;;AAmGtC;EAmDa,aAA0B,EAAA,CAAA,GAAA,EAjJ9B,UAgGE,CAAA,OAhGgB,aAiGpB,CAAA,CAAA,CAAA,CAAA,EAAA,KAgDgC,EAhJ5B,GAAA,CAAI,mBAgJwB,EAAA,GAAA,QAAA,EA/ItB,SA+IsB,EAAA,EAAA,GA9IhC,SA8IgC;EAC1B;AAKb;;;EACE,eAAA,EAAA,OAAA;EAEY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA3GA;;;;cAKA;;;;kCAKoB;;;;;;;;;;;;;;;;;;;;;;cAqCrB,+CAEF,4BACR,GAAA,CAAI;cAgDM,wCAjDF,4BACR,GAAA,CAAI;cAiDM,uCAlDF,4BACR,GAAA,CAAI;;;;cAsDM,wBAAwB,GACnC,KAAK,eAAe;;YAER"}
+{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;KA8BK,QAAA,SAAiB,GAAA,CAAI,iBAAA;AAAA,KAErB,KAAA,GAAQ,UAAA;;;;KAKD,uBAAA,GAA0B,OAAA;EAL5B;;;EASR,aAAA,GACE,GAAA,EAAK,UAAA,QAAkB,aAAA,MACvB,KAAA,EAAO,GAAA,CAAI,mBAAA,KACR,QAAA,EAAU,SAAA,OACV,SAAA;EARK;;;;EAcV,eAAA;EARS;;;;EAcT,qBAAA;EA0CgC;;;EArChC,kBAAA;EAzBoC;;;EA8BpC,UAAA;EAzBE;;;EA8BF,WAAA;EA5BK;;;EAiCL,YAAA;EApBA;;;EAyBA,mBAAA;IAAA,CACG,GAAA;EAAA;EAAA;;;EAMH,UAAA,EAAY,aAAA;EAKA;;;EAAZ,UAAA,EAAY,cAAA;EAKe;;;EAA3B,SAAA,GAAY,KAAA,UAAe,GAAA,EAAK,QAAA,EAAU,SAAA;EAU1C;;;EALA,OAAA,GAAU,KAAA;EAeD;AAiBX;;EA3BE,OAAA;EA2ED;;;EAtEC,mBAAA;EAyBC;;;EApBD,SAAA;AAAA;;;;;cAiBW,eAAA,GACX,QAAA,WACA,OAAA,GAAS,uBAAA,KACR,GAAA,CAAI,OAAA;AAAA,cAgDM,QAAA,GAAQ,QAAA,WAlDH,OAAA,GACP,uBAAA,KACR,GAAA,CAAI,OAAA;AAAA,cAiDM,OAAA,GAAO,QAAA,WAnDF,OAAA,GACP,uBAAA,KACR,GAAA,CAAI,OAAA;;;;cAsDM,sBAAA,EAAwB,EAAA,CACnC,IAAA,CAAK,cAAA,CAAe,OAAA;EAClB,QAAA;EACA,OAAA,GAAU,uBAAA;AAAA"}

package/dist/types/markdown/runtime.d.ts

@@ -2,7 +2,6 @@ import { MarkdownRuntime } from "@intlayer/core";
 import { ReactNode } from "react";
 
 //#region src/markdown/runtime.d.ts
-
 /**
  * React-specific runtime for the markdown processor.
  * Implements the MarkdownRuntime interface using React's primitives.

package/dist/types/markdown/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAuBa,cAAc;;;;;cA6Dd;gDAIA,gDAEJ;MAEN"}
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;;;;cAuBa,YAAA,EAAc,eAAA;;;;;cA6Dd,kBAAA,GACX,OAAA;EACE,eAAA,IACE,IAAA,gBACA,KAAA,EAAO,MAAA,sBACP,QAAA,YACG,SAAA;AAAA,MAEN,eAAA"}

package/dist/types/plugins.d.ts

@@ -1,10 +1,9 @@
 import { IntlayerNode } from "./IntlayerNode.js";
 import { DeepTransformContent as DeepTransformContent$1, HTMLCond, IInterpreterPluginState as IInterpreterPluginState$1, Plugins } from "@intlayer/core";
-import { ReactNode } from "react";
+import { ComponentType, ElementType, ReactNode } from "react";
 import { DeclaredLocales, LocalesValues, NodeType } from "@intlayer/types";
 
 //#region src/plugins.d.ts
-
 /** ---------------------------------------------
  *  INTLAYER NODE PLUGIN
  *  --------------------------------------------- */
@@ -20,20 +19,32 @@ type ReactNodeCond<T> = T extends {
 } ? ReactNode : never;
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
 declare const reactNodePlugins: Plugins;
+/** ---------------------------------------------
+ *  INSERTION PLUGIN
+ *  --------------------------------------------- */
+type InsertionCond<T, S, L> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Insertion]: string;
+  fields: readonly string[];
+} ? (values: { [K in T['fields'][number]]: ReactNode }) => ReactNode : never;
+/** Insertion plugin for React. Handles component/node insertion. */
+declare const insertionPlugin: Plugins;
 /**
  * MARKDOWN PLUGIN
  */
 type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
   metadata: DeepTransformContent<string>;
+  use: (components: any) => any;
 }> : never;
 /** Markdown string plugin. Replaces string node with a component that render the markdown. */
 declare const markdownStringPlugin: Plugins;
+type MarkdownComponentMap = Record<string, ComponentType<any> | ElementType>;
 type MarkdownCond<T, S, L extends LocalesValues> = T extends {
   nodeType: NodeType | string;
   [NodeType.Markdown]: infer M;
   metadata?: infer U;
 } ? {
-  use: (components: any) => any;
+  use: (components?: MarkdownComponentMap) => ReactNode;
   metadata: DeepTransformContent<U, L>;
 } & any : never;
 declare const markdownPlugin: Plugins;
@@ -49,6 +60,7 @@ declare const htmlPlugin: Plugins;
 interface IInterpreterPluginReact<T, S, L extends LocalesValues> {
   reactNode: ReactNodeCond<T>;
   reactIntlayerNode: IntlayerNodeCond<T>;
+  reactInsertion: InsertionCond<T, S, L>;
   reactMarkdown: MarkdownCond<T, S, L>;
   reactHtml: HTMLPluginCond<T, S, L>;
 }
@@ -60,10 +72,11 @@ interface IInterpreterPluginReact<T, S, L extends LocalesValues> {
 type IInterpreterPluginState = IInterpreterPluginState$1 & {
   reactNode: true;
   reactIntlayerNode: true;
+  reactInsertion: true;
   reactMarkdown: true;
   reactHtml: true;
 };
 type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContent$1<T, IInterpreterPluginState, L>;
 //#endregion
-export { DeepTransformContent, HTMLPluginCond, IInterpreterPluginReact, IInterpreterPluginState, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, ReactNodeCond, htmlPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin, reactNodePlugins };
+export { DeepTransformContent, HTMLPluginCond, IInterpreterPluginReact, IInterpreterPluginState, InsertionCond, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, ReactNodeCond, htmlPlugin, insertionPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin, reactNodePlugins };
 //# sourceMappingURL=plugins.d.ts.map

package/dist/types/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;AA2BA;AAAkC,KAAtB,gBAAsB,CAAA,CAAA,CAAA,GAAA,CAAA,SAAA,MAAA,GAAA,MAAA,GAC9B,YAD8B,CACjB,CADiB,CAAA,GAAA,KAAA;;AAC9B,cAIS,mBAJT,EAI8B,OAJ9B;;AAIJ;AA0BA;AAQa,KARD,aA+BX,CAAA,CAAA,CAAA,GA/B8B,CA+B9B,SAvB8B;EA6BnB,KAAA,EAAA,GAAA;EAAwB,GAAA,EAAA,GAAA;CACC,GAlCjC,SAkCiC,GAAA,KAAA;;AAArB,cA9BH,gBA8BG,EA9Be,OA8Bf;AAIhB;AA+EA;;AAA0D,KApF9C,kBAoF8C,CAAA,CAAA,CAAA,GApFtB,CAoFsB,SAAA,MAAA,GAnFtD,YAmFsD,CAAA,MAAA,EAAA;EAC9C,QAAA,EApFyB,oBAoFzB,CAAA,MAAA,CAAA;CACT,CAAA,GAAA,KAAS;;AAK4B,cAtF3B,oBAsF2B,EAtFL,OAsFK;AAAxB,KAPJ,YAOI,CAAA,CAAA,EAAA,CAAA,EAAA,UAPyB,aAOzB,CAAA,GAP0C,CAO1C,SAAA;EAAoB,QAAA,EANxB,QAMwB,GAAA,MAAA;EAIvB,CATV,QAAA,CAAS,QAAA,CA+BX,EAAA,KAAA,EAAA;EAMW,QAAA,CAAA,EAAA,KAAc,EAAA;CAAqB,GAAA;EAAG,GAAA,EAAA,CAAA,UAAA,EAAA,GAAA,EAAA,GAAA,GAAA;EAAG,QAAA,EAhCrC,oBAgCqC,CAhChB,CAgCgB,EAhCb,CAgCa,CAAA;CAAf,GAAA,GAAA,GAAA,KAAA;AAAQ,cA5BjC,cA4BiC,EA5BjB,OA4BiB;AAG9C;AAoCA;;AAC2B,KAxCf,cAwCe,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,GAxCW,QAwCX,CAxCoB,CAwCpB,EAxCuB,CAwCvB,EAxC0B,CAwC1B,CAAA;;AACW,cAtCzB,UAsCyB,EAtCb,OAsCa;;;;AACF,UAHnB,uBAGmB,CAAA,CAAA,EAAA,CAAA,EAAA,UAHqB,aAGrB,CAAA,CAAA;EAAnB,SAAA,EAFJ,aAEI,CAFU,CAEV,CAAA;EACW,iBAAA,EAFP,gBAEO,CAFU,CAEV,CAAA;EAAG,aAAA,EADd,YACc,CADD,CACC,EADE,CACF,EADK,CACL,CAAA;EAAG,SAAA,EAArB,cAAqB,CAAN,CAAM,EAAH,CAAG,EAAA,CAAA,CAAA;;;AAQlC;AAOA;;;AAG6B,KAVjB,uBAAA,GAA0B,yBAUT,GAAA;EAAG,SAAA,EAAA,IAAA;EAAyB,iBAAA,EAAA,IAAA;EAArD,aAAA,EAAA,IAAA;EAAwB,SAAA,EAAA,IAAA;;KAHhB,kCAEA,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;AAqCA;KAAY,gBAAA,MAAsB,CAAA,2BAC9B,YAAA,CAAa,CAAA;;cAIJ,mBAAA,EAAqB,OAAA;;;;KA0BtB,aAAA,MAAmB,CAAA;EAC7B,KAAA;EACA,GAAA;AAAA,IAEE,SAAA;;cAIS,gBAAA,EAAkB,OAAA;;AAlC/B;;KA+DY,aAAA,YAAyB,CAAA;EACnC,QAAA,EAAU,QAAA;EAAA,CACT,QAAA,CAAS,SAAA;EACV,MAAA;AAAA,KAGI,MAAA,UACQ,CAAA,qBAAsB,SAAA,OAE3B,SAAA;;cA4BI,eAAA,EAAiB,OAAA;;;;KA6DlB,kBAAA,MAAwB,CAAA,kBAChC,YAAA;EAEI,QAAA,EAAU,oBAAA;EAA8B,GAAA,GAAM,UAAA;AAAA;;cAKzC,oBAAA,EAAsB,OAAA;AAAA,KA+E9B,oBAAA,GAAuB,MAAA,SAAe,aAAA,QAAqB,WAAA;AAAA,KAEpD,YAAA,iBAA6B,aAAA,IAAiB,CAAA;EACxD,QAAA,EAAU,QAAA;EAAA,CACT,QAAA,CAAS,QAAA;EACV,QAAA;AAAA;EAGI,GAAA,GAAM,UAAA,GAAa,oBAAA,KAAyB,SAAA;EAC5C,QAAA,EAAU,oBAAA,CAAqB,CAAA,EAAG,CAAA;AAAA;AAAA,cAI3B,cAAA,EAAgB,OAAA;;;;KA2BjB,cAAA,YAA0B,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA;;cAGxC,UAAA,EAAY,OAAA;;;;UAiDR,uBAAA,iBAAwC,aAAA;EACvD,SAAA,EAAW,aAAA,CAAc,CAAA;EACzB,iBAAA,EAAmB,gBAAA,CAAiB,CAAA;EACpC,cAAA,EAAgB,aAAA,CAAc,CAAA,EAAG,CAAA,EAAG,CAAA;EACpC,aAAA,EAAe,YAAA,CAAa,CAAA,EAAG,CAAA,EAAG,CAAA;EAClC,SAAA,EAAW,cAAA,CAAe,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA;;;;AArPlC;;KA6PY,uBAAA,GAA0B,yBAAA;EACpC,SAAA;EACA,iBAAA;EACA,cAAA;EACA,aAAA;EACA,SAAA;AAAA;AAAA,KAGU,oBAAA,cAEA,aAAA,GAAgB,eAAA,IACxB,sBAAA,CAAyB,CAAA,EAAG,uBAAA,EAAyB,CAAA"}