@feugene/fint-i18n 0.2.3 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fureev Eugene
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunks/core-UYOFg8gl.js

@@ -0,0 +1,384 @@
+import { n as e, t } from "./loader-registry-B_fUe8pM.js";
+import { computed as n, isRef as r, reactive as i, readonly as a, ref as o } from "vue";
+//#region src/core/compiler.ts
+function s(e) {
+	if (!e.includes("{") && !e.includes("}}")) return () => e;
+	let t = [], n = 0, r = !1, i = /\{\{|\}\}|\{([\w.-]+)\}/g, a = i.exec(e);
+	for (; a;) a.index > n && t.push(e.slice(n, a.index)), a[0] === "{{" ? t.push("{") : a[0] === "}}" ? t.push("}") : (t.push({
+		key: a[1],
+		fallback: a[0]
+	}), r = !0), n = a.index + a[0].length, a = i.exec(e);
+	if (n < e.length && t.push(e.slice(n)), !r) {
+		let e = t.join("");
+		return () => e;
+	}
+	return (e) => {
+		let n = "";
+		for (let r of t) if (typeof r == "string") n += r;
+		else {
+			let t = e?.[r.key];
+			n += t == null ? r.fallback : String(t);
+		}
+		return n;
+	};
+}
+//#endregion
+//#region src/core/hooks.ts
+var c = class {
+	hooks = /* @__PURE__ */ new Map();
+	on(e, t) {
+		let n = this.hooks.get(e);
+		return n ? n.push(t) : this.hooks.set(e, [t]), () => this.off(e, t);
+	}
+	has(e) {
+		let t = this.hooks.get(e);
+		return !!t && t.length > 0;
+	}
+	off(e, t) {
+		let n = this.hooks.get(e);
+		if (n) {
+			let r = n.indexOf(t);
+			r !== -1 && (n.splice(r, 1), n.length === 0 && this.hooks.delete(e));
+		}
+	}
+	emit(e, t) {
+		let n = this.hooks.get(e);
+		if (!n || n.length === 0) return Promise.resolve(t);
+		let r = t, i = n.slice();
+		return (async () => {
+			for (let e of i) {
+				let t = await e(r);
+				t !== void 0 && (r = t);
+			}
+			return r;
+		})();
+	}
+	emitSync(e, t) {
+		let n = this.hooks.get(e);
+		if (!n || n.length === 0) return t;
+		let r = t, i = n.slice();
+		for (let t of i) {
+			let n = t(r);
+			if (n instanceof Promise) {
+				console.warn(`[fint-i18n] Sync hook "${e}" received a promise from handler. This will be ignored in sync execution.`);
+				continue;
+			}
+			n !== void 0 && (r = n);
+		}
+		return r;
+	}
+};
+//#endregion
+//#region src/core/message-utils.ts
+function l(e) {
+	return !!e && typeof e == "object" && !Array.isArray(e);
+}
+function u(e, t) {
+	for (let n in t) l(t[n]) ? (l(e[n]) || (e[n] = {}), u(e[n], t[n])) : e[n] = t[n];
+}
+function d(e, t) {
+	if (l(e) && l(t)) {
+		let n = i({});
+		return u(n, e), u(n, t), n;
+	}
+	return t;
+}
+function f(e, t) {
+	let n = e, r = 0;
+	for (; n && typeof n == "object";) {
+		let e = t.indexOf(".", r), i = e === -1 ? t.slice(r) : t.slice(r, e);
+		if (n = n[i], n === void 0 || e === -1) return n;
+		r = e + 1;
+	}
+}
+//#endregion
+//#region src/core/translate-params.ts
+function p(e) {
+	if (!e) return;
+	let t;
+	for (let n in e) {
+		let i = e[n];
+		r(i) && (t ||= { ...e }, t[n] = i.value);
+	}
+	return t || e;
+}
+//#endregion
+//#region src/core/instance.ts
+var m = class {
+	locale;
+	fallbackLocale;
+	messagesStore = i({});
+	messages = a(this.messagesStore);
+	localeRef;
+	preloadFallback;
+	unloadUnusedBlocks;
+	compiledMessages = Object.create(null);
+	loaderRegistry;
+	loadingBlocks = /* @__PURE__ */ new Map();
+	loadedBlocks = /* @__PURE__ */ new Map();
+	blockUsageCounters = /* @__PURE__ */ new Map();
+	patternExpansionCache = /* @__PURE__ */ new Map();
+	pendingUsedBlockLoads = /* @__PURE__ */ new Map();
+	localeEpoch = 0;
+	missingKeyReported = /* @__PURE__ */ new Set();
+	localeSetterWarned = !1;
+	installedPlugins = [];
+	hooks = new c();
+	constructor(e) {
+		this.localeRef = o(e.locale), this.locale = n({
+			get: () => this.localeRef.value,
+			set: (e) => {
+				this.localeSetterWarned || (this.localeSetterWarned = !0, console.warn("[fint-i18n] Direct assignment to `locale.value` is deprecated, use `setLocale()` instead")), this.setLocale(e);
+			}
+		}), this.fallbackLocale = e.fallbackLocale || "", this.preloadFallback = e.preloadFallback ?? !1, this.unloadUnusedBlocks = e.unloadUnusedBlocks ?? !1, this.loaderRegistry = new t(e.loaders), e.plugins && e.plugins.forEach((e) => {
+			e.install(this), this.installedPlugins.push(e);
+		}), this.hooks.emitSync("afterInit", void 0);
+	}
+	dispose = () => {
+		for (let e of this.installedPlugins) e.uninstall?.(this);
+		this.installedPlugins.length = 0;
+	};
+	addLoaders = (e) => {
+		this.loaderRegistry.add(e), this.patternExpansionCache.clear();
+	};
+	getKnownLocales = () => this.loaderRegistry.getKnownLocales();
+	t = (e, t, n) => {
+		let r = this.localeRef.value, i = p(t), a = this.resolve(r, e, i);
+		if (a === void 0) {
+			let t = n?.fallbackLocale || this.fallbackLocale;
+			t && t !== r && (a = this.resolve(t, e, i));
+		}
+		let o = this.hooks.emitSync("onTranslate", {
+			key: e,
+			params: i,
+			result: a
+		});
+		return o.result === void 0 ? (this.reportMissingKey(e, r), e) : o.result;
+	};
+	reportMissingKey = (e, t) => {
+		let n = `${t}:${e}`;
+		this.missingKeyReported.has(n) || (this.missingKeyReported.add(n), this.hooks.emit("onMissingKey", {
+			key: e,
+			locale: t
+		}).catch((e) => {
+			console.error("[fint-i18n] Error in onMissingKey hook:", e);
+		}));
+	};
+	reportError = (e, t = {}) => {
+		this.hooks.has("onError") ? this.hooks.emit("onError", {
+			error: e,
+			...t
+		}).catch((e) => {
+			console.error("[fint-i18n] Error in onError hook:", e);
+		}) : console.error("[fint-i18n] Unhandled error:", e, t);
+	};
+	resolve = (e, t, n) => {
+		let r = this.compiledMessages[e]?.[t];
+		if (r) return r(n);
+		let i = this.messagesStore[e];
+		if (!i) return;
+		let a = f(i, t);
+		if (typeof a == "string") {
+			let r = s(a);
+			return this.setCompiled(e, t, r), r(n);
+		}
+		if (typeof a == "function") {
+			let r = a;
+			return this.setCompiled(e, t, r), r(n);
+		}
+		if (a != null && typeof a != "object") return String(a);
+	};
+	setCompiled = (e, t, n) => {
+		this.compiledMessages[e] || (this.compiledMessages[e] = Object.create(null)), this.compiledMessages[e][t] = n;
+	};
+	invalidateCompiled = (e, t) => {
+		let n = this.compiledMessages[e];
+		if (!n) return;
+		let r = `${t}.`;
+		for (let e in n) (e === t || e.startsWith(r)) && delete n[e];
+	};
+	expandPattern = (e) => {
+		let t = this.patternExpansionCache.get(e);
+		if (t) return t;
+		let n = this.loaderRegistry.expandPattern(e);
+		return this.patternExpansionCache.set(e, n), n;
+	};
+	loadBlock = async (t, n) => {
+		let r = n || this.localeRef.value;
+		if (e(t)) {
+			let e = this.expandPattern(t);
+			if (e.length === 0) {
+				console.warn(`[fint-i18n] Pattern "${t}" did not match any registered block (locale "${r}")`);
+				return;
+			}
+			await Promise.all(e.map((e) => this.loadBlock(e, r)));
+			return;
+		}
+		let i = [this.loadConcreteBlock(t, r)];
+		this.preloadFallback && this.fallbackLocale && this.fallbackLocale !== r && i.push(this.loadConcreteBlock(t, this.fallbackLocale)), await Promise.all(i);
+	};
+	loadConcreteBlock = async (e, t) => {
+		let n = `${t}:${e}`;
+		if (this.isBlockLoaded(e, t)) return;
+		if (this.loadingBlocks.has(n)) return this.loadingBlocks.get(n);
+		await this.hooks.emit("beforeLoadBlock", e);
+		let r = (async () => {
+			try {
+				let n = this.loaderRegistry.resolve(t, e);
+				if (!n) {
+					console.warn(`[fint-i18n] No loader for block "${e}" in locale "${t}"`);
+					return;
+				}
+				let r;
+				for (let e of n.loaders) {
+					let i = await e(), a = i && typeof i == "object" && "default" in i && i.default ? i.default : i;
+					this.mergeMessages(t, n.resolvedBlockName, a), r = r === void 0 ? a : d(r, a);
+				}
+				this.markBlockLoaded(n.resolvedBlockName, t), await this.hooks.emit("afterLoadBlock", {
+					block: n.resolvedBlockName,
+					locale: t,
+					messages: r
+				});
+			} finally {
+				this.loadingBlocks.delete(n);
+			}
+		})();
+		return this.loadingBlocks.set(n, r), r;
+	};
+	mergeMessages = (e, t, n) => {
+		this.invalidateCompiled(e, t), this.messagesStore[e] || (this.messagesStore[e] = i({}));
+		let r = t.split("."), a = r[0];
+		if (r.length === 1) l(n) ? ((!this.messagesStore[e][a] || typeof this.messagesStore[e][a] != "object") && (this.messagesStore[e][a] = i({})), u(this.messagesStore[e][a], n)) : this.messagesStore[e][a] = n;
+		else {
+			(!this.messagesStore[e][a] || typeof this.messagesStore[e][a] != "object") && (this.messagesStore[e][a] = i({}));
+			let t = this.messagesStore[e][a];
+			for (let e = 1; e < r.length; e++) {
+				let n = r[e];
+				(!t[n] || typeof t[n] != "object") && (t[n] = i({})), t = t[n];
+			}
+			u(t, n);
+		}
+		this.precompileBlock(e, t, n);
+	};
+	precompileBlock = (e, t, n) => {
+		if (typeof n == "string") {
+			let r = s(n);
+			this.setCompiled(e, t, r);
+			return;
+		}
+		if (typeof n == "function") {
+			this.setCompiled(e, t, n);
+			return;
+		}
+		if (l(n)) for (let r in n) {
+			let i = n[r], a = `${t}.${r}`;
+			if (typeof i == "string") {
+				let t = s(i);
+				this.setCompiled(e, a, t);
+			} else typeof i == "function" ? this.setCompiled(e, a, i) : l(i) && this.precompileBlock(e, a, i);
+		}
+	};
+	isBlockLoaded = (e, t) => {
+		let n = t || this.localeRef.value, r = this.loadedBlocks.get(n);
+		if (!r) return !1;
+		if (r.has(e)) return !0;
+		let i = e.split("."), a = "";
+		for (let e = 0; e < i.length - 1; e++) if (a = a ? `${a}.${i[e]}` : i[e], r.has(a)) return !0;
+		return !1;
+	};
+	markBlockLoaded = (e, t) => {
+		this.loadedBlocks.has(t) || this.loadedBlocks.set(t, /* @__PURE__ */ new Set()), this.loadedBlocks.get(t).add(e), this.missingKeyReported.clear();
+	};
+	loadUsedBlocks = async (e) => {
+		let t = "";
+		for (;;) {
+			let n = this.pendingUsedBlockLoads.get(e);
+			if (n) {
+				await n;
+				continue;
+			}
+			let r = [];
+			for (let [t, n] of this.blockUsageCounters.entries()) n > 0 && !this.isBlockLoaded(t, e) && r.push(t);
+			if (r.length === 0) return;
+			let i = r.join(",");
+			if (i === t) return;
+			t = i;
+			let a = (async () => {
+				(await Promise.allSettled(r.map((t) => this.loadBlock(t, e)))).forEach((t, n) => {
+					t.status === "rejected" && this.reportError(t.reason, {
+						block: r[n],
+						locale: e
+					});
+				});
+			})();
+			this.pendingUsedBlockLoads.set(e, a);
+			try {
+				await a;
+			} finally {
+				this.pendingUsedBlockLoads.delete(e);
+			}
+		}
+	};
+	hasUnloadedUsedBlocks = (e) => {
+		if (this.pendingUsedBlockLoads.has(e)) return !0;
+		for (let [t, n] of this.blockUsageCounters.entries()) if (n > 0 && !this.isBlockLoaded(t, e)) return !0;
+		return !1;
+	};
+	setLocale = async (e) => {
+		let t = this.localeRef.value;
+		if (t === e) return;
+		let n = ++this.localeEpoch;
+		this.hasUnloadedUsedBlocks(e) && (await this.loadUsedBlocks(e), n !== this.localeEpoch) || (this.localeRef.value = e, this.missingKeyReported.clear(), this.hooks.emitSync("onLocaleChange", {
+			locale: e,
+			previous: t
+		}));
+	};
+	registerUsage = (t) => {
+		if (e(t)) {
+			let e = this.expandPattern(t);
+			if (e.length === 0) {
+				console.warn(`[fint-i18n] Pattern "${t}" did not match any registered block`);
+				return;
+			}
+			for (let t = 0; t < e.length; t++) this.incrementUsage(e[t]);
+			return;
+		}
+		this.incrementUsage(t);
+	};
+	registerBlocks = (e) => {
+		for (let t = 0; t < e.length; t++) this.registerUsage(e[t]);
+	};
+	unregisterUsage = (t) => {
+		if (e(t)) {
+			let e = this.expandPattern(t);
+			for (let t = 0; t < e.length; t++) this.decrementUsage(e[t]);
+			return;
+		}
+		this.decrementUsage(t);
+	};
+	incrementUsage = (e) => {
+		let t = this.blockUsageCounters.get(e) || 0;
+		this.blockUsageCounters.set(e, t + 1);
+	};
+	decrementUsage = (e) => {
+		let t = this.blockUsageCounters.get(e) || 0;
+		t <= 1 ? (this.blockUsageCounters.delete(e), this.unloadUnusedBlocks && this.unloadBlockAllLocales(e)) : this.blockUsageCounters.set(e, t - 1);
+	};
+	unloadBlock = (e, t) => {
+		let n = t || this.localeRef.value, r = this.messagesStore[n];
+		if (r) {
+			let t = e.split("."), n = r;
+			for (let e = 0; e < t.length - 1 && n; e++) n = typeof n == "object" ? n[t[e]] : void 0;
+			n && typeof n == "object" && delete n[t[t.length - 1]];
+		}
+		this.invalidateCompiled(n, e), this.loadedBlocks.get(n)?.delete(e);
+	};
+	unloadBlockAllLocales = (e) => {
+		for (let t of this.loadedBlocks.keys()) this.unloadBlock(e, t);
+	};
+};
+function h(e) {
+	return new m(e);
+}
+//#endregion
+export { s as i, h as n, c as r, m as t };

package/dist/chunks/loader-registry-B_fUe8pM.js

@@ -0,0 +1,103 @@
+//#region src/core/loader-registry.ts
+var e = ".**", t = ".*";
+function n(n) {
+	return n.endsWith(t) || n.endsWith(e);
+}
+var r = class {
+	loaders;
+	knownBlockNames;
+	constructor(e) {
+		this.loaders = this.normalize(e), this.knownBlockNames = this.collectKnownBlockNames(this.loaders);
+	}
+	add(e) {
+		let t = Array.isArray(e) ? e : [e];
+		for (let e of t) this.mergeCollection(this.loaders, e);
+		this.knownBlockNames = this.collectKnownBlockNames(this.loaders);
+	}
+	getKnownBlockNames() {
+		return this.knownBlockNames;
+	}
+	getKnownLocales() {
+		return Object.keys(this.loaders);
+	}
+	expandPattern(n) {
+		let r = n.endsWith(e), i = !r && n.endsWith(t);
+		if (!r && !i) return [];
+		let a = n.slice(0, -(r ? 3 : 2));
+		if (!a) return [];
+		let o = `${a}.`, s = o.length, c = [];
+		for (let e = 0; e < this.knownBlockNames.length; e++) {
+			let t = this.knownBlockNames[e];
+			if (t.length <= s) continue;
+			let n = !0;
+			for (let e = 0; e < s; e++) if (t.charCodeAt(e) !== o.charCodeAt(e)) {
+				n = !1;
+				break;
+			}
+			if (n) {
+				if (!r) {
+					let e = !1;
+					for (let n = s; n < t.length; n++) if (t.charCodeAt(n) === 46) {
+						e = !0;
+						break;
+					}
+					if (e) continue;
+				}
+				c.push(t);
+			}
+		}
+		return c;
+	}
+	resolve(e, t) {
+		let n = this.loaders[e];
+		if (!n) return null;
+		if (n[t]) return {
+			resolvedBlockName: t,
+			loaders: n[t]
+		};
+		if (!t.includes(".")) return null;
+		let r = t.split(".");
+		for (let e = r.length - 1; e >= 1; e--) {
+			let t = r.slice(0, e).join("."), i = n[t];
+			if (i) return {
+				resolvedBlockName: t,
+				loaders: i
+			};
+		}
+		return null;
+	}
+	normalize(e) {
+		let t = Object.create(null);
+		if (!e) return t;
+		let n = Array.isArray(e) ? e : [e];
+		for (let e of n) this.mergeCollection(t, e);
+		return t;
+	}
+	mergeCollection(e, t) {
+		for (let n in t) {
+			e[n] || (e[n] = Object.create(null));
+			let r = t[n];
+			for (let t in r) {
+				let i = this.normalizeEntry(r[t]);
+				if (!e[n][t]) {
+					e[n][t] = i;
+					continue;
+				}
+				e[n][t] = [...e[n][t], ...i];
+			}
+		}
+	}
+	normalizeEntry(e) {
+		return Array.isArray(e) ? e : [e];
+	}
+	collectKnownBlockNames(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let n in e) {
+			let r = e[n];
+			for (let e in r) t.add(e);
+		}
+		return Array.from(t);
+	}
+};
+//#endregion
+export { n, r as t };

package/dist/core.js

@@ -1,2 +1,2 @@
-import { i as e, n as t, r as n, t as r } from "./chunks/core-CJdrAmJT.js";
+import { i as e, n as t, r as n, t as r } from "./chunks/core-UYOFg8gl.js";
 export { r as FintI18n, n as HookManager, e as compileTemplate, t as createFintI18n };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { i as e, n as t, r as n, t as r } from "./chunks/core-CJdrAmJT.js";
-import { FINT_I18N_KEY as i, createVTDirective as a, installI18n as o, useFintI18n as s, useI18nScope as c } from "./vue.js";
-import { BridgePlugin as l, HookLoggerPlugin as u, PersistencePlugin as d } from "./plugins.js";
-export { l as BridgePlugin, i as FINT_I18N_KEY, r as FintI18n, u as HookLoggerPlugin, n as HookManager, d as PersistencePlugin, e as compileTemplate, t as createFintI18n, a as createVTDirective, o as installI18n, s as useFintI18n, c as useI18nScope };
+import { i as e, n as t, r as n, t as r } from "./chunks/core-UYOFg8gl.js";
+import { FINT_I18N_KEY as i, createFintI18nPlugin as a, createVTDirective as o, installI18n as s, useFintI18n as c, useI18nScope as l, useI18nScopeSync as u } from "./vue.js";
+import { BridgePlugin as d, HookLoggerPlugin as f, PersistencePlugin as p } from "./plugins.js";
+export { d as BridgePlugin, i as FINT_I18N_KEY, r as FintI18n, f as HookLoggerPlugin, n as HookManager, p as PersistencePlugin, e as compileTemplate, t as createFintI18n, a as createFintI18nPlugin, o as createVTDirective, s as installI18n, c as useFintI18n, l as useI18nScope, u as useI18nScopeSync };

package/dist/plugins.js

@@ -1,8 +1,10 @@
-import { watch as e } from "vue";
+import { isRef as e, watch as t } from "vue";
 //#region src/plugins/persistence.ts
-var t = class {
+var n = class {
 	name = "persistence";
 	options;
+	offLocaleChange;
+	storageListener;
 	constructor(e = {}) {
 		this.options = {
 			key: "fint-i18n-locale",
@@ -13,44 +15,58 @@ var t = class {
 	install(e) {
 		let t = this.options.key, n = this.options.storage || (typeof window < "u" ? window.localStorage : void 0);
 		if (!n || typeof n.getItem != "function") return;
-		let r = n.getItem(t);
-		r && (e.locale.value = r), e.hooks.on("onLocaleChange", ({ locale: e }) => {
+		let r = (t) => {
+			if (!t) return !1;
+			let n = e.getKnownLocales();
+			return n.length === 0 || n.includes(t);
+		}, i = n.getItem(t);
+		r(i) && i !== e.locale.value && e.setLocale(i), this.offLocaleChange = e.hooks.on("onLocaleChange", ({ locale: e }) => {
 			n.setItem(t, e);
-		}), this.options.syncTabs && typeof window < "u" && window.addEventListener("storage", (n) => {
-			n.key === t && n.newValue && n.newValue !== e.locale.value && (e.locale.value = n.newValue);
-		});
+		}), this.options.syncTabs && typeof window < "u" && (this.storageListener = (n) => {
+			n.key === t && r(n.newValue) && n.newValue !== e.locale.value && e.setLocale(n.newValue);
+		}, window.addEventListener("storage", this.storageListener));
 	}
-}, n = class {
+	uninstall() {
+		this.offLocaleChange?.(), this.offLocaleChange = void 0, this.storageListener && typeof window < "u" && (window.removeEventListener("storage", this.storageListener), this.storageListener = void 0);
+	}
+}, r = class {
 	name = "bridge";
 	options;
+	stopLocaleWatch;
+	hookUnsubscribers = [];
 	constructor(e) {
 		this.options = e;
 	}
-	install(t) {
-		let n = this.options.i18n;
-		e(() => n.locale.value || n.locale, (e) => {
-			t.locale.value !== e && (t.locale.value = e);
-		}, { immediate: !0 }), t.hooks.on("onLocaleChange", ({ locale: e }) => {
-			typeof n.locale == "object" ? n.locale.value = e : n.locale = e;
-		}), t.hooks.on("onTranslate", (e) => {
-			let t = e.params ? n.t(e.key, e.params) : n.t(e.key);
+	install(n) {
+		let r = this.options.i18n, i = "global" in r ? r.global : r, a = this.options.priority ?? "fint", o = e(i.locale) ? () => i.locale.value : () => i.locale;
+		this.stopLocaleWatch = t(o, (e) => {
+			n.locale.value !== e && n.setLocale(e);
+		}, { immediate: !0 }), this.hookUnsubscribers.push(n.hooks.on("onLocaleChange", ({ locale: t }) => {
+			e(i.locale) ? i.locale.value = t : i.locale = t;
+		})), this.hookUnsubscribers.push(n.hooks.on("onTranslate", (e) => {
+			if (a === "fint" && e.result !== void 0) return e;
+			let t = e.params ? i.t(e.key, e.params) : i.t(e.key);
 			return t === e.key ? e : {
 				...e,
 				result: t
 			};
-		});
+		}));
+	}
+	uninstall() {
+		this.stopLocaleWatch?.(), this.stopLocaleWatch = void 0, this.hookUnsubscribers.forEach((e) => e()), this.hookUnsubscribers = [];
 	}
-}, r = [
-	"beforeInit",
+}, i = [
 	"afterInit",
 	"onLocaleChange",
 	"beforeLoadBlock",
 	"afterLoadBlock",
 	"onMissingKey",
-	"onTranslate"
-], i = class {
+	"onTranslate",
+	"onError"
+], a = class {
 	name = "hook-logger";
 	options;
+	hookUnsubscribers = [];
 	constructor(e = {}) {
 		this.options = {
 			logger: console.log,
@@ -59,11 +75,14 @@ var t = class {
 		};
 	}
 	install(e) {
-		r.forEach((t) => this.registerHook(e, t));
+		i.forEach((t) => this.registerHook(e, t));
+	}
+	uninstall() {
+		this.hookUnsubscribers.forEach((e) => e()), this.hookUnsubscribers = [];
 	}
 	registerHook(e, t) {
-		e.hooks.on(t, (e) => (this.options.logger(`${this.options.prefix} "${t}" called`, e), e));
+		this.hookUnsubscribers.push(e.hooks.on(t, (e) => (this.options.logger(`${this.options.prefix} "${t}" called`, e), e)));
 	}
 };
 //#endregion
-export { n as BridgePlugin, i as HookLoggerPlugin, t as PersistencePlugin };
+export { r as BridgePlugin, a as HookLoggerPlugin, n as PersistencePlugin };

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

@@ -2,5 +2,10 @@ export type MessageFunction = (params?: Record<string, any>) => string;
 /**
  * JIT-компилятор шаблонов.
  * Преобразует строку "Привет, {name}!" в функцию (p) => "Привет, " + p.name + "!"
+ *
+ * Синтаксис:
+ * - `{name}` — подстановка параметра; имя: буквы/цифры/`_`, а также `.` и `-`.
+ * - `{{` и `}}` — экранирование: выводятся как литеральные `{` и `}`.
+ * - Отсутствующий или null/undefined параметр оставляет плейсхолдер как есть.
  */
 export declare function compileTemplate(template: string): MessageFunction;

package/dist/types/core/hooks.d.ts

@@ -2,7 +2,7 @@ import type { Locale } from './types';
 export type HookFn<T = any> = (arg: T) => void | T | Promise<void | T>;
 type HookPayload<K extends keyof FintI18nHooks> = Parameters<FintI18nHooks[K]>[0];
 export interface FintI18nHooks {
-    'beforeInit': HookFn<any>;
+    /** Эмитится синхронно в конце конструктора — подписаться успевают только плагины. */
     'afterInit': HookFn<void>;
     'onLocaleChange': HookFn<{
         locale: Locale;
@@ -23,10 +23,17 @@ export interface FintI18nHooks {
         params?: any;
         result: string | undefined;
     }>;
+    /** Ошибки асинхронной загрузки блоков. Без подписчиков — console.error. */
+    'onError': HookFn<{
+        error: unknown;
+        block?: string;
+        locale?: Locale;
+    }>;
 }
 export declare class HookManager {
     private hooks;
     on<K extends keyof FintI18nHooks>(name: K, fn: FintI18nHooks[K]): () => void;
+    has<K extends keyof FintI18nHooks>(name: K): boolean;
     off<K extends keyof FintI18nHooks>(name: K, fn: FintI18nHooks[K]): void;
     emit<K extends keyof FintI18nHooks>(name: K, arg: HookPayload<K>): Promise<HookPayload<K>>;
     emitSync<K extends keyof FintI18nHooks>(name: K, arg: HookPayload<K>): HookPayload<K>;