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

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

@@ -1,14 +1,118 @@
-import { ReactHTMLComponent } from "./types.js";
+import { HTMLComponents } from "../utils/HTMLComponentTypes.js";
+import * as react0 from "react";
 import { FC, JSX } from "react";
 
 //#region src/html/HTMLRenderer.d.ts
-declare const defaultHTMLComponents: Record<string, ReactHTMLComponent>;
+declare const defaultHTMLComponents: {} & {
+  object?: FC<react0.DetailedHTMLProps<react0.ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>>;
+  hr?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHRElement>, HTMLHRElement>>;
+  th?: FC<react0.DetailedHTMLProps<react0.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>>;
+  tr?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
+  html?: FC<react0.DetailedHTMLProps<react0.HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>>;
+  small?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  sub?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  sup?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  slot?: FC<react0.DetailedHTMLProps<react0.SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>>;
+  head?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>>;
+  body?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>>;
+  main?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  header?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  footer?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  nav?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  aside?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  article?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  section?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  div?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+  span?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>>;
+  h1?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+  h2?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+  h3?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+  h4?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+  h5?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+  h6?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+  p?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>>;
+  a?: FC<react0.DetailedHTMLProps<react0.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>>;
+  strong?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  b?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  em?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  i?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  u?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  s?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  del?: FC<react0.DetailedHTMLProps<react0.DelHTMLAttributes<HTMLModElement>, HTMLModElement>>;
+  ins?: FC<react0.DetailedHTMLProps<react0.InsHTMLAttributes<HTMLModElement>, HTMLModElement>>;
+  mark?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  code?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  pre?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLPreElement>, HTMLPreElement>>;
+  blockquote?: FC<react0.DetailedHTMLProps<react0.BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>>;
+  q?: FC<react0.DetailedHTMLProps<react0.QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>>;
+  cite?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  abbr?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  address?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  time?: FC<react0.DetailedHTMLProps<react0.TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>>;
+  kbd?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  samp?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  var?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  ul?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLUListElement>, HTMLUListElement>>;
+  ol?: FC<react0.DetailedHTMLProps<react0.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>>;
+  li?: FC<react0.DetailedHTMLProps<react0.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>>;
+  dl?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLDListElement>, HTMLDListElement>>;
+  dt?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  dd?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  table?: FC<react0.DetailedHTMLProps<react0.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>>;
+  thead?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>>;
+  tbody?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>>;
+  tfoot?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>>;
+  td?: FC<react0.DetailedHTMLProps<react0.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>>;
+  caption?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  colgroup?: FC<react0.DetailedHTMLProps<react0.ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>>;
+  col?: FC<react0.DetailedHTMLProps<react0.ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>>;
+  form?: FC<react0.DetailedHTMLProps<react0.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>>;
+  input?: FC<react0.DetailedHTMLProps<react0.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>>;
+  textarea?: FC<react0.DetailedHTMLProps<react0.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>>;
+  button?: FC<react0.DetailedHTMLProps<react0.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>>;
+  select?: FC<react0.DetailedHTMLProps<react0.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>>;
+  option?: FC<react0.DetailedHTMLProps<react0.OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>>;
+  optgroup?: FC<react0.DetailedHTMLProps<react0.OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>>;
+  label?: FC<react0.DetailedHTMLProps<react0.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>>;
+  fieldset?: FC<react0.DetailedHTMLProps<react0.FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>>;
+  legend?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>>;
+  datalist?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>>;
+  output?: FC<react0.DetailedHTMLProps<react0.OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>>;
+  progress?: FC<react0.DetailedHTMLProps<react0.ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>>;
+  meter?: FC<react0.DetailedHTMLProps<react0.MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>>;
+  img?: FC<react0.DetailedHTMLProps<react0.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>>;
+  video?: FC<react0.DetailedHTMLProps<react0.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>>;
+  audio?: FC<react0.DetailedHTMLProps<react0.AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>>;
+  source?: FC<react0.DetailedHTMLProps<react0.SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>>;
+  track?: FC<react0.DetailedHTMLProps<react0.TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>>;
+  picture?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  figure?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  figcaption?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  iframe?: FC<react0.DetailedHTMLProps<react0.IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>>;
+  embed?: FC<react0.DetailedHTMLProps<react0.EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>>;
+  canvas?: FC<react0.DetailedHTMLProps<react0.CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>>;
+  svg?: FC<react0.SVGProps<SVGSVGElement>>;
+  details?: FC<react0.DetailedHTMLProps<react0.DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>>;
+  summary?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  dialog?: FC<react0.DetailedHTMLProps<react0.DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>>;
+  br?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLBRElement>, HTMLBRElement>>;
+  wbr?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  ruby?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  rt?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  rp?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  bdi?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  bdo?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLElement>, HTMLElement>>;
+  data?: FC<react0.DetailedHTMLProps<react0.DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>>;
+  template?: FC<react0.DetailedHTMLProps<react0.HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>>;
+} & {
+  [key: string]: FC<react0.HTMLAttributes<HTMLElement>>;
+};
 type RenderHTMLProps = {
   /**
    * Component overrides for HTML tags.
    * Allows you to customize how specific HTML elements are rendered.
    */
-  components?: Record<string, any>;
+  components?: HTMLComponents<'permissive', {}>;
 };
 /**
  * Renders HTML-like content to JSX with the provided components.

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

@@ -1 +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"}
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;;;cAkBa,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAED,eAAA;;;;;EAKV,UAAA,GAAa,cAAA;AAAA;;;;;;;cASF,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;;;;EAI9B,QAAA;AAAA;;;;;;;cASW,YAAA,EAAc,EAAA,CAAG,iBAAA"}

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

@@ -1,5 +1,4 @@
 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 };
+export { HTMLProvider, HTMLRenderer, HTMLRendererPlugin, HTMLRendererProps, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLContext, useHTMLRenderer };

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

@@ -1,5 +1,5 @@
-import { Overrides } from "@intlayer/core";
-import { FC, PropsWithChildren, ReactNode } from "react";
+import { HTMLComponents } from "../utils/HTMLComponentTypes.js";
+import { FC, HTMLAttributes, PropsWithChildren, ReactNode } from "react";
 
 //#region src/markdown/MarkdownProvider.d.ts
 type MarkdownProviderOptions = {
@@ -8,17 +8,13 @@ type MarkdownProviderOptions = {
   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, components?: Overrides | RenderMarkdownOptions) => ReactNode;
+  renderMarkdown: (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: FC<HTMLAttributes<HTMLElement>>) => ReactNode;
 };
 type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
-  components?: Overrides;
-  wrapper?: any;
-  renderMarkdown?: (markdown: string, overrides?: Overrides | RenderMarkdownOptions) => ReactNode;
+  components?: HTMLComponents<'permissive', {}>;
+  wrapper?: FC<HTMLAttributes<HTMLElement>>;
+  renderMarkdown?: (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: FC<HTMLAttributes<HTMLElement>>) => ReactNode;
 }>;
 declare const useMarkdownContext: () => MarkdownContextValue;
 /**

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KAaY,uBAAA;iFAEV,UAAA,YAFiC;EAIjC,WAAA,YAJiC;EAMjC,mBAAA,YAFA;EAIA,SAAA;AAAA;AAAA,KAGG,oBAAA;EACH,cAAA,GACE,QAAA,UACA,OAAA,GAAU,uBAAA,EACV,UAAA,GAAa,cAAA,oBACb,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA,OACzB,SAAA;AAAA;AAAA,KAGF,qBAAA,GAAwB,iBAAA,CAC3B,uBAAA;EACE,UAAA,GAAa,cAAA;EACb,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA;EAC5B,cAAA,IACE,QAAA,UACA,OAAA,GAAU,uBAAA,EACV,UAAA,GAAa,cAAA,oBACb,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA,OACzB,SAAA;AAAA;AAAA,cAQI,kBAAA,QAAkB,oBAAA;;;;;;;;;;;;;;;;;;AApBf;;;;;;;cAmEH,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}

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

@@ -1,7 +1,7 @@
+import { HTMLComponents } from "../utils/HTMLComponentTypes.js";
 import { MarkdownProviderOptions } from "./MarkdownProvider.js";
-import { Overrides } from "@intlayer/core";
-import * as react0 from "react";
-import { FC, JSX, ReactNode } from "react";
+import * as react201 from "react";
+import { FC, HTMLAttributes, JSX, ReactNode } from "react";
 
 //#region src/markdown/MarkdownRenderer.d.ts
 /**
@@ -37,7 +37,7 @@ type RenderMarkdownProps = MarkdownProviderOptions & {
    * }}
    * ```
    */
-  components?: Overrides;
+  components?: HTMLComponents<'permissive', {}>;
   /**
    * Wrapper element or component to be used when there are multiple children.
    * Only used if not wrapped in a MarkdownProvider.
@@ -47,7 +47,7 @@ type RenderMarkdownProps = MarkdownProviderOptions & {
    * wrapper={({ children }) => <div className="markdown-content">{children}</div>}
    * ```
    */
-  wrapper?: FC;
+  wrapper?: FC<HTMLAttributes<HTMLElement>>;
 };
 /**
  * Renders markdown content to JSX with the provided components and options.
@@ -134,7 +134,7 @@ declare const useMarkdownRenderer: ({
   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;
+}?: RenderMarkdownProps) => (content: string) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react201.ReactPortal | react201.ReactElement<unknown, string | react201.JSXElementConstructor<any>> | Iterable<ReactNode>> | JSX.Element;
 /**
  * Props for the MarkdownRenderer component.
  *
@@ -183,7 +183,7 @@ type MarkdownRendererProps = RenderMarkdownProps & {
    * ```
    */
   renderMarkdown?: (markdown: string, options?: {
-    components?: Overrides;
+    components?: HTMLComponents<'permissive', {}>;
     wrapper?: FC;
     forceBlock?: boolean;
     forceInline?: boolean;

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;;AA2BA;;;;;;;;;;;;;;;;KAAY,mBAAA,GAAsB,uBAAA;EAwBO;;AA4BzC;;;;;;;;;;;EAtCE,UAAA,GAAa,cAAA;EA6Dd;;;;;;;;;EAnDC,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA;AAAA;;;;;;;;;AAkG9B;;;;;;;;;;;;;;;;;cAtEa,cAAA,GACX,OAAA;EACA,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOG,mBAAA,KACF,GAAA,CAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+GP;;;;;;;;;;;;;;;;cAnDa,mBAAA;EAAuB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOjC,mBAAA,MAGO,OAAA,kDAAe,QAAA,CAAA,SAAA,IAAA,OAAA,sCAAA,QAAA,CAAA,WAAA,GAAA,QAAA,CAAA,YAAA,mBAAA,QAAA,CAAA,qBAAA,SAAA,QAAA,CAAA,SAAA,KAAA,GAAA,CAAA,OAAA;;;;;;;;;AAmJzB;;;;;;;KA1GY,qBAAA,GAAwB,mBAAA;;;;;;;;;;;EAWlC,QAAA;;;;;;;;;;;;;;;;;;;;;EAqBA,cAAA,IACE,QAAA,UACA,OAAA;IACE,UAAA,GAAa,cAAA;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/index.d.ts

@@ -1,6 +1,6 @@
 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 { LegacyMarkdownRenderer, MarkdownRendererOptions, RuleType, 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 };
+export { LegacyMarkdownRenderer, MarkdownMetadataRenderer, MarkdownProvider, MarkdownProviderOptions, MarkdownRenderer, MarkdownRendererOptions, MarkdownRendererPlugin, MarkdownRendererProps, RenderMarkdownProps, RuleType, compile, compileMarkdown, compiler, createReactRuntime, reactRuntime, renderMarkdown, defaultSanitizer as sanitizer, defaultSlugify as slugify, useMarkdownContext, useMarkdownRenderer };

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

@@ -1,9 +1,9 @@
-import { Overrides as CoreOverrides, ParseState, ParserResult, RenderRuleHook, RuleOutput, RuleType, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core";
+import { HTMLComponents } from "../utils/HTMLComponentTypes.js";
+import { RenderRuleHook, 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.
  */
@@ -47,7 +47,7 @@ type MarkdownRendererOptions = Partial<{
   /**
    * Selectively control the output of particular HTML tags.
    */
-  components: CoreOverrides;
+  components: HTMLComponents;
   /**
    * Allows for full control over rendering of particular rules.
    */
@@ -88,5 +88,5 @@ declare const LegacyMarkdownRenderer: FC<Omit<HTMLAttributes<Element>, 'children
   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 };
+export { LegacyMarkdownRenderer, MarkdownRendererOptions, RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
 //# sourceMappingURL=processor.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;;KA4BK,QAAA,SAAiB,GAAA,CAAI,iBAAA;;;;KAKd,uBAAA,GAA0B,OAAA;EAA1B;;;EAIV,aAAA,GACE,GAAA,EAAK,UAAA,QAAkB,aAAA,MACvB,KAAA,EAAO,GAAA,CAAI,mBAAA,KACR,QAAA,EAAU,SAAA,OACV,SAAA;EAHE;;;;EASP,eAAA;EA2CY;;;;EArCZ,qBAAA;EApBoC;;;EAyBpC,kBAAA;EApBE;;;EAyBF,UAAA;EAvBK;;;EA4BL,WAAA;EAfA;;;EAoBA,YAAA;EAAA;;;EAKA,mBAAA;IAAA,CACG,GAAA;EAAA;EAWS;;;EALZ,UAAA,EAAY,cAAA;EAUe;;;EAL3B,UAAA,EAAY,cAAA;EAeZ;;;EAVA,SAAA,GAAY,KAAA,UAAe,GAAA,EAAK,QAAA,EAAU,SAAA;EAoBjC;AAiBX;;EAhCE,OAAA,GAAU,KAAA;EAgFX;;;EA3EC,OAAA;EA8BC;;;EAzBD,mBAAA;EAyEW;;;EApEX,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/plugins.d.ts

@@ -1,6 +1,7 @@
 import { IntlayerNode } from "./IntlayerNode.js";
-import { DeepTransformContent as DeepTransformContent$1, HTMLCond, IInterpreterPluginState as IInterpreterPluginState$1, Plugins } from "@intlayer/core";
-import { ComponentType, ElementType, ReactNode } from "react";
+import { HTMLComponents } from "./utils/HTMLComponentTypes.js";
+import { DeepTransformContent as DeepTransformContent$1, IInterpreterPluginState as IInterpreterPluginState$1, Plugins } from "@intlayer/core";
+import { ReactNode } from "react";
 import { DeclaredLocales, LocalesValues, NodeType } from "@intlayer/types";
 
 //#region src/plugins.d.ts
@@ -22,7 +23,7 @@ declare const reactNodePlugins: Plugins;
 /** ---------------------------------------------
  *  INSERTION PLUGIN
  *  --------------------------------------------- */
-type InsertionCond<T, S, L> = T extends {
+type InsertionCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeType.Insertion]: string;
   fields: readonly string[];
@@ -34,36 +35,50 @@ declare const insertionPlugin: Plugins;
  */
 type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
   metadata: DeepTransformContent<string>;
-  use: (components: any) => any;
+  use: (components: HTMLComponents<'permissive', {}>) => ReactNode;
 }> : 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 {
+type MarkdownCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeType.Markdown]: infer M;
   metadata?: infer U;
+  tags?: infer U;
 } ? {
-  use: (components?: MarkdownComponentMap) => ReactNode;
-  metadata: DeepTransformContent<U, L>;
-} & any : never;
+  use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<M>;
+  metadata: DeepTransformContent<U>;
+} : never;
 declare const markdownPlugin: Plugins;
 /** ---------------------------------------------
  *  HTML PLUGIN
  *  --------------------------------------------- */
-type HTMLPluginCond<T, S, L> = HTMLCond<T, S, L>;
+/**
+ * HTML conditional type that enforces:
+ * - All components (Standard or Custom) are OPTIONAL in the `use()` method.
+ * - Custom components props are strictly inferred from the dictionary definition.
+ *
+ * This ensures type safety:
+ * - `html('<div>Hello <CustomComponent /></div>').use({ CustomComponent: ... })` - optional but typed
+ */
+type HTMLPluginCond<T> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.HTML]: infer I;
+  tags?: infer U;
+} ? {
+  use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<I>;
+} : never;
 /** HTML plugin. Replaces node with a function that takes components => ReactNode. */
 declare const htmlPlugin: Plugins;
 /** ---------------------------------------------
  *  PLUGINS RESULT
  *  --------------------------------------------- */
-interface IInterpreterPluginReact<T, S, L extends LocalesValues> {
+type 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>;
-}
+  reactInsertion: InsertionCond<T>;
+  reactMarkdown: MarkdownCond<T>;
+  reactHtml: HTMLPluginCond<T>;
+};
 /**
  * Insert this type as param of `DeepTransformContent` to avoid `intlayer` package pollution.
  *

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;AAkCA;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,MAAmB,CAAA;EAC7B,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;EAGI,QAAA,EAAU,oBAAA;EACV,GAAA,GAAM,UAAA,EAAY,cAAA,uBAAqC,SAAA;AAAA;;cAMlD,oBAAA,EAAsB,OAAA;AAAA,KA+EvB,YAAA,MAAkB,CAAA;EAC5B,QAAA,EAAU,QAAA;EAAA,CACT,QAAA,CAAS,QAAA;EACV,QAAA;EACA,IAAA;AAAA;EAGI,GAAA,GAAM,UAAA,GAAa,cAAA,eAA6B,CAAA,MAAO,YAAA,CAAa,CAAA;EACpE,QAAA,EAAU,oBAAA,CAAqB,CAAA;AAAA;AAAA,cAIxB,cAAA,EAAgB,OAAA;;;;;;;;;;;;KAmCjB,cAAA,MAAoB,CAAA;EAC9B,QAAA,EAAU,QAAA;EAAA,CACT,QAAA,CAAS,IAAA;EACV,IAAA;AAAA;EAGI,GAAA,GAAM,UAAA,GAAa,cAAA,eAA6B,CAAA,MAAO,YAAA,CAAa,CAAA;AAAA;;cAK7D,UAAA,EAAY,OAAA;;;AApJzB;KAwLY,uBAAA,mBAA0C,aAAA;EACpD,SAAA,EAAW,aAAA,CAAc,CAAA;EACzB,iBAAA,EAAmB,gBAAA,CAAiB,CAAA;EACpC,cAAA,EAAgB,aAAA,CAAc,CAAA;EAC9B,aAAA,EAAe,YAAA,CAAa,CAAA;EAC5B,SAAA,EAAW,cAAA,CAAe,CAAA;AAAA;;;;;;KAQhB,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"}

package/dist/types/reactElement/renderReactElement.d.ts

@@ -1,8 +1,7 @@
-import * as react4 from "react";
 import { ReactElement } from "react";
 
 //#region src/reactElement/renderReactElement.d.ts
-declare const renderReactElement: (element: ReactElement<any>) => ReactElement<any, string | react4.JSXElementConstructor<any>>;
+declare const renderReactElement: (element: ReactElement<any>) => any;
 //#endregion
 export { renderReactElement };
 //# sourceMappingURL=renderReactElement.d.ts.map

package/dist/types/reactElement/renderReactElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;;;cAGa,kBAAA,GAAsB,OAAA,EAAS,YAAA,UAAiB,YAAA,eAAL,MAAA,CAAK,qBAAA"}
+{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;;cAGa,kBAAA,GAAsB,OAAA,EAAS,YAAA"}

package/dist/types/server/IntlayerServerProvider.d.ts

@@ -1,4 +1,4 @@
-import * as react3 from "react";
+import * as react200 from "react";
 import { FC, PropsWithChildren } from "react";
 import { LocalesValues } from "@intlayer/types";
 
@@ -13,7 +13,7 @@ declare const IntlayerServerContext: FC<PropsWithChildren<{
     value?: LocalesValues;
   }>>;
   Consumer: FC<PropsWithChildren<{
-    children: (context: LocalesValues) => react3.ReactNode;
+    children: (context: LocalesValues) => react200.ReactNode;
   }>>;
   _storage: () => {
     value: LocalesValues;

package/dist/types/server/useDictionary.d.ts

@@ -1,5 +1,5 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
-import * as _intlayer_core2 from "@intlayer/core";
+import * as _intlayer_core4 from "@intlayer/core";
 import { DeclaredLocales, Dictionary, LocalesValues } from "@intlayer/types";
 
 //#region src/server/useDictionary.d.ts
@@ -8,7 +8,7 @@ import { DeclaredLocales, Dictionary, LocalesValues } from "@intlayer/types";
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => _intlayer_core2.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>;
+declare const useDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => _intlayer_core4.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>;
 //#endregion
 export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/server/useDictionaryAsync.d.ts

@@ -1,5 +1,5 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
-import * as _intlayer_core4 from "@intlayer/core";
+import * as _intlayer_core2 from "@intlayer/core";
 import { DeclaredLocales, Dictionary, LocalesValues, StrictModeLocaleMap } from "@intlayer/types";
 
 //#region src/server/useDictionaryAsync.d.ts
@@ -8,7 +8,7 @@ import { DeclaredLocales, Dictionary, LocalesValues, StrictModeLocaleMap } from
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useDictionaryAsync: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => Promise<_intlayer_core4.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>>;
+declare const useDictionaryAsync: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => Promise<_intlayer_core2.DeepTransformContent<T["content"], IInterpreterPluginState$1, L>>;
 //#endregion
 export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

package/dist/types/server/useIntlayer.d.ts

@@ -1,6 +1,6 @@
 import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
 import * as _intlayer_core5 from "@intlayer/core";
-import * as _intlayer_types9 from "@intlayer/types";
+import * as _intlayer_types8 from "@intlayer/types";
 import { DictionaryKeys, LocalesValues } from "@intlayer/types";
 
 //#region src/server/useIntlayer.d.ts
@@ -9,7 +9,7 @@ import { DictionaryKeys, LocalesValues } from "@intlayer/types";
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useIntlayer: <T extends DictionaryKeys, L extends LocalesValues>(key: T, locale?: L) => _intlayer_core5.DeepTransformContent<_intlayer_types9.DictionaryRegistryContent<T>, IInterpreterPluginState$1, L>;
+declare const useIntlayer: <T extends DictionaryKeys, L extends LocalesValues>(key: T, locale?: L) => _intlayer_core5.DeepTransformContent<_intlayer_types8.DictionaryRegistryContent<T>, IInterpreterPluginState$1, L>;
 //#endregion
 export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/utils/HTMLComponentTypes.d.ts

@@ -0,0 +1,38 @@
+import { HTMLTagsType } from "@intlayer/core";
+import { ComponentProps, FC, HTMLAttributes, JSX } from "react";
+
+//#region src/utils/HTMLComponentTypes.d.ts
+/**
+ * Helper to extract specific props from the configuration value.
+ */
+type PropsFromConfig<Value> = Value extends true ? {} : Value extends object ? Value : {};
+/**
+ * Smart Type to resolve props based on the key K.
+ */
+type ElementProps<K> = K extends keyof JSX.IntrinsicElements ? ComponentProps<K> : HTMLAttributes<HTMLElement>;
+/**
+ * Helper: Defines the mapping for the explicitly listed keys in T.
+ * Handles whether they are Required or Optional.
+ */
+type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? { [K in keyof T]: FC<ElementProps<K> & PropsFromConfig<T[K]>> } : { [K in keyof T]?: FC<ElementProps<K> & PropsFromConfig<T[K]>> };
+/**
+ * Helper: Defines the standard HTML tags NOT listed in T.
+ * These are always optional when included.
+ */
+type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: FC<K extends keyof JSX.IntrinsicElements ? ComponentProps<K> : HTMLAttributes<HTMLElement>> };
+/**
+ * The supported modes for the HTMLComponents type.
+ */
+type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+/**
+ * The main component definition with Mode support.
+ */
+type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' ? // Inclusive: Keys in T are required. Rest of HTML is optional.
+DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' ? // Permissive: Keys in T optional. Rest of HTML optional. Any other string allowed.
+DefinedComponents<T, false> & RestHTMLComponents<T> & {
+  [key: string]: FC<HTMLAttributes<HTMLElement>>;
+} : // Optional (Default): Keys in T optional. Rest of HTML optional.
+DefinedComponents<T, false> & RestHTMLComponents<T>;
+//#endregion
+export { HTMLComponentMode, HTMLComponents };
+//# sourceMappingURL=HTMLComponentTypes.d.ts.map

package/dist/types/utils/HTMLComponentTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/utils/HTMLComponentTypes.tsx"],"mappings":";;;;;;AACqE;KAKhE,eAAA,UAAyB,KAAA,qBAE1B,KAAA,kBACE,KAAA;;;;KAMD,YAAA,MAAkB,CAAA,eAAgB,GAAA,CAAI,iBAAA,GACvC,cAAA,CAAe,CAAA,IACf,cAAA,CAAe,WAAA;;;;;KAMd,iBAAA,kCAAmD,UAAA,8BAGtC,CAAA,GAAI,EAAA,CAAG,YAAA,CAAa,CAAA,IAAK,eAAA,CAAgB,CAAA,CAAE,CAAA,sBAI3C,CAAA,IAAK,EAAA,CAAG,YAAA,CAAa,CAAA,IAAK,eAAA,CAAgB,CAAA,CAAE,CAAA;;;;;KAOzD,kBAAA,cACG,OAAA,OAAc,YAAA,QAAoB,CAAA,KAAM,EAAA,CAC5C,CAAA,eAAgB,GAAA,CAAI,iBAAA,GAChB,cAAA,CAAe,CAAA,IACf,cAAA,CAAe,WAAA;;;;KAOX,iBAAA;;;;KASA,cAAA,cACG,iBAAA,yBAEX,IAAA,oBAEA,iBAAA,CAAkB,CAAA,UAClB,IAAA;AAEE,iBAAA,CAAkB,CAAA,UAAW,kBAAA,CAAmB,CAAA,IAChD,IAAA;AAEE,iBAAA,CAAkB,CAAA,WAChB,kBAAA,CAAmB,CAAA;EAAA,CAEhB,GAAA,WAAc,EAAA,CAAG,cAAA,CAAe,WAAA;AAAA;AAGrC,iBAAA,CAAkB,CAAA,WAAY,kBAAA,CAAmB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-intlayer",
-  "version": "8.0.0-canary.2",
+  "version": "8.0.0-canary.4",
   "private": false,
   "description": "Easily internationalize i18n your React applications with type-safe multilingual content management.",
   "keywords": [
@@ -116,14 +116,14 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.0.0-canary.2",
-    "@intlayer/config": "8.0.0-canary.2",
-    "@intlayer/core": "8.0.0-canary.2",
-    "@intlayer/dictionaries-entry": "8.0.0-canary.2",
-    "@intlayer/editor-react": "8.0.0-canary.2",
-    "@intlayer/types": "8.0.0-canary.2",
-    "@intlayer/unmerged-dictionaries-entry": "8.0.0-canary.2",
-    "intlayer": "8.0.0-canary.2"
+    "@intlayer/api": "8.0.0-canary.4",
+    "@intlayer/config": "8.0.0-canary.4",
+    "@intlayer/core": "8.0.0-canary.4",
+    "@intlayer/dictionaries-entry": "8.0.0-canary.4",
+    "@intlayer/editor-react": "8.0.0-canary.4",
+    "@intlayer/types": "8.0.0-canary.4",
+    "@intlayer/unmerged-dictionaries-entry": "8.0.0-canary.4",
+    "intlayer": "8.0.0-canary.4"
   },
   "devDependencies": {
     "@craco/types": "7.1.0",

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

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

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