react-intlayer 7.6.0-canary.0 → 8.0.0-canary.2

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,5 @@
+import { HTMLProvider, useHTMLContext } from "./HTMLProvider.js";
+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

@@ -1,5 +1,6 @@
 import { IntlayerNode } from "./IntlayerNode.js";
 import { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, IntlayerProviderProps, useIntlayerContext } from "./client/IntlayerProvider.js";
+import { useIntl } from "./client/format/useIntl.js";
 import { t } from "./client/t.js";
 import { IInterpreterPluginReact } from "./plugins.js";
 import { useDictionary } from "./client/useDictionary.js";
@@ -13,13 +14,18 @@ import { useLocaleBase } from "./client/useLocaleBase.js";
 import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage } from "./client/useLocaleStorage.js";
 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, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer } from "./markdown/MarkdownRenderer.js";
 import "./markdown/index.js";
+import { LocalesValues } from "@intlayer/types";
 
 //#region src/index.d.ts
 declare module '@intlayer/core' {
-  interface IInterpreterPlugin<T, S, L> extends IInterpreterPluginReact<T> {}
+  interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginReact<T, S, L> {}
 }
 //#endregion
-export { IntlayerClientContext, type IntlayerNode, IntlayerProvider, IntlayerProviderContent, type IntlayerProviderProps, MarkdownProvider, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, 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":";;;;;;;;;;;;;;;;;;;;gDAIgD,wBAAwB"}
+{"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

@@ -1,12 +1,51 @@
+import { Overrides } from "@intlayer/core";
 import { FC, PropsWithChildren, ReactNode } from "react";
 
 //#region src/markdown/MarkdownProvider.d.ts
+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<any>;
+};
 type MarkdownContextValue = {
-  renderMarkdown: (markdown: string) => ReactNode;
+  renderMarkdown: (markdown: string, components?: Overrides | RenderMarkdownOptions) => ReactNode;
 };
-type MarkdownProviderProps = PropsWithChildren<MarkdownContextValue>;
+type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
+  components?: Overrides;
+  wrapper?: any;
+  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, useMarkdownContext };
+export { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext };
 //# sourceMappingURL=MarkdownProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":[],"mappings":";;;KAUK,oBAAA;wCACmC;AAHzB,CAAA;AAGkC,KAG5C,qBAAA,GAAwB,iBAAkB,CAAA,oBAAlB,CAAA;AAMhB,cAAA,kBAAkB,EAAA,GAAA,GAAA,oBAAoC;AAEtD,cAAA,gBAAqB,EAAH,EAAG,CAAA,qBAAD,CAAA"}
+{"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,18 +1,258 @@
-import { FC } from "react";
-import { KeyPath, LocalesValues } from "@intlayer/types";
+import { MarkdownProviderOptions } from "./MarkdownProvider.js";
+import { Overrides } from "@intlayer/core";
+import * as react0 from "react";
+import { FC, JSX, ReactNode } from "react";
 
 //#region src/markdown/MarkdownRenderer.d.ts
-type MarkdownRendererProps = {
-  dictionaryKey: string;
-  keyPath: KeyPath[];
-  locale?: LocalesValues;
+/**
+ * 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 & {
+  /**
+   * The markdown content to render as a string.
+   *
+   * @example
+   * ```tsx
+   * <MarkdownRenderer>
+   *   {`# Title\n\nParagraph with **bold** text.`}
+   * </MarkdownRenderer>
+   * ```
+   */
   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 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>
+ *   );
+ * }
+ * ```
+ */
 declare const MarkdownRenderer: FC<MarkdownRendererProps>;
-type MarkdownMetadataRendererProps = MarkdownRendererProps & {
-  metadataKeyPath: KeyPath[];
-};
-declare const MarkdownMetadataRenderer: FC<MarkdownMetadataRendererProps>;
 //#endregion
-export { MarkdownMetadataRenderer, 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":";;;;KAaK,qBAAA;;EAAA,OAAA,EAEM,OAFN,EAAA;EAOQ,MAAA,CAAA,EAJF,aAuCV;EAEI,QAAA,EAAA,MAAA;AAIL,CAAA;cAzCa,kBAAkB,GAAG;KAqC7B,6BAAA,GAAgC;mBAClB;;cAGN,0BAA0B,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

@@ -0,0 +1,19 @@
+import { FC } from "react";
+import { KeyPath, LocalesValues } from "@intlayer/types";
+
+//#region src/markdown/MarkdownRendererPlugin.d.ts
+type MarkdownRendererPluginProps = {
+  dictionaryKey: string;
+  keyPath: KeyPath[];
+  locale?: LocalesValues;
+  children: string;
+  [key: string]: any;
+};
+declare const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps>;
+type MarkdownMetadataRendererProps = MarkdownRendererPluginProps & {
+  metadataKeyPath: KeyPath[];
+};
+declare const MarkdownMetadataRenderer: FC<MarkdownMetadataRendererProps>;
+//#endregion
+export { MarkdownMetadataRenderer, MarkdownRendererPlugin };
+//# sourceMappingURL=MarkdownRendererPlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"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,3 +1,6 @@
-import { MarkdownProvider, useMarkdownContext } from "./MarkdownProvider.js";
-import { MarkdownMetadataRenderer, MarkdownRenderer } from "./MarkdownRenderer.js";
-export { MarkdownMetadataRenderer, MarkdownProvider, MarkdownRenderer, useMarkdownContext };
+import { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext } from "./MarkdownProvider.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, 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

@@ -0,0 +1,92 @@
+import { Overrides as CoreOverrides, ParseState, ParserResult, RenderRuleHook, RuleOutput, RuleType, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core";
+import { FC, HTMLAttributes, JSX, ReactNode, createElement } from "react";
+
+//#region src/markdown/processor.d.ts
+type HTMLTags = keyof JSX.IntrinsicElements;
+type State = ParseState;
+/**
+ * Refined MarkdownRendererOptions type.
+ */
+type MarkdownRendererOptions = Partial<{
+  /**
+   * Ultimate control over the output of all rendered JSX.
+   */
+  createElement: (tag: Parameters<typeof createElement>[0], props: JSX.IntrinsicAttributes, ...children: ReactNode[]) => ReactNode;
+  /**
+   * The library automatically generates an anchor tag for bare URLs included in the markdown
+   * document, but this behavior can be disabled if desired.
+   */
+  disableAutoLink: boolean;
+  /**
+   * Disable the compiler's best-effort transcription of provided raw HTML
+   * into JSX-equivalent.
+   */
+  disableParsingRawHTML: boolean;
+  /**
+   * Forces the compiler to have space between hash sign and the header text.
+   */
+  enforceAtxHeadings: boolean;
+  /**
+   * 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;
+  /**
+   * Forces the compiler to wrap results, even if there is only a single child.
+   */
+  forceWrapper: boolean;
+  /**
+   * Supply additional HTML entity: unicode replacement mappings.
+   */
+  namedCodesToUnicode: {
+    [key: string]: string;
+  };
+  /**
+   * Selectively control the output of particular HTML tags.
+   */
+  components: CoreOverrides;
+  /**
+   * Allows for full control over rendering of particular rules.
+   */
+  renderRule: RenderRuleHook;
+  /**
+   * Override the built-in sanitizer function for URLs.
+   */
+  sanitizer: (value: string, tag: HTMLTags, attribute: string) => string | null;
+  /**
+   * Override normalization of non-URI-safe characters for anchor linking.
+   */
+  slugify: (input: string) => string;
+  /**
+   * Declare the type of the wrapper to be used when there are multiple children.
+   */
+  wrapper: any | null;
+  /**
+   * Whether to preserve frontmatter in the markdown content.
+   */
+  preserveFrontmatter: boolean;
+  /**
+   * Whether to use the GitHub Tag Filter.
+   */
+  tagfilter: boolean;
+}>;
+/**
+ * Compile markdown to React elements.
+ * This is the primary export - use this for new code.
+ */
+declare const compileMarkdown: (markdown?: string, options?: MarkdownRendererOptions) => JSX.Element;
+declare const compiler: (markdown?: string, options?: MarkdownRendererOptions) => JSX.Element;
+declare const compile: (markdown?: string, options?: MarkdownRendererOptions) => JSX.Element;
+/**
+ * React component that renders markdown to JSX (legacy).
+ */
+declare const LegacyMarkdownRenderer: FC<Omit<HTMLAttributes<Element>, 'children'> & {
+  children: string;
+  options?: MarkdownRendererOptions;
+}>;
+//#endregion
+export { LegacyMarkdownRenderer, MarkdownRendererOptions, type CoreOverrides as Overrides, type ParseState, type ParserResult, type RuleOutput, RuleType, type State, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
+//# sourceMappingURL=processor.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,19 @@
+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.
+ */
+declare const reactRuntime: MarkdownRuntime;
+/**
+ * Creates a React runtime with custom createElement for advanced use cases.
+ * Useful for wrapping elements or adding middleware.
+ */
+declare const createReactRuntime: (options?: {
+  onCreateElement?: (type: string | any, props: Record<string, any> | null, children: any[]) => ReactNode;
+}) => MarkdownRuntime;
+//#endregion
+export { createReactRuntime, reactRuntime as default, reactRuntime };
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"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, IInterpreterPluginState as IInterpreterPluginState$1, Plugins } from "@intlayer/core";
-import { ReactNode } from "react";
+import { DeepTransformContent as DeepTransformContent$1, HTMLCond, IInterpreterPluginState as IInterpreterPluginState$1, Plugins } from "@intlayer/core";
+import { ComponentType, ElementType, ReactNode } from "react";
 import { DeclaredLocales, LocalesValues, NodeType } from "@intlayer/types";
 
 //#region src/plugins.d.ts
-
 /** ---------------------------------------------
  *  INTLAYER NODE PLUGIN
  *  --------------------------------------------- */
@@ -20,29 +19,50 @@ 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 MarkdownCond<T> = T extends {
+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;
-} ? IntlayerNode<DeepTransformContent<M>, {
-  metadata: DeepTransformContent<U>;
-}> : never;
+} ? {
+  use: (components?: MarkdownComponentMap) => ReactNode;
+  metadata: DeepTransformContent<U, L>;
+} & any : never;
 declare const markdownPlugin: Plugins;
+/** ---------------------------------------------
+ *  HTML PLUGIN
+ *  --------------------------------------------- */
+type HTMLPluginCond<T, S, L> = HTMLCond<T, S, L>;
+/** HTML plugin. Replaces node with a function that takes components => ReactNode. */
+declare const htmlPlugin: Plugins;
 /** ---------------------------------------------
  *  PLUGINS RESULT
  *  --------------------------------------------- */
-interface IInterpreterPluginReact<T> {
+interface IInterpreterPluginReact<T, S, L extends LocalesValues> {
   reactNode: ReactNodeCond<T>;
-  intlayerNode: IntlayerNodeCond<T>;
-  markdown: MarkdownCond<T>;
+  reactIntlayerNode: IntlayerNodeCond<T>;
+  reactInsertion: InsertionCond<T, S, L>;
+  reactMarkdown: MarkdownCond<T, S, L>;
+  reactHtml: HTMLPluginCond<T, S, L>;
 }
 /**
  * Insert this type as param of `DeepTransformContent` to avoid `intlayer` package pollution.
@@ -51,10 +71,12 @@ interface IInterpreterPluginReact<T> {
  */
 type IInterpreterPluginState = IInterpreterPluginState$1 & {
   reactNode: true;
-  intlayerNode: true;
-  markdown: true;
+  reactIntlayerNode: true;
+  reactInsertion: true;
+  reactMarkdown: true;
+  reactHtml: true;
 };
 type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContent$1<T, IInterpreterPluginState, L>;
 //#endregion
-export { DeepTransformContent, IInterpreterPluginReact, IInterpreterPluginState, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, ReactNodeCond, 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