lit-intlayer 8.4.10

package/dist/esm/client/useLocaleStorage.mjs

@@ -0,0 +1,24 @@
+import { localeStorageOptions as e } from "@intlayer/core/localization";
+import { LocaleStorage as t, getLocaleFromStorage as n, setLocaleInStorage as r } from "@intlayer/core/utils";
+//#region src/client/useLocaleStorage.ts
+var i = n(e), a = i, o = (t, n) => r(t, {
+	...e,
+	isCookieEnabled: n
+}), s = o, c = (n) => {
+	let r = t({
+		...e,
+		isCookieEnabled: n
+	});
+	return {
+		localeStorage: r.getLocale(),
+		setLocaleStorage: r.setLocale
+	};
+}, l = (e) => {
+	let t = c(e);
+	return {
+		localeCookie: t.localeStorage,
+		setLocaleCookie: t.setLocaleStorage
+	};
+};
+//#endregion
+export { a as localeCookie, i as localeInStorage, s as setLocaleCookie, o as setLocaleInStorage, l as useLocaleCookie, c as useLocaleStorage };

package/dist/esm/client/useRewriteURL.mjs

@@ -0,0 +1,30 @@
+import { getIntlayerClient as e } from "./installIntlayer.mjs";
+import t from "@intlayer/config/built";
+import { getRewritePath as n } from "@intlayer/core/localization";
+//#region src/client/useRewriteURL.ts
+var r = class {
+	host;
+	_unsubscribe = null;
+	constructor(e) {
+		this.host = e, e.addController(this);
+	}
+	_rewrite(e) {
+		let r = t?.routing?.rewrite;
+		if (typeof window > "u" || !r) return;
+		let i = window.location.pathname, a = n(i, e, r);
+		a && a !== i && window.history.replaceState(window.history.state, "", a + window.location.search + window.location.hash);
+	}
+	hostConnected() {
+		let t = e();
+		this._rewrite(t.locale), this._unsubscribe = t.subscribe((e) => {
+			this._rewrite(e);
+		});
+	}
+	hostDisconnected() {
+		this._unsubscribe?.(), this._unsubscribe = null;
+	}
+}, i = (e) => {
+	new r(e);
+};
+//#endregion
+export { i as useRewriteURL };

package/dist/esm/editor/useEditor.mjs

@@ -0,0 +1,33 @@
+import { getIntlayerClient as e } from "../client/installIntlayer.mjs";
+import { isEnabled as t } from "@intlayer/editor/isEnabled";
+//#region src/editor/useEditor.ts
+var n = (t) => {
+	let n = !1, r = null;
+	return import("@intlayer/editor").then(({ initEditorClient: i }) => {
+		if (n) return;
+		let a = i(), o = e();
+		a.currentLocale.set(t), r = o.subscribe((e) => {
+			a.currentLocale.set(e);
+		});
+	}), () => {
+		n = !0, r?.(), import("@intlayer/editor").then(({ stopEditorClient: e }) => {
+			e();
+		});
+	};
+}, r = class {
+	host;
+	_stopEditor = null;
+	constructor(e) {
+		this.host = e, e.addController(this);
+	}
+	hostConnected() {
+		this._stopEditor = n(e().locale);
+	}
+	hostDisconnected() {
+		this._stopEditor?.(), this._stopEditor = null;
+	}
+}, i = (e) => {
+	process.env.INTLAYER_EDITOR_ENABLED === "false" || !t || new r(e);
+};
+//#endregion
+export { i as useEditor };

package/dist/esm/format/index.mjs

@@ -0,0 +1,2 @@
+import { useIntl as e } from "./useIntl.mjs";
+export { e as useIntl };

package/dist/esm/format/useIntl.mjs

@@ -0,0 +1,24 @@
+import { getIntlayerClient as e } from "../client/installIntlayer.mjs";
+import { bindIntl as t } from "@intlayer/core/utils";
+//#region src/format/useIntl.ts
+var n = class {
+	host;
+	_overrideLocale;
+	_unsubscribe = null;
+	value;
+	constructor(n, r) {
+		this.host = n, this._overrideLocale = r;
+		let i = e();
+		this.value = t(this._overrideLocale ?? i.locale), n.addController(this);
+	}
+	hostConnected() {
+		this._unsubscribe = e().subscribe((e) => {
+			this.value = t(this._overrideLocale ?? e), this.host.requestUpdate();
+		});
+	}
+	hostDisconnected() {
+		this._unsubscribe?.(), this._unsubscribe = null;
+	}
+}, r = (e, t) => new n(e, t);
+//#endregion
+export { r as useIntl };

package/dist/esm/getDictionary.mjs

@@ -0,0 +1,6 @@
+import { getPlugins as e } from "./plugins.mjs";
+import { getDictionary as t } from "@intlayer/core/interpreter";
+//#region src/getDictionary.ts
+var n = (n, r) => t(n, r, e(r));
+//#endregion
+export { n as getDictionary };

package/dist/esm/getIntlayer.mjs

@@ -0,0 +1,6 @@
+import { getPlugins as e } from "./plugins.mjs";
+import { getIntlayer as t } from "@intlayer/core/interpreter";
+//#region src/getIntlayer.ts
+var n = (n, r) => t(n, r, e(r));
+//#endregion
+export { n as getIntlayer };

package/dist/esm/html/HTMLRenderer.mjs

@@ -0,0 +1,24 @@
+import { useHTML as e } from "./installIntlayerHTML.mjs";
+import { LitElement as t, html as n, nothing as r } from "lit";
+import { unsafeHTML as i } from "lit/directives/unsafe-html.js";
+//#region src/html/HTMLRenderer.ts
+var a = (e, t = {}) => e, o = ({ components: t } = {}) => {
+	let n = e();
+	return (e) => n.renderHTML(e, { components: t });
+}, s = class extends t {
+	static properties = {
+		content: { type: String },
+		components: { attribute: !1 }
+	};
+	content = "";
+	components;
+	createRenderRoot() {
+		return this;
+	}
+	render() {
+		return this.content ? n`${i(o({ components: this.components })(this.content))}` : r;
+	}
+};
+customElements.get("intlayer-html-renderer") || customElements.define("intlayer-html-renderer", s);
+//#endregion
+export { s as HTMLRenderer, a as renderHTML, o as useHTMLRenderer };

package/dist/esm/html/index.mjs

@@ -0,0 +1,3 @@
+import { createIntlayerHTMLClient as e, installIntlayerHTML as t, useHTML as n } from "./installIntlayerHTML.mjs";
+import { HTMLRenderer as r, renderHTML as i, useHTMLRenderer as a } from "./HTMLRenderer.mjs";
+export { r as HTMLRenderer, e as createIntlayerHTMLClient, t as installIntlayerHTML, i as renderHTML, n as useHTML, a as useHTMLRenderer };

package/dist/esm/html/installIntlayerHTML.mjs

@@ -0,0 +1,18 @@
+//#region src/html/installIntlayerHTML.ts
+var e = null, t = (t) => e || (e = { renderHTML: t }, e), n = (e) => {
+	let n;
+	if (typeof e == "function") n = e;
+	else {
+		let { components: t, renderHTML: r } = e ?? {};
+		n = r || ((e, n) => {
+			let r = n && typeof n == "object" && "components" in n ? n.components : n, i = {
+				...t ?? {},
+				...r ?? {}
+			};
+			return Object.keys(i).length, e;
+		});
+	}
+	return t(n);
+}, r = () => e || { renderHTML: (e) => e };
+//#endregion
+export { t as createIntlayerHTMLClient, n as installIntlayerHTML, r as useHTML };

package/dist/esm/index.mjs

@@ -0,0 +1,21 @@
+import { getPlugins as e, htmlPlugin as t, insertionPlugin as n, intlayerNodePlugins as r, markdownPlugin as i, markdownStringPlugin as a } from "./plugins.mjs";
+import { getDictionary as o } from "./getDictionary.mjs";
+import { getIntlayer as s } from "./getIntlayer.mjs";
+import { IntlayerClient as c, createIntlayerClient as l, getIntlayerClient as u, installIntlayer as d } from "./client/installIntlayer.mjs";
+import { useDictionary as f } from "./client/useDictionary.mjs";
+import { useIntlayer as p } from "./client/useIntlayer.mjs";
+import { localeCookie as m, localeInStorage as h, setLocaleCookie as g, setLocaleInStorage as _, useLocaleCookie as v, useLocaleStorage as y } from "./client/useLocaleStorage.mjs";
+import { LocaleController as b, useLocale as x } from "./client/useLocale.mjs";
+import { useRewriteURL as S } from "./client/useRewriteURL.mjs";
+import "./client/index.mjs";
+import { useEditor as C } from "./editor/useEditor.mjs";
+import { useIntl as w } from "./format/useIntl.mjs";
+import { createIntlayerHTMLClient as T, installIntlayerHTML as E, useHTML as D } from "./html/installIntlayerHTML.mjs";
+import { HTMLRenderer as O, renderHTML as k, useHTMLRenderer as A } from "./html/HTMLRenderer.mjs";
+import "./html/index.mjs";
+import j, { createLitRuntime as M } from "./markdown/runtime.mjs";
+import { RuleType as N, compile as P, compileMarkdown as F, compiler as I, sanitizer as L, slugify as R } from "./markdown/compiler.mjs";
+import { createIntlayerMarkdownClient as z, installIntlayerMarkdown as B, useMarkdown as V } from "./markdown/installIntlayerMarkdown.mjs";
+import { MarkdownRenderer as H, renderMarkdown as U, useMarkdownRenderer as W } from "./markdown/MarkdownRenderer.mjs";
+import "./markdown/index.mjs";
+export { O as HTMLRenderer, c as IntlayerClient, b as LocaleController, H as MarkdownRenderer, N as RuleType, P as compile, F as compileMarkdown, I as compiler, l as createIntlayerClient, T as createIntlayerHTMLClient, z as createIntlayerMarkdownClient, M as createLitRuntime, o as getDictionary, s as getIntlayer, u as getIntlayerClient, e as getPlugins, t as htmlPlugin, n as insertionPlugin, d as installIntlayer, E as installIntlayerHTML, B as installIntlayerMarkdown, r as intlayerNodePlugins, j as litRuntime, m as localeCookie, h as localeInStorage, i as markdownPlugin, a as markdownStringPlugin, k as renderHTML, U as renderMarkdown, L as sanitizer, g as setLocaleCookie, _ as setLocaleInStorage, R as slugify, f as useDictionary, C as useEditor, D as useHTML, A as useHTMLRenderer, w as useIntl, p as useIntlayer, x as useLocale, v as useLocaleCookie, y as useLocaleStorage, V as useMarkdown, W as useMarkdownRenderer, S as useRewriteURL };

package/dist/esm/markdown/MarkdownRenderer.mjs

@@ -0,0 +1,55 @@
+import { compileMarkdown as e } from "./compiler.mjs";
+import { useMarkdown as t } from "./installIntlayerMarkdown.mjs";
+import { LitElement as n, html as r, nothing as i } from "lit";
+import { unsafeHTML as a } from "lit/directives/unsafe-html.js";
+//#region src/markdown/MarkdownRenderer.ts
+var o = (t, { forceBlock: n, forceInline: r, preserveFrontmatter: i, tagfilter: a } = {}) => e(t, {
+	forceBlock: n,
+	forceInline: r,
+	preserveFrontmatter: i,
+	tagfilter: a
+}), s = (e = {}) => {
+	let n = t();
+	return (t) => n.renderMarkdown(t, {
+		forceBlock: e.forceBlock,
+		forceInline: e.forceInline,
+		preserveFrontmatter: e.preserveFrontmatter,
+		tagfilter: e.tagfilter
+	}, e.components, e.wrapper);
+}, c = class extends n {
+	static properties = {
+		content: { type: String },
+		forceBlock: { type: Boolean },
+		forceInline: { type: Boolean },
+		preserveFrontmatter: { type: Boolean },
+		tagfilter: { type: Boolean },
+		renderMarkdown: { attribute: !1 }
+	};
+	content = "";
+	forceBlock;
+	forceInline;
+	preserveFrontmatter;
+	tagfilter;
+	renderMarkdownFn;
+	createRenderRoot() {
+		return this;
+	}
+	render() {
+		if (!this.content) return i;
+		let e;
+		return e = this.renderMarkdownFn ? this.renderMarkdownFn(this.content, {
+			forceBlock: this.forceBlock,
+			forceInline: this.forceInline,
+			preserveFrontmatter: this.preserveFrontmatter,
+			tagfilter: this.tagfilter
+		}, void 0, void 0) : s({
+			forceBlock: this.forceBlock,
+			forceInline: this.forceInline,
+			preserveFrontmatter: this.preserveFrontmatter,
+			tagfilter: this.tagfilter
+		})(this.content), r`${a(e)}`;
+	}
+};
+customElements.get("intlayer-markdown-renderer") || customElements.define("intlayer-markdown-renderer", c);
+//#endregion
+export { c as MarkdownRenderer, o as renderMarkdown, s as useMarkdownRenderer };

package/dist/esm/markdown/compiler.mjs

@@ -0,0 +1,6 @@
+import e from "./runtime.mjs";
+import { RuleType as t, compileWithOptions as n, sanitizer as r, slugify as i } from "@intlayer/core/markdown";
+//#region src/markdown/compiler.ts
+var a = (t = "", r = {}) => n(t, e, r), o = a, s = a;
+//#endregion
+export { t as RuleType, s as compile, a as compileMarkdown, o as compiler, r as sanitizer, i as slugify };

package/dist/esm/markdown/index.mjs

@@ -0,0 +1,5 @@
+import e, { createLitRuntime as t } from "./runtime.mjs";
+import { RuleType as n, compile as r, compileMarkdown as i, compiler as a, sanitizer as o, slugify as s } from "./compiler.mjs";
+import { createIntlayerMarkdownClient as c, installIntlayerMarkdown as l, useMarkdown as u } from "./installIntlayerMarkdown.mjs";
+import { MarkdownRenderer as d, renderMarkdown as f, useMarkdownRenderer as p } from "./MarkdownRenderer.mjs";
+export { d as MarkdownRenderer, n as RuleType, r as compile, i as compileMarkdown, a as compiler, c as createIntlayerMarkdownClient, t as createLitRuntime, l as installIntlayerMarkdown, e as litRuntime, f as renderMarkdown, o as sanitizer, s as slugify, u as useMarkdown, p as useMarkdownRenderer };

package/dist/esm/markdown/installIntlayerMarkdown.mjs

@@ -0,0 +1,31 @@
+import { compileMarkdown as e } from "./compiler.mjs";
+//#region src/markdown/installIntlayerMarkdown.ts
+var t = null, n = (e, n) => t || (t = {
+	components: n,
+	renderMarkdown: e
+}, t), r = (t) => {
+	let r, i;
+	if (typeof t == "function") r = t;
+	else {
+		let { components: n, wrapper: a, forceBlock: o, forceInline: s, preserveFrontmatter: c, tagfilter: l, renderMarkdown: u } = t ?? {};
+		if (i = n, u) r = u;
+		else {
+			let t = {
+				forceBlock: o,
+				forceInline: s,
+				preserveFrontmatter: c,
+				tagfilter: l
+			};
+			r = (n, r, i, a) => e(n, {
+				...t,
+				forceBlock: r?.forceBlock ?? t.forceBlock,
+				forceInline: r?.forceInline ?? t.forceInline,
+				preserveFrontmatter: r?.preserveFrontmatter ?? t.preserveFrontmatter,
+				tagfilter: r?.tagfilter ?? t.tagfilter
+			});
+		}
+	}
+	return n(r, i);
+}, i = () => t || { renderMarkdown: (t) => e(t) };
+//#endregion
+export { n as createIntlayerMarkdownClient, r as installIntlayerMarkdown, i as useMarkdown };

package/dist/esm/markdown/runtime.mjs

@@ -0,0 +1,51 @@
+//#region src/markdown/runtime.ts
+var e = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]), t = (e) => e ? Object.entries(e).filter(([, e]) => e != null).map(([e, t]) => typeof t == "boolean" ? t ? e : "" : e === "_innerHTML" ? "" : `${e}="${String(t).replace(/&/g, "&").replace(/"/g, """)}"`).filter(Boolean).join(" ") : "", n = "__lit_fragment__", r = {
+	createElement: (r, i, ...a) => {
+		let o = a.flat(Infinity).join("");
+		if (r === n) return o;
+		if (typeof r == "string") {
+			let n = t(i), a = n ? ` ${n}` : "", s = i?._innerHTML;
+			return e.has(r) ? `<${r}${a}>` : s === void 0 ? `<${r}${a}>${o}</${r}>` : `<${r}${a}>${s}</${r}>`;
+		}
+		if (typeof r == "function") try {
+			let e = r({
+				...i,
+				children: o
+			});
+			return typeof e == "string" ? e : o;
+		} catch {
+			return o;
+		}
+		return o;
+	},
+	cloneElement: (e, t, ...n) => typeof e == "string" ? e : String(e ?? ""),
+	Fragment: n,
+	normalizeProps: (e, t) => {
+		let n = {};
+		for (let [e, r] of Object.entries(t)) e === "className" ? n.class = r : e === "htmlFor" ? n.for = r : e === "dangerouslySetInnerHTML" && r?.__html ? n._innerHTML = r.__html : n[e] = r;
+		return n;
+	}
+}, i = (e = {}) => {
+	let { onCreateElement: t } = e;
+	return t ? {
+		...r,
+		createElement: (e, n, ...r) => t(e, n, r)
+	} : r;
+};
+//#endregion
+export { i as createLitRuntime, r as default, r as litRuntime };

package/dist/esm/plugins.mjs

@@ -0,0 +1,109 @@
+import { renderIntlayerNode as e } from "./renderIntlayerNode.mjs";
+import { conditionPlugin as t, enumerationPlugin as n, filePlugin as r, genderPlugin as i, nestedPlugin as a, splitInsertionTemplate as o, translationPlugin as s } from "@intlayer/core/interpreter";
+import c from "@intlayer/config/built";
+import { getMarkdownMetadata as l } from "@intlayer/core/markdown";
+import * as u from "@intlayer/types/nodeType";
+//#region src/plugins.ts
+var d = {
+	id: "intlayer-node-plugin",
+	canHandle: (e) => typeof e == "bigint" || typeof e == "string" || typeof e == "number",
+	transform: (t, { children: n, ...r }) => e({
+		...r,
+		value: n,
+		children: n
+	})
+}, f = {
+	id: "insertion-plugin",
+	canHandle: (e) => typeof e == "object" && e?.nodeType === u.INSERTION,
+	transform: (e, t, n) => {
+		let r = [...t.keyPath, { type: u.INSERTION }], i = e[u.INSERTION], a = {
+			id: "insertion-string-plugin",
+			canHandle: (e) => typeof e == "string",
+			transform: (e, n, r) => {
+				let i = r(e, {
+					...n,
+					children: e,
+					plugins: (t.plugins ?? []).filter((e) => e.id !== "intlayer-node-plugin")
+				});
+				return (e) => {
+					let a = o(i, e), s = a.isSimple ? a.parts : a.parts.join("");
+					return r(s, {
+						...n,
+						plugins: t.plugins,
+						children: s
+					});
+				};
+			}
+		};
+		return n(i, {
+			...t,
+			children: i,
+			keyPath: r,
+			plugins: [a, ...t.plugins ?? []]
+		});
+	}
+}, p = {
+	id: "markdown-string-plugin",
+	canHandle: (e) => typeof e == "string",
+	transform: (t, n, r) => {
+		let { plugins: i, ...a } = n, o = r(l(t) ?? {}, {
+			plugins: [{
+				id: "markdown-metadata-plugin",
+				canHandle: (e) => typeof e == "string" || typeof e == "number" || typeof e == "boolean" || !e,
+				transform: (n, r) => e({
+					...r,
+					value: n,
+					children: t
+				})
+			}],
+			dictionaryKey: a.dictionaryKey,
+			keyPath: []
+		});
+		return e({
+			...n,
+			value: t,
+			children: t,
+			additionalProps: {
+				metadata: o,
+				use: (e) => t
+			}
+		});
+	}
+}, m = {
+	id: "markdown-plugin",
+	canHandle: (e) => typeof e == "object" && e?.nodeType === u.MARKDOWN,
+	transform: (e, t, n) => {
+		let r = [...t.keyPath, { type: u.MARKDOWN }], i = e[u.MARKDOWN];
+		return n(i, {
+			...t,
+			children: i,
+			keyPath: r,
+			plugins: [p, ...t.plugins ?? []]
+		});
+	}
+}, h = {
+	id: "html-plugin",
+	canHandle: (e) => typeof e == "object" && e?.nodeType === u.HTML,
+	transform: (t, n) => {
+		let r = t[u.HTML];
+		return e({
+			...n,
+			value: r,
+			children: r,
+			additionalProps: { use: (e) => r }
+		});
+	}
+}, g = (e, o = !0) => [
+	s(e ?? c.internationalization.defaultLocale, o ? c.internationalization.defaultLocale : void 0),
+	n,
+	t,
+	a(e ?? c.internationalization.defaultLocale),
+	r,
+	i,
+	d,
+	f,
+	m,
+	h
+];
+//#endregion
+export { g as getPlugins, h as htmlPlugin, f as insertionPlugin, d as intlayerNodePlugins, m as markdownPlugin, p as markdownStringPlugin };

package/dist/esm/renderIntlayerNode.mjs

@@ -0,0 +1,25 @@
+//#region src/renderIntlayerNode.ts
+var e = ({ value: e, additionalProps: t = {} }) => {
+	let n = e, r = {
+		toString: () => String(n ?? ""),
+		valueOf: () => n,
+		[Symbol.toPrimitive]: () => n,
+		toJSON: () => n,
+		get raw() {
+			return n;
+		},
+		set raw(e) {
+			n = e;
+		},
+		get value() {
+			return n;
+		},
+		__update(e) {
+			n = e?.raw ?? e?.value ?? e;
+		},
+		...t
+	};
+	return Object.setPrototypeOf(r, String.prototype), r;
+};
+//#endregion
+export { e as renderIntlayerNode };

package/dist/types/src/client/index.d.ts

@@ -0,0 +1,6 @@
+export * from './installIntlayer';
+export * from './useDictionary';
+export * from './useIntlayer';
+export * from './useLocale';
+export * from './useLocaleStorage';
+export * from './useRewriteURL';

package/dist/types/src/client/installIntlayer.d.ts

@@ -0,0 +1,37 @@
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+type LocaleListener = (locale: LocalesValues) => void;
+export declare class IntlayerClient {
+    private _locale;
+    private _listeners;
+    isCookieEnabled: boolean;
+    constructor(locale?: LocalesValues, isCookieEnabled?: boolean);
+    get locale(): LocalesValues;
+    setLocale(newLocale: LocalesValues): void;
+    subscribe(listener: LocaleListener): () => void;
+}
+/**
+ * Create and return a single IntlayerClient instance.
+ */
+export declare const createIntlayerClient: (locale?: LocalesValues, isCookieEnabled?: boolean) => IntlayerClient;
+/**
+ * Get the current IntlayerClient instance, creating one with defaults if needed.
+ */
+export declare const getIntlayerClient: () => IntlayerClient;
+/**
+ * Install Intlayer into your Lit application.
+ *
+ * Call this once at application startup before any Lit elements are rendered.
+ *
+ * @param locale - Initial locale (defaults to config defaultLocale).
+ * @param isCookieEnabled - Whether to persist locale in cookies/localStorage.
+ * @returns The IntlayerClient singleton.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayer } from 'lit-intlayer';
+ *
+ * installIntlayer('en');
+ * ```
+ */
+export declare const installIntlayer: (locale?: LocalesValues, isCookieEnabled?: boolean) => IntlayerClient;
+export {};

package/dist/types/src/client/useDictionary.d.ts

@@ -0,0 +1,30 @@
+import { Dictionary } from '@intlayer/types/dictionary';
+import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { ReactiveControllerHost } from 'lit';
+import { DeepTransformContent } from '../plugins';
+/**
+ * Reactive hook that returns the translated content for a raw dictionary object.
+ *
+ * Unlike `useIntlayer` (which takes a registered key), this hook accepts a
+ * dictionary object directly — useful for dictionaries loaded asynchronously
+ * or defined inline.
+ *
+ * @param host       - The LitElement (or any ReactiveControllerHost).
+ * @param dictionary - The raw dictionary object.
+ * @param locale     - Optional locale override.
+ * @returns A reactive proxy to the dictionary content.
+ *
+ * @example
+ * ```ts
+ * import myDict from './myDictionary.content';
+ *
+ * class MyElement extends LitElement {
+ *   private content = useDictionary(this, myDict);
+ *
+ *   render() {
+ *     return html`<p>${this.content.greeting.value}</p>`;
+ *   }
+ * }
+ * ```
+ */
+export declare const useDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(host: ReactiveControllerHost, dictionary: T, locale?: L) => DeepTransformContent<T["content"], L>;

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

@@ -0,0 +1,29 @@
+import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types/module_augmentation';
+import { ReactiveControllerHost } from 'lit';
+import { DeepTransformContent } from '../plugins';
+/**
+ * Reactive hook that returns the translated dictionary for the given key.
+ *
+ * Works as a Lit ReactiveController: the host element automatically
+ * re-renders whenever the locale changes.
+ *
+ * The returned value is a transparent proxy of the dictionary content.
+ * Access fields directly without an extra `.value` wrapper.
+ *
+ * @param host - The LitElement (or any ReactiveControllerHost) that owns this hook.
+ * @param key  - The dictionary key registered in your intlayer content files.
+ * @param locale - Optional locale override (defaults to the current app locale).
+ * @returns A reactive proxy to the dictionary content.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends LitElement {
+ *   private content = useIntlayer(this, 'my-component');
+ *
+ *   render() {
+ *     return html`<h1>${this.content.title.value}</h1>`;
+ *   }
+ * }
+ * ```
+ */
+export declare const useIntlayer: <T extends DictionaryKeys>(host: ReactiveControllerHost, key: T, locale?: LocalesValues) => DeepTransformContent<DictionaryRegistryContent<T>>;

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

@@ -0,0 +1,62 @@
+import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+type UseLocaleProps = {
+    isCookieEnabled?: boolean;
+    onLocaleChange?: (locale: LocalesValues) => void;
+};
+/**
+ * ReactiveController that exposes the current locale and a `setLocale` setter.
+ * The host element re-renders whenever the locale changes.
+ */
+export declare class LocaleController implements ReactiveController {
+    private readonly host;
+    private readonly _isCookieEnabled;
+    private readonly _onLocaleChange;
+    private _unsubscribe;
+    /** The currently active locale. */
+    locale: DeclaredLocales;
+    /** The application's default locale (from config). */
+    readonly defaultLocale: DeclaredLocales;
+    /** All available locales (from config). */
+    readonly availableLocales: DeclaredLocales[];
+    constructor(host: ReactiveControllerHost, props?: UseLocaleProps);
+    /**
+     * Change the application locale.
+     * Validates against `availableLocales`, persists to storage, and triggers a re-render.
+     */
+    setLocale: (newLocale: LocalesValues) => void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+/**
+ * Reactive hook that provides locale management.
+ *
+ * Returns a `LocaleController` with:
+ * - `locale` — the current locale (updates the host on change)
+ * - `defaultLocale` — the config default locale
+ * - `availableLocales` — all configured locales
+ * - `setLocale(locale)` — switches the app locale
+ *
+ * @param host  - The LitElement (or any ReactiveControllerHost).
+ * @param props - Optional configuration.
+ * @returns A `LocaleController`.
+ *
+ * @example
+ * ```ts
+ * class LocaleSwitcher extends LitElement {
+ *   private locale = useLocale(this);
+ *
+ *   render() {
+ *     return html`
+ *       <select @change=${(e: Event) => this.locale.setLocale((e.target as HTMLSelectElement).value as any)}>
+ *         ${this.locale.availableLocales.map(
+ *           (loc) => html`<option value=${loc} ?selected=${loc === this.locale.locale}>${loc}</option>`
+ *         )}
+ *       </select>
+ *     `;
+ *   }
+ * }
+ * ```
+ */
+export declare const useLocale: (host: ReactiveControllerHost, props?: UseLocaleProps) => LocaleController;
+export {};