preact-intlayer 8.4.4 → 8.4.6

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

@@ -1,2 +1,13 @@
-import { t as useDictionaryAsync } from "../useDictionaryAsync-CDCcBnXn.js";
-export { useDictionaryAsync };
+import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/client/useDictionaryAsync.d.ts
+/**
+ * On the server side, Hook that transform a dictionary and return the content
+ *
+ * If the locale is not provided, it will use the locale from the client context
+ */
+declare const useDictionaryAsync: <T extends Dictionary>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: LocalesValues) => Promise<T>;
+//#endregion
+export { useDictionaryAsync };
+//# sourceMappingURL=useDictionaryAsync.d.ts.map

package/dist/types/client/useDictionaryAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;AAeA;;;cAAa,kBAAA,aAAsC,UAAA,EACjD,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,MAAA,GAAS,aAAA,KACR,OAAA,CAAQ,CAAA"}

package/dist/types/client/useDictionaryDynamic.d.ts

@@ -1,2 +1,16 @@
-import { t as useDictionaryDynamic } from "../useDictionaryDynamic-BQgaM0vp.js";
-export { useDictionaryDynamic };
+import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
+import * as _intlayer_core_interpreter0 from "@intlayer/core/interpreter";
+import { DictionaryKeys, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import * as _intlayer_types_allLocales0 from "@intlayer/types/allLocales";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/client/useDictionaryDynamic.d.ts
+/**
+ * On the server side, Hook that transform a dictionary and return the content
+ *
+ * If the locale is not provided, it will use the locale from the client context
+ */
+declare const useDictionaryDynamic: <T extends Dictionary, K extends DictionaryKeys>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, locale?: LocalesValues) => _intlayer_core_interpreter0.DeepTransformContent<T["content"], IInterpreterPluginState$1, _intlayer_types_allLocales0.Locale>;
+//#endregion
+export { useDictionaryDynamic };
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/client/useDictionaryDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;cAgBa,oBAAA,aACD,UAAA,YACA,cAAA,EAEV,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,aAAA,KAAa,2BAAA,CAAA,oBAAA,CAAA,CAAA,aAAA,yBAAA,EAAA,2BAAA,CAAA,MAAA"}

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

@@ -1,2 +1,28 @@
-import { t as useIntlayer } from "../useIntlayer-BINmW9T1.js";
-export { useIntlayer };
+import { DeepTransformContent } from "../plugins.js";
+import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/client/useIntlayer.d.ts
+/**
+ * Preact hook that picks one dictionary by its key and returns its content.
+ *
+ * If the locale is not provided, it will use the locale from the client context.
+ *
+ * @param key - The unique key of the dictionary to retrieve.
+ * @param locale - Optional locale to override the current context locale.
+ * @returns The transformed dictionary content.
+ *
+ * @example
+ * ```tsx
+ * import { useIntlayer } from 'preact-intlayer';
+ *
+ * const MyComponent = () => {
+ *   const content = useIntlayer('my-dictionary-key');
+ *
+ *   return <div>{content.myField.value}</div>;
+ * };
+ * ```
+ */
+declare const useIntlayer: <T extends DictionaryKeys, L extends LocalesValues>(key: T, locale?: L) => DeepTransformContent<DictionaryRegistryContent<T>>;
+//#endregion
+export { useIntlayer };
+//# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/client/useIntlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;AA8BA;;;;;;;;;;;;;;;;;;cAAa,WAAA,aAAyB,cAAA,YAA0B,aAAA,EAC9D,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,KAAC,oBAAA,CAAA,yBAAA,CAAA,CAAA"}

package/dist/types/client/useLoadDynamic.d.ts

@@ -1,2 +1,5 @@
-import { t as useLoadDynamic } from "../useLoadDynamic-DFXHehpF.js";
-export { useLoadDynamic };
+//#region src/client/useLoadDynamic.d.ts
+declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
+//#endregion
+export { useLoadDynamic };
+//# sourceMappingURL=useLoadDynamic.d.ts.map

package/dist/types/client/useLoadDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";cA2Ba,cAAA,MAAqB,GAAA,UAAa,OAAA,EAAS,OAAA,CAAQ,CAAA,MAAK,CAAA"}

package/dist/types/client/useLocale.d.ts

@@ -1,2 +1,43 @@
-import { t as useLocale } from "../useLocale-BDQ4yLc5.js";
-export { useLocale };
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import * as _intlayer_types_allLocales0 from "@intlayer/types/allLocales";
+
+//#region src/client/useLocale.d.ts
+type useLocaleProps = {
+  isCookieEnabled?: boolean;
+  onLocaleChange?: (locale: LocalesValues) => void;
+};
+/**
+ * Preact hook to get the current locale and related locale management functions.
+ *
+ * @param props - Optional properties for the hook.
+ * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.
+ *
+ * @example
+ * ```tsx
+ * import { useLocale } from 'preact-intlayer';
+ *
+ * const LocaleSwitcher = () => {
+ *   const { locale, setLocale, availableLocales } = useLocale();
+ *
+ *   return (
+ *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>
+ *       {availableLocales.map((loc) => (
+ *         <option key={loc} value={loc}>{loc}</option>
+ *       ))}
+ *     </select>
+ *   );
+ * };
+ * ```
+ */
+declare const useLocale: ({
+  isCookieEnabled,
+  onLocaleChange
+}?: useLocaleProps) => {
+  locale: LocalesValues;
+  defaultLocale: _intlayer_types_allLocales0.Locale;
+  availableLocales: _intlayer_types_allLocales0.Locale[];
+  setLocale: (locale: LocalesValues) => void;
+};
+//#endregion
+export { useLocale };
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/client/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;;KAMK,cAAA;EACH,eAAA;EACA,cAAA,IAAkB,MAAA,EAAQ,aAAA;AAAA;;;;;;;;;;AA0B5B;;;;;;;;;;;;;;cAAa,SAAA;EAAa,eAAA;EAAA;AAAA,IAGvB,cAAA;;;;sBAU0B,aAAA;AAAA"}

package/dist/types/client/useLocaleBase.d.ts

@@ -1,2 +1,16 @@
-import { t as useLocaleBase } from "../useLocaleBase-1L1RLyXD.js";
-export { useLocaleBase };
+import * as _intlayer_types_module_augmentation0 from "@intlayer/types/module_augmentation";
+import * as _intlayer_types_allLocales0 from "@intlayer/types/allLocales";
+
+//#region src/client/useLocaleBase.d.ts
+/**
+ * On the client side, hook to get the current locale and all related fields
+ */
+declare const useLocaleBase: () => {
+  locale: _intlayer_types_module_augmentation0.LocalesValues;
+  defaultLocale: _intlayer_types_allLocales0.Locale;
+  availableLocales: _intlayer_types_allLocales0.Locale[];
+  setLocale: (newLocale: _intlayer_types_module_augmentation0.LocalesValues) => void;
+};
+//#endregion
+export { useLocaleBase };
+//# sourceMappingURL=useLocaleBase.d.ts.map

package/dist/types/client/useLocaleBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;;;cAUa,aAAA;UASZ,oCAAA,CAAA,aAAA"}

package/dist/types/client/useLocaleStorage.d.ts

@@ -1,2 +1,45 @@
-import { a as useLocaleCookie, i as setLocaleInStorage, n as localeInStorage, o as useLocaleStorage, r as setLocaleCookie, t as localeCookie } from "../useLocaleStorage-BwH9gqN5.js";
-export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import * as _intlayer_types_allLocales0 from "@intlayer/types/allLocales";
+
+//#region src/client/useLocaleStorage.d.ts
+/**
+ * Get the locale cookie
+ */
+declare const localeInStorage: _intlayer_types_allLocales0.Locale;
+/**
+ * @deprecated Use localeInStorage instead
+ *
+ * Get the locale cookie
+ */
+declare const localeCookie: _intlayer_types_allLocales0.Locale;
+/**
+ * Set the locale cookie
+ */
+declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * @deprecated Use setLocaleInStorage instead
+ *
+ * Set the locale cookie
+ */
+declare const setLocaleCookie: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * Hook that provides the locale storage and a function to set it
+ */
+declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  getLocale: () => _intlayer_types_allLocales0.Locale;
+  setLocale: (locale: LocalesValues) => void;
+};
+/**
+ * @deprecated Use useLocaleStorage instead
+ *
+ * For GDPR compliance, use useLocaleStorage instead
+ *
+ * Hook that provides the locale cookie and a function to set it
+ */
+declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
+  localeCookie: _intlayer_types_allLocales0.Locale;
+  setLocaleCookie: (locale: LocalesValues) => void;
+};
+//#endregion
+export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
+//# sourceMappingURL=useLocaleStorage.d.ts.map

package/dist/types/client/useLocaleStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;cAYa,eAAA,EAA4D,2BAAA,CAA7C,MAAA;;;;;AAM5B;cAAa,YAAA,EAA8B,2BAAA,CAAlB,MAAA;;;;cAKZ,kBAAA,GACX,MAAA,EAAQ,aAAA,EACR,eAAA;;;;;;cAYW,eAAA,GAAe,MAAA,EAblB,aAAA,EAAa,eAAA;;;AAavB;cAKa,gBAAA,GAAoB,eAAA;mBAQ9B,2BAAA,CAAA,MAAA;sBAAA,aAAA;AAAA;;;;;AARH;;;cAiBa,eAAA,GAAmB,eAAA;gBAM/B,2BAAA,CAAA,MAAA;4BAAA,aAAA;AAAA"}

package/dist/types/getDictionary.d.ts

@@ -1,4 +1,4 @@
-import { t as DeepTransformContent } from "./plugins-D6OB94dO.js";
+import { DeepTransformContent } from "./plugins.js";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
 

package/dist/types/getIntlayer.d.ts

@@ -1,4 +1,4 @@
-import { t as DeepTransformContent } from "./plugins-D6OB94dO.js";
+import { DeepTransformContent } from "./plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
 
 //#region src/getIntlayer.d.ts

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

@@ -1,2 +1,18 @@
-import { n as useHTMLContext, t as HTMLProvider } from "../HTMLProvider-8sO8DU8H.js";
-export { HTMLProvider, useHTMLContext };
+import { HTMLComponents } from "./types.js";
+import { FunctionalComponent, RenderableProps } from "preact";
+
+//#region src/html/HTMLProvider.d.ts
+type HTMLContextValue = {
+  components?: HTMLComponents<'permissive', {}>;
+};
+type HTMLProviderProps = RenderableProps<{
+  /**
+   * Component overrides for HTML tags.
+   */
+  components?: HTMLComponents<'permissive', {}>;
+}>;
+declare const useHTMLContext: () => HTMLContextValue;
+declare const HTMLProvider: FunctionalComponent<HTMLProviderProps>;
+//#endregion
+export { HTMLProvider, useHTMLContext };
+//# sourceMappingURL=HTMLProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;;KAQK,gBAAA;EACH,UAAA,GAAa,cAAA;AAAA;AAAA,KAGV,iBAAA,GAAoB,eAAA;;;;EAIvB,UAAA,GAAa,cAAA;AAAA;AAAA,cAKF,cAAA,QAAc,gBAAA;AAAA,cAEd,YAAA,EAAc,mBAAA,CAAoB,iBAAA"}

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

@@ -1,2 +1,61 @@
-import { a as renderHTML, i as defaultHTMLComponents, n as HTMLRendererProps, o as useHTMLRenderer, r as RenderHTMLProps, t as HTMLRenderer } from "../HTMLRenderer-NNa_9oMD.js";
-export { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLRenderer };
+import { HTMLComponents } from "./types.js";
+import { FunctionComponent, JSX, h } from "preact";
+import { KeyPath } from "@intlayer/types/keyPath";
+
+//#region src/html/HTMLRenderer.d.ts
+/**
+ * Type for Preact HTML tag components.
+ */
+type HTMLTagComponent = (props: {
+  children?: any;
+  [key: string]: any;
+}) => JSX.Element;
+declare const defaultHTMLComponents: Record<string, HTMLTagComponent>;
+type RenderHTMLProps = {
+  /**
+   * Component overrides for HTML tags.
+   * Allows you to customize how specific HTML elements are rendered.
+   */
+  components?: HTMLComponents<'permissive', {}>;
+};
+/**
+ * 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) => h.JSX.Element;
+type HTMLRendererProps = RenderHTMLProps & {
+  /**
+   * The HTML content to render as a string.
+   */
+  children?: string;
+  /**
+   * Alias for children, used by the plugin.
+   */
+  html?: string;
+  /**
+   * Alias for components, used by the plugin.
+   */
+  components?: HTMLComponents<'permissive', {}>;
+  dictionaryKey?: string;
+  keyPath?: KeyPath[];
+};
+/**
+ * Preact component that renders HTML-like content to JSX.
+ */
+declare const HTMLRenderer: FunctionComponent<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":";;;;;;;AAK8C;KAKzC,gBAAA,IAAoB,KAAA;EACvB,QAAA;EAAA,CACC,GAAA;AAAA,MACG,GAAA,CAAI,OAAA;AAAA,cAaG,qBAAA,EAAqB,MAAA,SAAA,gBAAA;AAAA,KAEtB,eAAA;EAfN;;;;EAoBJ,UAAA,GAAa,cAAA;AAAA;;;;AALf;;;cAca,UAAA,GACX,OAAA;EACA;AAAA,IAAgB,eAAA,KACf,GAAA,CAAI,OAAA;;AAHP;;;;;cA4Ba,eAAA;EAAmB;AAAA,IAAgB,eAAA,MAGtC,OAAA,aAAe,CAAA,CAAA,GAAA,CAAA,OAAA;AAAA,KAUb,iBAAA,GAAoB,eAAA;EArB/B;;;EAyBC,QAAA;EA3CgB;;;EA+ChB,IAAA;EA7BD;AAQD;;EAyBE,UAAA,GAAa,cAAA;EACb,aAAA;EACA,OAAA,GAAU,OAAA;AAAA;;;;cAMC,YAAA,EAAc,iBAAA,CAAkB,iBAAA"}

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

@@ -1,3 +1,3 @@
-import { n as useHTMLContext, t as HTMLProvider } from "../HTMLProvider-8sO8DU8H.js";
-import { a as renderHTML, i as defaultHTMLComponents, n as HTMLRendererProps, o as useHTMLRenderer, r as RenderHTMLProps, t as HTMLRenderer } from "../HTMLRenderer-NNa_9oMD.js";
+import { HTMLProvider, useHTMLContext } from "./HTMLProvider.js";
+import { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLRenderer } from "./HTMLRenderer.js";
 export { HTMLProvider, HTMLRenderer, HTMLRendererProps, RenderHTMLProps, defaultHTMLComponents, renderHTML, useHTMLContext, useHTMLRenderer };

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

@@ -1,2 +1,38 @@
-import { n as HTMLComponents, t as HTMLComponentMode } from "../types-B3Kzdco6.js";
-export { HTMLComponentMode, HTMLComponents };
+import { FunctionalComponent, JSX } from "preact";
+import { HTMLTagsType } from "@intlayer/core/transpiler";
+
+//#region src/html/types.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 ? JSX.IntrinsicElements[K] : JSX.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]: FunctionalComponent<ElementProps<K> & PropsFromConfig<T[K]>> } : { [K in keyof T]?: FunctionalComponent<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>]?: FunctionalComponent<K extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[K] : JSX.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]: FunctionalComponent<JSX.HTMLAttributes<HTMLElement>>;
+} : // Optional (Default): Keys in T optional. Rest of HTML optional.
+DefinedComponents<T, false> & RestHTMLComponents<T>;
+//#endregion
+export { HTMLComponentMode, HTMLComponents };
+//# 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":";;;;;;AACuD;KAKlD,eAAA,UAAyB,KAAA,qBAE1B,KAAA,kBACE,KAAA;;;;KAMD,YAAA,MAAkB,CAAA,eAAgB,GAAA,CAAI,iBAAA,GACvC,GAAA,CAAI,iBAAA,CAAkB,CAAA,IACtB,GAAA,CAAI,cAAA,CAAe,WAAA;;;;;KAMlB,iBAAA,kCAAmD,UAAA,8BAGtC,CAAA,GAAI,mBAAA,CACd,YAAA,CAAa,CAAA,IAAK,eAAA,CAAgB,CAAA,CAAE,CAAA,sBAK1B,CAAA,IAAK,mBAAA,CACf,YAAA,CAAa,CAAA,IAAK,eAAA,CAAgB,CAAA,CAAE,CAAA;;;;;KAQvC,kBAAA,cACG,OAAA,OAAc,YAAA,QAAoB,CAAA,KAAM,mBAAA,CAC5C,CAAA,eAAgB,GAAA,CAAI,iBAAA,GAChB,GAAA,CAAI,iBAAA,CAAkB,CAAA,IACtB,GAAA,CAAI,cAAA,CAAe,WAAA;;;;KAOf,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,CAChB,GAAA,WAAc,mBAAA,CAAoB,GAAA,CAAI,cAAA,CAAe,WAAA;AAAA;AAG1D,iBAAA,CAAkB,CAAA,WAAY,kBAAA,CAAmB,CAAA"}

package/dist/types/index.d.ts

@@ -1,24 +1,24 @@
-import { t as IntlayerNode } from "./IntlayerNode-CIzFHYnC.js";
-import { a as useIntlayerContext, i as IntlayerProviderProps, n as IntlayerProvider, r as IntlayerProviderContent, t as IntlayerClientContext } from "./IntlayerProvider-aV596OL4.js";
-import { t as useIntl } from "./useIntl-DfzrSGu4.js";
-import { t } from "./t-CalXqnSB.js";
-import { d as htmlPlugin, g as preactNodePlugins, h as markdownStringPlugin, m as markdownPlugin, p as intlayerNodePlugins, r as IInterpreterPluginPreact } from "./plugins-D6OB94dO.js";
-import { t as useDictionary } from "./useDictionary-cjQAc1l1.js";
-import { t as useDictionaryAsync } from "./useDictionaryAsync-CDCcBnXn.js";
-import { t as useDictionaryDynamic } from "./useDictionaryDynamic-BQgaM0vp.js";
-import { t as useIntlayer } from "./useIntlayer-BINmW9T1.js";
-import { t as useLoadDynamic } from "./useLoadDynamic-DFXHehpF.js";
-import { t as useLocale } from "./useLocale-BDQ4yLc5.js";
-import { t as useLocaleBase } from "./useLocaleBase-1L1RLyXD.js";
-import { a as useLocaleCookie, i as setLocaleInStorage, o as useLocaleStorage, r as setLocaleCookie, t as localeCookie } from "./useLocaleStorage-BwH9gqN5.js";
+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 { IInterpreterPluginPreact, htmlPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin, preactNodePlugins } from "./plugins.js";
+import { useDictionary } from "./client/useDictionary.js";
+import { useDictionaryAsync } from "./client/useDictionaryAsync.js";
+import { useDictionaryDynamic } from "./client/useDictionaryDynamic.js";
+import { useIntlayer } from "./client/useIntlayer.js";
+import { useLoadDynamic } from "./client/useLoadDynamic.js";
+import { useLocale } from "./client/useLocale.js";
+import { useLocaleBase } from "./client/useLocaleBase.js";
+import { localeCookie, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage } from "./client/useLocaleStorage.js";
 import { getDictionary } from "./getDictionary.js";
 import { getIntlayer } from "./getIntlayer.js";
-import { t as HTMLProvider } from "./HTMLProvider-8sO8DU8H.js";
-import { a as renderHTML, n as HTMLRendererProps, o as useHTMLRenderer, r as RenderHTMLProps, t as HTMLRenderer } from "./HTMLRenderer-NNa_9oMD.js";
-import { i as compileMarkdown } from "./compiler-BB0gAVbe.js";
-import { t as MarkdownProvider } from "./MarkdownProvider-chUIO05u.js";
-import { i as useMarkdownRenderer, r as renderMarkdown, t as MarkdownRenderer } from "./MarkdownRenderer-BMhuurZW.js";
-import { t as preactRuntime } from "./runtime-BMHAtT-R.js";
+import { HTMLProvider } from "./html/HTMLProvider.js";
+import { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, renderHTML, useHTMLRenderer } from "./html/HTMLRenderer.js";
+import { compileMarkdown } from "./markdown/compiler.js";
+import { MarkdownProvider } from "./markdown/MarkdownProvider.js";
+import { MarkdownRenderer, renderMarkdown, useMarkdownRenderer } from "./markdown/MarkdownRenderer.js";
+import preactRuntime from "./markdown/runtime.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 
 //#region src/index.d.ts

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

@@ -1,2 +1,52 @@
-import { n as MarkdownProviderOptions, r as useMarkdownContext, t as MarkdownProvider } from "../MarkdownProvider-chUIO05u.js";
-export { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext };
+import { HTMLComponents } from "../html/types.js";
+import { ComponentChildren, FunctionComponent } from "preact";
+
+//#region src/markdown/MarkdownProvider.d.ts
+type PropsWithChildren<P = {}> = P & {
+  children?: ComponentChildren;
+};
+/**
+ * Refined options for the MarkdownProvider.
+ */
+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.
+   */
+  tagfilter?: boolean;
+};
+type MarkdownContextValue = {
+  components?: HTMLComponents<'permissive', {}>;
+  renderMarkdown: (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: any) => ComponentChildren;
+};
+type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
+  /**
+   * Component overrides for HTML tags.
+   */
+  components?: HTMLComponents<'permissive', {}>;
+  /**
+   * Wrapper element or component to be used when there are multiple children.
+   */
+  wrapper?: any;
+  /**
+   * Custom render function for markdown.
+   * If provided, it will overwrite all rules and default rendering.
+   */
+  renderMarkdown?: (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: any) => ComponentChildren;
+}>;
+declare const useMarkdownContext: () => MarkdownContextValue;
+declare const MarkdownProvider: FunctionComponent<MarkdownProviderProps>;
+//#endregion
+export { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext };
+//# sourceMappingURL=MarkdownProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KASK,iBAAA,WAA4B,CAAA;EAAM,QAAA,GAAW,iBAAA;AAAA;;;;KAKtC,uBAAA;EALqB;;;EAS/B,UAAA;EATiE;AAKnE;;EAQE,WAAA;EARiC;;;EAYjC,mBAAA;EAIA;;;EAAA,SAAA;AAAA;AAAA,KAQG,oBAAA;EACH,UAAA,GAAa,cAAA;EACb,cAAA,GACE,QAAA,UACA,OAAA,GAAU,uBAAA,EACV,UAAA,GAAa,cAAA,oBACb,OAAA,WACG,iBAAA;AAAA;AAAA,KAGF,qBAAA,GAAwB,iBAAA,CAC3B,uBAAA;EAJsB;;;EAQpB,UAAA,GAAa,cAAA;EAbf;;;EAiBE,OAAA;EAda;;;;EAmBb,cAAA,IACE,QAAA,UACA,OAAA,GAAU,uBAAA,EACV,UAAA,GAAa,cAAA,oBACb,OAAA,WACG,iBAAA;AAAA;AAAA,cAQI,kBAAA,QAAkB,oBAAA;AAAA,cAuBlB,gBAAA,EAAkB,iBAAA,CAAkB,qBAAA"}

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

@@ -1,2 +1,61 @@
-import { i as useMarkdownRenderer, n as RenderMarkdownProps, r as renderMarkdown, t as MarkdownRenderer } from "../MarkdownRenderer-BMhuurZW.js";
-export { MarkdownRenderer, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer };
+import { HTMLComponents } from "../html/types.js";
+import { MarkdownProviderOptions } from "./MarkdownProvider.js";
+import { ComponentChildren, FunctionComponent, JSX } from "preact";
+
+//#region src/markdown/MarkdownRenderer.d.ts
+type RenderMarkdownProps = MarkdownProviderOptions & {
+  /**
+   * Component overrides for HTML tags.
+   * Only used if not wrapped in a MarkdownProvider.
+   */
+  components?: HTMLComponents<'permissive', {}>;
+  /**
+   * Wrapper element or component to be used when there are multiple children.
+   * Only used if not wrapped in a MarkdownProvider.
+   */
+  wrapper?: FunctionComponent<any>;
+};
+declare const renderMarkdown: (content: string, {
+  components,
+  wrapper,
+  forceBlock,
+  forceInline,
+  preserveFrontmatter,
+  tagfilter
+}?: RenderMarkdownProps) => JSX.Element;
+declare const useMarkdownRenderer: ({
+  components,
+  wrapper,
+  forceBlock,
+  forceInline,
+  preserveFrontmatter,
+  tagfilter
+}?: RenderMarkdownProps) => (content: string) => ComponentChildren;
+type MarkdownRendererProps = RenderMarkdownProps & {
+  /**
+   * The markdown content to render.
+   */
+  children: string;
+  /**
+   * Custom render function for markdown.
+   * If provided, it will overwrite context and default rendering.
+   */
+  renderMarkdown?: (markdown: string, options?: {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: FunctionComponent<any>;
+    forceBlock?: boolean;
+    forceInline?: boolean;
+    preserveFrontmatter?: boolean;
+    tagfilter?: boolean;
+  }) => ComponentChildren;
+};
+/**
+ * Preact component that renders markdown to JSX.
+ *
+ * It uses the renderMarkdown function from the MarkdownProvider context if available.
+ * Otherwise, it falls back to the default compiler with provided components and options.
+ */
+declare const MarkdownRenderer: FunctionComponent<MarkdownRendererProps>;
+//#endregion
+export { MarkdownRenderer, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer };
+//# sourceMappingURL=MarkdownRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;KAQY,mBAAA,GAAsB,uBAAA;;AAAlC;;;EAKE,UAAA,GAAa,cAAA;EAAA;;;;EAKb,OAAA,GAAU,iBAAA;AAAA;AAAA,cAGC,cAAA,GACX,OAAA;EACA,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOG,mBAAA,KACF,GAAA,CAAI,OAAA;AAAA,cAeM,mBAAA;EAAuB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOjC,mBAAA,MAGO,OAAA,aAAe,iBAAA;AAAA,KAuBpB,qBAAA,GAAwB,mBAAA;EA7DA;;AAG7B;EA8DE,QAAA;;;;;EAKA,cAAA,IACE,QAAA,UACA,OAAA;IACE,UAAA,GAAa,cAAA;IACb,OAAA,GAAU,iBAAA;IACV,UAAA;IACA,WAAA;IACA,mBAAA;IACA,SAAA;EAAA,MAEC,iBAAA;AAAA;;;;;;;cASM,gBAAA,EAAkB,iBAAA,CAAkB,qBAAA"}

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

@@ -1,2 +1,23 @@
-import { n as MarkdownRendererPlugin, t as MarkdownMetadataRenderer } from "../MarkdownRendererPlugin-DFRVdHCA.js";
-export { MarkdownMetadataRenderer, MarkdownRendererPlugin };
+import { HTMLComponents } from "../html/types.js";
+import { MarkdownProviderOptions } from "./MarkdownProvider.js";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { FunctionComponent } from "preact";
+import { KeyPath } from "@intlayer/types/keyPath";
+
+//#region src/markdown/MarkdownRendererPlugin.d.ts
+type MarkdownRendererPluginProps = {
+  dictionaryKey: string;
+  keyPath: KeyPath[];
+  locale?: LocalesValues;
+  children: string;
+  options?: MarkdownProviderOptions;
+  components?: HTMLComponents<'permissive', {}>;
+};
+declare const MarkdownRendererPlugin: FunctionComponent<MarkdownRendererPluginProps>;
+type MarkdownMetadataRendererProps = MarkdownRendererPluginProps & {
+  metadataKeyPath: KeyPath[];
+};
+declare const MarkdownMetadataRenderer: FunctionComponent<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":";;;;;;;KAeK,2BAAA;EACH,aAAA;EACA,OAAA,EAAS,OAAA;EACT,MAAA,GAAS,aAAA;EACT,QAAA;EACA,OAAA,GAAU,uBAAA;EACV,UAAA,GAAa,cAAA;AAAA;AAAA,cAGF,sBAAA,EAAwB,iBAAA,CACnC,2BAAA;AAAA,KAYG,6BAAA,GAAgC,2BAAA;EACnC,eAAA,EAAiB,OAAA;AAAA;AAAA,cAGN,wBAAA,EAA0B,iBAAA,CACrC,6BAAA"}

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

@@ -1,2 +1,14 @@
-import { a as compiler, i as compileMarkdown, n as RuleType, o as defaultSanitizer, r as compile, s as defaultSlugify, t as MarkdownCompilerOptions } from "../compiler-BB0gAVbe.js";
-export { MarkdownCompilerOptions, RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
+import { CompileOptions, RuleType, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core/markdown";
+
+//#region src/markdown/compiler.d.ts
+type MarkdownCompilerOptions = CompileOptions;
+/**
+ * Compile markdown to Preact VNodes.
+ * This is the primary export - use this for new code.
+ */
+declare const compileMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => unknown;
+declare const compiler: (markdown?: string, options?: MarkdownCompilerOptions) => unknown;
+declare const compile: (markdown?: string, options?: MarkdownCompilerOptions) => unknown;
+//#endregion
+export { MarkdownCompilerOptions, RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
+//# sourceMappingURL=compiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;KAiBY,uBAAA,GAA0B,cAAA;;AAMtC;;;cAAa,eAAA,GACX,QAAA,WACA,OAAA,GAAS,uBAAA;AAAA,cAIE,QAAA,GAAQ,QAAA,WALH,OAAA,GACP,uBAAA;AAAA,cAKE,OAAA,GAAO,QAAA,WANF,OAAA,GACP,uBAAA"}

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

@@ -1,6 +1,6 @@
-import { a as compiler, i as compileMarkdown, n as RuleType, o as defaultSanitizer, r as compile, s as defaultSlugify, t as MarkdownCompilerOptions } from "../compiler-BB0gAVbe.js";
-import { n as MarkdownProviderOptions, r as useMarkdownContext, t as MarkdownProvider } from "../MarkdownProvider-chUIO05u.js";
-import { i as useMarkdownRenderer, n as RenderMarkdownProps, r as renderMarkdown, t as MarkdownRenderer } from "../MarkdownRenderer-BMhuurZW.js";
-import { n as MarkdownRendererPlugin, t as MarkdownMetadataRenderer } from "../MarkdownRendererPlugin-DFRVdHCA.js";
-import { t as preactRuntime } from "../runtime-BMHAtT-R.js";
+import { MarkdownCompilerOptions, RuleType, compile, compileMarkdown, compiler, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "./compiler.js";
+import { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext } from "./MarkdownProvider.js";
+import { MarkdownRenderer, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.js";
+import { MarkdownMetadataRenderer, MarkdownRendererPlugin } from "./MarkdownRendererPlugin.js";
+import preactRuntime from "./runtime.js";
 export { MarkdownCompilerOptions, MarkdownMetadataRenderer, MarkdownProvider, MarkdownProviderOptions, MarkdownRenderer, MarkdownRendererPlugin, RenderMarkdownProps, RuleType, compile, compileMarkdown, compiler, preactRuntime, renderMarkdown, defaultSanitizer as sanitizer, defaultSlugify as slugify, useMarkdownContext, useMarkdownRenderer };