gt-react 10.19.16 → 10.19.18

package/dist/macros.mjs

@@ -28,7 +28,46 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
-//#region ../core/dist/base64-CWITCfhU.mjs
+//#region ../core/dist/base64-r7YWJYWt.mjs
+function ensureSentence(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	return /[.!?)]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function stripSentence(text) {
+	const trimmed = text.trim();
+	let end = trimmed.length;
+	while (end > 0) {
+		const char = trimmed[end - 1];
+		if (char !== "." && char !== "!" && char !== "?") break;
+		end -= 1;
+	}
+	return trimmed.slice(0, end);
+}
+function lowercaseFirstWord(text) {
+	return text.replace(/^[A-Z][a-z]/, (match) => match.toLowerCase());
+}
+function formatDetails(details) {
+	if (!details) return "";
+	const detailText = Array.isArray(details) ? details.join(", ") : details;
+	if (!detailText.trim()) return "";
+	return ensureSentence(`Details: ${detailText}`);
+}
+function createDiagnosticMessage({ source, severity, whatHappened, reassurance, why, fix, wayOut, details, docsUrl }) {
+	const prefix = source ? severity ? `${source} ${severity}:` : `${source}:` : severity ? `${severity}:` : "";
+	const whatAndWhy = why ? `${stripSentence(whatHappened)} because ${lowercaseFirstWord(stripSentence(why))}` : whatHappened;
+	const shouldCombineWayOut = !!fix && !!wayOut && /^[a-z]/.test(stripSentence(wayOut));
+	const messageParts = [
+		whatAndWhy,
+		reassurance,
+		shouldCombineWayOut ? `${stripSentence(fix)}, or ${lowercaseFirstWord(stripSentence(wayOut))}` : fix,
+		shouldCombineWayOut ? void 0 : wayOut,
+		formatDetails(details)
+	].filter((part) => !!part).map(ensureSentence);
+	if (docsUrl) messageParts.push(`Learn more: ${docsUrl}`);
+	const message = messageParts.join(" ");
+	return prefix ? `${prefix} ${message}` : message;
+}
 const defaultCacheUrl = "https://cdn.gtx.dev";
 //#endregion
 //#region ../core/dist/isVariable-fAKEB7gF.mjs
@@ -4303,7 +4342,7 @@ function sanitizeJsxChildren(childrenAsObjects) {
 	return Array.isArray(childrenAsObjects) ? childrenAsObjects.map(sanitizeChild) : sanitizeChild(childrenAsObjects);
 }
 //#endregion
-//#region ../i18n/dist/versionId-B2xfz6jP.mjs
+//#region ../i18n/dist/versionId-BTjLA0FZ.mjs
 /**
 * Throw errors if there are any errors and log warnings if there are any warnings
 * @param {ValidationResult[]} results - The results to print
@@ -4349,9 +4388,9 @@ function getLoadTranslationsType(config) {
 * Requirements:
 * - REMOTE:
 * - GT_REMOTE:
-*   - projectId is required
+*   - projectId is needed
 * - CUSTOM:
-*   - loadTranslations is required
+*   - loadTranslations is needed
 * - DISABLED:
 *   - no requirements
 */
@@ -4363,13 +4402,19 @@ function validateLoadTranslations(params) {
 		case "gt-remote":
 			if (!projectId) results.push({
 				type: "warning",
-				message: "projectId is required when loading translations from a remote store"
+				message: createDiagnosticMessage({
+					whatHappened: "Loading translations from a remote store needs a projectId",
+					fix: "Add projectId to the I18nManager config or disable remote translation loading"
+				})
 			});
 			break;
 		case "custom":
 			if (!loadTranslations) results.push({
 				type: "error",
-				message: "loadTranslations is required when loading translations from a custom loader"
+				message: createDiagnosticMessage({
+					whatHappened: "Custom translation loading needs loadTranslations",
+					fix: "Provide a loadTranslations function or disable custom translation loading"
+				})
 			});
 			break;
 		case "disabled": break;
@@ -4382,8 +4427,9 @@ function validateLoadTranslations(params) {
 * @returns The runtime translation type
 */
 function getTranslationApiType(params) {
-	if ((params.runtimeUrl === void 0 || params.runtimeUrl === "https://runtime2.gtx.dev") && params.projectId && (params.devApiKey || params.apiKey)) return "gt";
-	else if (params.runtimeUrl) return "custom";
+	const usesDefaultRuntimeUrl = params.runtimeUrl === void 0 || params.runtimeUrl === "https://runtime2.gtx.dev";
+	if (usesDefaultRuntimeUrl && params.projectId && (params.devApiKey || params.apiKey)) return "gt";
+	else if (params.runtimeUrl && !usesDefaultRuntimeUrl) return "custom";
 	else return "disabled";
 }
 /**
@@ -4399,8 +4445,8 @@ function getTranslationApiType(params) {
 * Requirements:
 * - CUSTOM:
 * - GT:
-*   - projectId is required
-*   - devApiKey or apiKey is required
+*   - projectId is needed
+*   - devApiKey or apiKey is needed
 * - DISABLED:
 *   - no requirements
 *
@@ -4413,11 +4459,17 @@ function validateTranslationApi(params) {
 		case "gt":
 			if (!params.projectId) results.push({
 				type: "warning",
-				message: "projectId is required"
+				message: createDiagnosticMessage({
+					whatHappened: "Runtime translation needs a projectId",
+					fix: "Add projectId to the I18nManager config or disable runtime translation"
+				})
 			});
 			if (!params.devApiKey && !params.apiKey) results.push({
 				type: "warning",
-				message: "devApiKey or apiKey is required"
+				message: createDiagnosticMessage({
+					whatHappened: "Runtime translation needs devApiKey or apiKey",
+					fix: "Add credentials to the I18nManager config or disable runtime translation"
+				})
 			});
 			break;
 		case "disabled": break;
@@ -4446,7 +4498,10 @@ function validateLocales(params) {
 	new Set([...defaultLocale ? [defaultLocale] : [], ...locales || []]).forEach((locale) => {
 		if (!isValidLocale(locale, customMapping)) results.push({
 			type: "error",
-			message: `Invalid locale: ${locale}`
+			message: createDiagnosticMessage({
+				whatHappened: `Locale "${locale}" is not valid`,
+				fix: "Use a valid BCP 47 locale code or add a custom mapping"
+			})
 		});
 	});
 	return results;
@@ -4461,7 +4516,10 @@ function validateDictionary(params) {
 	const results = [];
 	if (params.loadDictionary && !params.dictionary) results.push({
 		type: "error",
-		message: "dictionary is required when loadDictionary is provided"
+		message: createDiagnosticMessage({
+			whatHappened: "loadDictionary needs a source dictionary",
+			fix: "Provide dictionary so the default locale has source content"
+		})
 	});
 	return results;
 }
@@ -4550,83 +4608,269 @@ function routeCreateTranslationLoader({ type, remoteTranslationLoaderParams, loa
 		case "disabled": return createFallbackTranslationLoader();
 	}
 }
-function isPlainObject(value) {
-	if (value == null || typeof value !== "object") return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
+function getDictionaryPath(id) {
+	const path = id ? id.split(".") : [];
+	for (const segment of path) assertSafeDictionaryPathSegment(segment, id);
+	return path;
+}
+function assertSafeDictionaryPathSegment(segment, path) {
+	if (segment === "__proto__" || segment === "constructor" || segment === "prototype") throw new Error(`Dictionary path "${path}" contains an unsafe segment`);
 }
-function copyCacheValue(value) {
-	if (Array.isArray(value)) return [...value];
-	if (isPlainObject(value)) return { ...value };
-	return value;
+function isDictionaryObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function cloneDictionaryValue(value) {
+	if (value === void 0 || typeof value === "string") return value;
+	return structuredClone(value);
+}
+function getDictionaryValueAtPath(dictionary, path) {
+	let current = dictionary;
+	for (const segment of getDictionaryPath(path)) {
+		if (!isDictionaryObject(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function setDictionaryValueAtPath(dictionary, path, value) {
+	const segments = getDictionaryPath(path);
+	if (isDictionaryObject(value)) assertSafeDictionaryObject(value, path);
+	if (segments.length === 0) {
+		if (isDictionaryObject(value)) replaceDictionary(dictionary, value);
+		return;
+	}
+	let current = dictionary;
+	for (const segment of segments.slice(0, -1)) {
+		const next = current[segment];
+		if (!isDictionaryObject(next)) current[segment] = {};
+		current = current[segment];
+	}
+	const leafSegment = segments[segments.length - 1];
+	current[leafSegment] = value;
+}
+function getDictionaryEntry(value) {
+	if (!isDictionaryLeafNode(value)) return;
+	return {
+		entry: Array.isArray(value) ? value[0] : value,
+		options: Array.isArray(value) ? value[1] ?? {} : {}
+	};
+}
+function getDictionaryValue(value) {
+	if (Object.keys(value.options).length === 0) return value.entry;
+	return [value.entry, value.options];
+}
+function resolveDictionaryLookupOptions(options) {
+	const { $format, context, ...rest } = options;
+	return {
+		...rest,
+		$format: isStringFormat($format) ? $format : "ICU",
+		...rest.$context === void 0 && typeof context === "string" && { $context: context }
+	};
+}
+function isDictionaryLeafNode(value) {
+	if (typeof value === "string") return true;
+	if (!Array.isArray(value) || typeof value[0] !== "string") return false;
+	if (value.length === 1) return true;
+	return value.length === 2 && isDictionaryOptions(value[1]);
+}
+function isDictionaryOptions(value) {
+	if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
+	const options = value;
+	return (options.$context === void 0 || typeof options.$context === "string") && (options.$format === void 0 || isStringFormat(options.$format)) && (options.$maxChars === void 0 || typeof options.$maxChars === "number") && (options.context === void 0 || typeof options.context === "string");
+}
+function isStringFormat(value) {
+	return value === "ICU" || value === "I18NEXT" || value === "STRING";
+}
+function replaceDictionary(target, source) {
+	for (const key of Object.keys(target)) delete target[key];
+	for (const key of Object.keys(source)) target[key] = source[key];
 }
+function assertSafeDictionaryObject(dictionary, parentPath = "") {
+	for (const [key, value] of Object.entries(dictionary)) {
+		const path = parentPath ? `${parentPath}.${key}` : key;
+		assertSafeDictionaryPathSegment(key, path);
+		if (isDictionaryObject(value)) assertSafeDictionaryObject(value, path);
+	}
+}
+var DictionarySourceNotFoundError = class extends Error {
+	constructor(id) {
+		super(`I18nManager: source dictionary entry ${id} is not defined`);
+		this.name = "DictionarySourceNotFoundError";
+	}
+};
 /**
-* Cache class
-* This is designed in such a way that it is the responsibility of the client
-* to invoke the cache miss method when a cache miss occurs.
-*
-* TODO: maybe add "OutputValue" as a reflection of "InputKey"
+* Builds the dictionary value for a requested path by combining existing target
+* translations with runtime translations of any source leaves that are missing.
 */
-var Cache = class {
-	/**
-	* Constructor
-	* @param {Object} params - The parameters for the cache
-	* @param {Record<CacheKey, CacheValue>} params.init - The initial cache
-	* @param {CacheLifecycle} [lifecycle] - Optional lifecycle callbacks
-	*/
-	constructor(init, lifecycle) {
-		this.cache = {};
-		this.fallbackPromises = {};
+async function materializeDictionaryValue({ key, sourceValue, targetValue, translateEntry }) {
+	if (getDictionaryEntry(targetValue) !== void 0) return cloneDictionaryValue(targetValue);
+	if (isDictionaryObject(targetValue) && !isDictionaryObject(sourceValue)) return cloneDictionaryValue(targetValue);
+	const sourceEntry = getDictionaryEntry(sourceValue);
+	if (sourceEntry !== void 0) return await translateEntry(key, sourceEntry);
+	if (!isDictionaryObject(sourceValue)) throw new DictionarySourceNotFoundError(key);
+	const targetDictionary = isDictionaryObject(targetValue) ? targetValue : {};
+	const keys = new Set([...Object.keys(sourceValue), ...Object.keys(targetDictionary)]);
+	const entries = await Promise.all(Array.from(keys).map(async (childKey) => {
+		const childPath = key ? `${key}.${childKey}` : childKey;
+		assertSafeDictionaryPathSegment(childKey, childPath);
+		const childSource = sourceValue[childKey];
+		if (childSource === void 0) return [childKey, cloneDictionaryValue(targetDictionary[childKey])];
+		return [childKey, await materializeDictionaryValue({
+			key: childPath,
+			sourceValue: childSource,
+			targetValue: targetDictionary[childKey],
+			translateEntry
+		})];
+	}));
+	return Object.fromEntries(entries);
+}
+function cloneDictionaryEntry(entry) {
+	return {
+		entry: entry.entry,
+		options: structuredClone(entry.options)
+	};
+}
+var DictionaryCache = class {
+	constructor({ init, lifecycle = {}, runtimeTranslate }) {
+		this.pendingTranslations = /* @__PURE__ */ new Map();
+		this.pendingMaterializations = /* @__PURE__ */ new Map();
 		this.cache = structuredClone(init);
-		this.onHit = lifecycle?.onHit;
-		this.onMiss = lifecycle?.onMiss;
+		this.runtimeTranslate = runtimeTranslate;
+		this.lifecycle = lifecycle;
 	}
-	/**
-	* Set the value for a key
-	*/
-	setCache(cacheKey, value) {
-		this.cache[cacheKey] = value;
+	getEntry(key) {
+		const value = getDictionaryValueAtPath(this.cache, key);
+		const entry = getDictionaryEntry(value);
+		if (entry === void 0) return;
+		const outputEntry = cloneDictionaryEntry(entry);
+		this.lifecycle.onHit?.({
+			inputKey: key,
+			cacheKey: key,
+			cacheValue: value,
+			outputValue: outputEntry
+		});
+		return outputEntry;
 	}
-	/**
-	* Look up the key
-	*/
-	getCache(key) {
-		const cacheKey = this.genKey(key);
-		return this.cache[cacheKey];
+	getValue(key) {
+		const value = getDictionaryValueAtPath(this.cache, key);
+		if (value === void 0) return;
+		const outputValue = cloneDictionaryValue(value);
+		this.lifecycle.onDictionaryObjectCacheHit?.({
+			inputKey: key,
+			cacheKey: key,
+			cacheValue: value,
+			outputValue
+		});
+		return outputValue;
+	}
+	setValue(key, value) {
+		setDictionaryValueAtPath(this.cache, key, cloneDictionaryValue(value));
 	}
-	/**
-	* Get the internal cache
-	* @returns The internal cache
-	*
-	* @internal - used by gt-tanstack-start
-	*/
 	getInternalCache() {
-		return Object.fromEntries(Object.entries(this.cache).map(([key, value]) => [key, copyCacheValue(value)]));
+		return cloneDictionaryValue(this.cache);
+	}
+	async materializeValue(key, sourceValue, targetValue = getDictionaryValueAtPath(this.cache, key)) {
+		let materializationPromise = this.pendingMaterializations.get(key);
+		if (!materializationPromise) {
+			materializationPromise = materializeDictionaryValue({
+				key,
+				sourceValue,
+				targetValue,
+				translateEntry: async (entryKey, sourceEntry) => getDictionaryValue(await this.materializeEntry(entryKey, sourceEntry))
+			}).then((value) => {
+				this.setValue(key, value);
+				return value;
+			});
+			this.pendingMaterializations.set(key, materializationPromise);
+		}
+		try {
+			return await materializationPromise;
+		} finally {
+			this.pendingMaterializations.delete(key);
+		}
 	}
-	/**
-	* Get the mutable cache for subclasses that need custom read/write behavior.
-	*/
-	getMutableCache() {
-		return this.cache;
+	async materializeEntry(key, sourceEntry) {
+		let translationPromise = this.pendingTranslations.get(key);
+		if (!translationPromise) {
+			translationPromise = this.runtimeTranslate(key, sourceEntry).then((value) => {
+				setDictionaryValueAtPath(this.cache, key, value);
+				const entry = getDictionaryEntry(value);
+				if (entry === void 0) throw new Error("DictionaryCache materializeEntry did not return a DictionaryEntry");
+				this.lifecycle.onMiss?.({
+					inputKey: key,
+					cacheKey: key,
+					cacheValue: value,
+					outputValue: cloneDictionaryEntry(entry)
+				});
+				return cloneDictionaryEntry(entry);
+			});
+			this.pendingTranslations.set(key, translationPromise);
+		}
+		try {
+			return cloneDictionaryEntry(await translationPromise);
+		} finally {
+			this.pendingTranslations.delete(key);
+		}
 	}
-	/**
-	* Fallback to the value from the fallback function on a cache miss
-	* @important assumes that the fallback error handling done upstream
-	*/
-	async missCache(...args) {
-		const key = args[0];
-		const cacheKey = this.genKey(key);
-		if (this.fallbackPromises[cacheKey] !== void 0) return await this.fallbackPromises[cacheKey];
-		const fallbackPromise = this.fallback(...args);
-		this.fallbackPromises[cacheKey] = fallbackPromise;
+};
+var ResourceCache = class {
+	constructor({ load, lifecycle = {}, ttl }) {
+		this.cache = /* @__PURE__ */ new Map();
+		this.pendingLoads = /* @__PURE__ */ new Map();
+		this.loadResource = load;
+		this.lifecycle = lifecycle;
+		this.ttl = ttl === null ? -1 : ttl ?? 6e4;
+	}
+	get(key) {
+		const entry = this.cache.get(key);
+		if (!entry || this.isExpired(entry)) return;
+		this.lifecycle.onHit?.({
+			inputKey: key,
+			cacheKey: key,
+			cacheValue: entry,
+			outputValue: entry.value
+		});
+		return entry.value;
+	}
+	set(key, value, { expiresAt = this.getExpiresAt() } = {}) {
+		this.cache.set(key, {
+			expiresAt,
+			value
+		});
+	}
+	async getOrLoad(key) {
+		return this.get(key) ?? await this.load(key);
+	}
+	async load(key) {
+		let loadPromise = this.pendingLoads.get(key);
+		if (!loadPromise) {
+			loadPromise = this.loadResource(key).then((value) => {
+				const entry = {
+					expiresAt: this.getExpiresAt(),
+					value
+				};
+				this.cache.set(key, entry);
+				this.lifecycle.onMiss?.({
+					inputKey: key,
+					cacheKey: key,
+					cacheValue: entry,
+					outputValue: entry.value
+				});
+				return entry;
+			});
+			this.pendingLoads.set(key, loadPromise);
+		}
 		try {
-			const value = await fallbackPromise;
-			this.setCache(cacheKey, value);
-			return value;
+			return (await loadPromise).value;
 		} finally {
-			delete this.fallbackPromises[cacheKey];
+			this.pendingLoads.delete(key);
 		}
 	}
+	getExpiresAt() {
+		return this.ttl < 0 ? this.ttl : Date.now() + this.ttl;
+	}
+	isExpired(entry) {
+		return entry.expiresAt > 0 && entry.expiresAt < Date.now();
+	}
 };
 /**
 * Hash a message string
@@ -4671,20 +4915,22 @@ function normalizeBatchConfig(batchConfig) {
 *   Locale logic is handled at the LocalesCache level. Use a callback function that has the
 *   locale parameter embedded if you wish to use the locale code.
 */
-var TranslationsCache = class extends Cache {
+var TranslationsCache = class {
 	/**
 	* Constructor
 	* @param {Object} params - The parameters for the cache
 	* @param {Record<Hash, TranslationValue>} params.init - The initial cache
 	* @param {Function} params.fallback - Get the fallback value for a cache miss
 	*/
-	constructor({ init, translateMany, lifecycle, batchConfig }) {
-		super(init, lifecycle);
-		this._queue = [];
-		this._batchTimer = null;
-		this._activeRequests = 0;
-		this._translateMany = translateMany;
-		this._batchConfig = normalizeBatchConfig(batchConfig);
+	constructor({ init, translateMany, lifecycle = {}, batchConfig }) {
+		this.pendingTranslations = /* @__PURE__ */ new Map();
+		this.queue = [];
+		this.batchTimer = null;
+		this.activeRequests = 0;
+		this.cache = structuredClone(init);
+		this.translateMany = translateMany;
+		this.batchConfig = normalizeBatchConfig(batchConfig);
+		this.lifecycle = lifecycle;
 	}
 	/**
 	* Get the translation value for a given key
@@ -4692,10 +4938,11 @@ var TranslationsCache = class extends Cache {
 	* @returns The translation value
 	*/
 	get(key) {
-		const value = this.getCache(key);
-		if (value != null && this.onHit) this.onHit({
+		const cacheKey = this.getCacheKey(key);
+		const value = this.cache[cacheKey];
+		if (value != null) this.lifecycle.onHit?.({
 			inputKey: key,
-			cacheKey: this.genKey(key),
+			cacheKey,
 			cacheValue: value,
 			outputValue: value
 		});
@@ -4707,75 +4954,64 @@ var TranslationsCache = class extends Cache {
 	* @returns The translation value
 	*/
 	async miss(key) {
-		const value = await this.missCache(key);
-		if (value != null && this.onMiss) this.onMiss({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue: value,
-			outputValue: value
-		});
-		return value;
+		const cacheKey = this.getCacheKey(key);
+		let translationPromise = this.pendingTranslations.get(cacheKey);
+		if (!translationPromise) {
+			translationPromise = this.translate(key);
+			this.pendingTranslations.set(cacheKey, translationPromise);
+		}
+		try {
+			const value = await translationPromise;
+			if (value != null) this.lifecycle.onMiss?.({
+				inputKey: key,
+				cacheKey,
+				cacheValue: value,
+				outputValue: value
+			});
+			return value;
+		} finally {
+			this.pendingTranslations.delete(cacheKey);
+		}
 	}
-	/**
-	* Generate a key for the cache
-	* @param key - The translation key
-	* @returns The key
-	*/
-	genKey(key) {
+	getInternalCache() {
+		return structuredClone(this.cache);
+	}
+	getCacheKey(key) {
 		return hashMessage(key.message, key.options);
 	}
-	/**
-	* Get the fallback value for a cache miss
-	* @param key - The translation key
-	* @returns The fallback value
-	*/
-	fallback(key) {
-		const translationPromise = this._enqueueTranslation(key);
-		if (this._queue.length >= this._batchConfig.maxBatchSize) this._flushNow();
-		else this._scheduleBatch();
+	translate(key) {
+		const translationPromise = this.enqueueTranslation(key);
+		if (this.queue.length >= this.batchConfig.maxBatchSize) this.flushNow();
+		else this.scheduleBatch();
 		return translationPromise;
 	}
-	/**
-	* Flush the queue now
-	*/
-	_flushNow() {
-		if (this._batchTimer) {
-			clearTimeout(this._batchTimer);
-			this._batchTimer = null;
+	flushNow() {
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = null;
 		}
-		this._drainQueue();
-	}
-	/**
-	* Schedule a batch of translations
-	*/
-	_scheduleBatch() {
-		if (this._batchTimer) return;
-		this._batchTimer = setTimeout(() => {
-			this._batchTimer = null;
-			this._drainQueue();
-		}, this._batchConfig.batchInterval);
-	}
-	/**
-	* Drain the queue
-	*/
-	_drainQueue() {
-		while (this._queue.length > 0 && this._activeRequests < this._batchConfig.maxConcurrentRequests) {
-			const batch = this._queue.splice(0, this._batchConfig.maxBatchSize);
-			this._sendBatchRequest(batch);
+		this.drainQueue();
+	}
+	scheduleBatch() {
+		if (this.batchTimer) return;
+		this.batchTimer = setTimeout(() => {
+			this.batchTimer = null;
+			this.drainQueue();
+		}, this.batchConfig.batchInterval);
+	}
+	drainQueue() {
+		while (this.queue.length > 0 && this.activeRequests < this.batchConfig.maxConcurrentRequests) {
+			const batch = this.queue.splice(0, this.batchConfig.maxBatchSize);
+			this.sendBatchRequest(batch);
 		}
-		if (this._queue.length > 0) this._scheduleBatch();
+		if (this.queue.length > 0) this.scheduleBatch();
 	}
-	/**
-	* Enqueue translation request and return a promise that resolves when the translation is ready
-	* @param {TranslationKey<TranslationValue>} key - The translation key
-	* @returns {Promise<TranslationValue>} The translation promise
-	*/
-	_enqueueTranslation(key) {
-		const hash = this.genKey(key);
+	enqueueTranslation(key) {
+		const hash = this.getCacheKey(key);
 		const options = key.options;
 		const metadataOptions = options;
 		return new Promise((resolve, reject) => {
-			this._queue.push({
+			this.queue.push({
 				key: hash,
 				source: key.message,
 				metadata: {
@@ -4790,38 +5026,28 @@ var TranslationsCache = class extends Cache {
 			});
 		});
 	}
-	/**
-	* Send a batch request for translations
-	* @param {QueueEntry<TranslationValue>[]} batch - The batch of requests to send
-	*/
-	async _sendBatchRequest(batch) {
-		this._activeRequests++;
+	async sendBatchRequest(batch) {
+		this.activeRequests++;
 		const requests = convertBatchToTranslateManyParams(batch);
-		const response = await this._sendBatchRequestWithErrorHandling(batch, requests);
-		if (response) this._handleTranslationResponse(batch, response);
-		this._activeRequests--;
+		const response = await this.sendBatchRequestWithErrorHandling(batch, requests);
+		if (response) this.handleTranslationResponse(batch, response);
+		this.activeRequests--;
 	}
-	/**
-	* Send a translation request with error handling
-	*/
-	async _sendBatchRequestWithErrorHandling(batch, requests) {
+	async sendBatchRequestWithErrorHandling(batch, requests) {
 		try {
-			return await this._translateMany(requests);
+			return await this.translateMany(requests);
 		} catch (error) {
 			for (const entry of batch) entry.reject(error);
 			return;
 		}
 	}
-	/**
-	* Handle a translation response
-	*/
-	_handleTranslationResponse(batch, response) {
+	handleTranslationResponse(batch, response) {
 		for (const entry of batch) {
 			const { key } = entry;
 			const result = response[key];
 			if (result && result.success) {
 				const translation = result.translation;
-				this.setCache(key, translation);
+				this.cache[key] = translation;
 				entry.resolve(translation);
 			} else entry.reject(result?.error);
 		}
@@ -4839,415 +5065,87 @@ function convertBatchToTranslateManyParams(batch) {
 		return acc;
 	}, {});
 }
-/**
-* Default cache expiry time in milliseconds
-*/
-const DEFAULT_CACHE_EXPIRY_TIME = 6e4;
-/**
-* Cache for looking up translations by locale
-*/
-var LocalesCache = class extends Cache {
-	/**
-	* Constructor
-	* @param {Object} params - The parameters for the cache
-	* @param {Record<string, CacheEntry<TranslationValue>>} params.init - The initial cache
-	* @param {number | null} params.ttl - The time to live for cache entries
-	* @param {SafeTranslationsLoader<TranslationValue>} params.loadTranslations - The translation loader function
-	* @param {CreateTranslateMany} params.createTranslateMany - Factory function for creating a translate many function
-	*/
-	constructor({ init = {}, ttl, batchConfig, loadTranslations, createTranslateMany, lifecycle: { onLocalesCacheHit: onHit, onLocalesCacheMiss: onMiss, onTranslationsCacheHit, onTranslationsCacheMiss } }) {
-		super(init, {
-			onHit,
-			onMiss
+var LocalesCache = class {
+	constructor({ ttl, batchConfig, defaultLocale, dictionary = {}, loadTranslations, loadDictionary, createTranslateMany, translateDictionaryEntry, lifecycle }) {
+		this.translations = new ResourceCache({
+			ttl,
+			load: async (locale) => new TranslationsCache({
+				init: await loadTranslations(locale),
+				lifecycle: createTranslationsCacheLifecycle(locale, lifecycle),
+				translateMany: createTranslateMany(locale),
+				batchConfig
+			}),
+			lifecycle: {
+				onHit: lifecycle.onLocalesCacheHit,
+				onMiss: lifecycle.onLocalesCacheMiss
+			}
 		});
-		this.ttl = DEFAULT_CACHE_EXPIRY_TIME;
-		this.ttl = ttl === null ? -1 : ttl ?? 6e4;
-		this._translationLoader = loadTranslations;
-		this._createTranslateMany = createTranslateMany;
-		this._batchConfig = batchConfig;
-		this._onTranslationsCacheHit = onTranslationsCacheHit;
-		this._onTranslationsCacheMiss = onTranslationsCacheMiss;
-	}
-	/**
-	* Get the translations for a given locale
-	* @param key - The locale
-	* @returns The translations
-	*/
-	get(key) {
-		const entry = this.getCache(key);
-		if (!entry || entry.expiresAt > 0 && entry.expiresAt < Date.now()) return;
-		const value = entry.translationsCache;
-		if (value != null && this.onHit) this.onHit({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue: entry,
-			outputValue: value
+		this.dictionaries = new ResourceCache({
+			ttl,
+			load: async (locale) => createDictionaryCache({
+				locale,
+				dictionary: await loadDictionary(locale),
+				translate: translateDictionaryEntry,
+				lifecycle
+			}),
+			lifecycle: {
+				onHit: lifecycle.onLocalesDictionaryCacheHit,
+				onMiss: lifecycle.onLocalesDictionaryCacheMiss
+			}
 		});
-		return value;
+		this.dictionaries.set(defaultLocale, createDictionaryCache({
+			locale: defaultLocale,
+			dictionary,
+			translate: translateDictionaryEntry,
+			lifecycle
+		}), { expiresAt: -1 });
 	}
-	/**
-	* Miss the cache
-	* @param key - The locale
-	* @returns The translations cache
-	*/
-	async miss(key) {
-		const cacheValue = await this.missCache(key);
-		const value = cacheValue.translationsCache;
-		if (value != null && this.onMiss) this.onMiss({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue,
-			outputValue: value
-		});
-		return value;
+	getTranslations(locale) {
+		return this.translations.get(locale);
 	}
-	/**
-	* Generate the cache key for a given locale
-	* @param key - The locale
-	* @returns The cache key
-	*
-	* This is just an identity function, no transformation needed
-	*/
-	genKey(key) {
-		return key;
+	getOrLoadTranslations(locale) {
+		return this.translations.getOrLoad(locale);
 	}
-	/**
-	* Fallback for a cache miss
-	* @param locale - The locale
-	* @returns The cache entry
-	*/
-	async fallback(locale) {
-		return {
-			translationsCache: new TranslationsCache({
-				init: await this._translationLoader(locale),
-				lifecycle: this._createTranslationsCacheLifecycle(locale),
-				translateMany: this._createTranslateMany(locale),
-				batchConfig: this._batchConfig
-			}),
-			expiresAt: this.ttl < 0 ? this.ttl : Date.now() + this.ttl
-		};
+	getDictionary(locale) {
+		return this.dictionaries.get(locale);
 	}
-	/**
-	* Create the translations cache lifecycle
-	* @param locale - The locale
-	* @returns The translations cache lifecycle
-	*/
-	_createTranslationsCacheLifecycle(locale) {
-		return {
-			onHit: this._onTranslationsCacheHit ? (params) => this._onTranslationsCacheHit({
-				locale,
-				...params
-			}) : void 0,
-			onMiss: this._onTranslationsCacheMiss ? (params) => this._onTranslationsCacheMiss({
-				locale,
-				...params
-			}) : void 0
-		};
+	getOrLoadDictionary(locale) {
+		return this.dictionaries.getOrLoad(locale);
 	}
 };
-function getDictionaryPath(id) {
-	if (!id) return [];
-	return id.split(".");
-}
-function isDictionaryValue(value) {
-	return typeof value === "object" && value != null && !Array.isArray(value);
-}
-function getDictionaryEntry(value) {
-	if (!isDictionaryLeafNode(value)) return;
-	return {
-		entry: Array.isArray(value) ? value[0] : value,
-		options: Array.isArray(value) ? value[1] ?? {} : {}
-	};
-}
-function getDictionaryValue(value) {
-	if (Object.keys(value.options).length === 0) return value.entry;
-	return [value.entry, value.options];
-}
-function resolveDictionaryLookupOptions(options) {
-	const { $format, ...rest } = options;
+function createTranslationsCacheLifecycle(locale, lifecycle) {
 	return {
-		...rest,
-		$format: isStringFormat($format) ? $format : "ICU",
-		...rest.$context === void 0 && typeof rest.context === "string" && { $context: rest.context }
+		onHit: withLocale(locale, lifecycle.onTranslationsCacheHit),
+		onMiss: withLocale(locale, lifecycle.onTranslationsCacheMiss)
 	};
 }
-function isDictionaryLeafNode(value) {
-	if (typeof value === "string") return true;
-	if (!Array.isArray(value) || typeof value[0] !== "string") return false;
-	if (value.length === 1) return true;
-	return value.length === 2 && isDictionaryOptions(value[1]);
-}
-function isDictionaryOptions(value) {
-	if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
-	const options = value;
-	return (options.$context === void 0 || typeof options.$context === "string") && (options.$format === void 0 || isStringFormat(options.$format)) && (options.$maxChars === void 0 || typeof options.$maxChars === "number") && (options.context === void 0 || typeof options.context === "string");
-}
-function isStringFormat(value) {
-	return value === "ICU" || value === "I18NEXT" || value === "STRING";
+function createDictionaryCache({ locale, dictionary, translate, lifecycle }) {
+	const { onDictionaryCacheHit, onDictionaryCacheMiss, onDictionaryObjectCacheHit } = lifecycle;
+	return new DictionaryCache({
+		init: dictionary,
+		runtimeTranslate: (key, sourceEntry) => translate(locale, key, sourceEntry),
+		lifecycle: {
+			onHit: withLocale(locale, onDictionaryCacheHit),
+			onMiss: withLocale(locale, onDictionaryCacheMiss),
+			onDictionaryObjectCacheHit: withLocale(locale, onDictionaryObjectCacheHit)
+		}
+	});
 }
-function replaceDictionary(target, source) {
-	for (const key of Object.keys(target)) delete target[key];
-	Object.assign(target, source);
+function withLocale(locale, callback) {
+	return callback ? (params) => callback({
+		locale,
+		...params
+	}) : void 0;
 }
-var DictionarySourceNotFoundError = class extends Error {
-	constructor(id) {
-		super(`I18nManager: source dictionary entry ${id} is not defined`);
-		this.name = "DictionarySourceNotFoundError";
-	}
-};
-/**
-* A cache for a single locale's dictionary
-*
-* Principles:
-* - This class is language agnostic, and should never store the locale code as a parameter.
-*   Locale logic is handled at the LocalesDictionaryCache level. Use a callback function
-*   that has the locale parameter embedded if you wish to use the locale code.
-*/
-var DictionaryCache = class extends Cache {
-	/**
-	* Constructor
-	* @param {Object} params - The parameters for the cache
-	* @param {Dictionary} params.init - The initial cache
-	*/
-	constructor({ init, lifecycle, runtimeTranslate }) {
-		super(init, lifecycle);
-		this._runtimeTranslate = runtimeTranslate;
-		this.onHitObj = lifecycle?.onHitObj;
-		this.onMissObj = lifecycle?.onMissObj;
-	}
-	/**
-	* Get the dictionary value for a given key
-	* @param key - The dictionary key
-	* @returns The dictionary value
-	*/
-	get(key) {
-		const value = this.getCache(key);
-		const entry = getDictionaryEntry(value);
-		if (entry === void 0) return;
-		if (this.onHit) this.onHit({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue: value,
-			outputValue: entry
-		});
-		return entry;
-	}
-	set(key, value) {
-		const dictionaryValue = getDictionaryValue(value);
-		this.setCache(this.genKey(key), dictionaryValue);
-	}
-	getObj(key) {
-		const value = this.getCache(key);
-		if (value === void 0) return;
-		const outputValue = structuredClone(value);
-		if (this.onHitObj) this.onHitObj({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue: value,
-			outputValue
-		});
-		return outputValue;
-	}
-	setObj(key, value) {
-		this.setCache(this.genKey(key), structuredClone(value));
-	}
-	async missObj(key, sourceObject) {
-		const sourceEntry = getDictionaryEntry(sourceObject);
-		if (sourceEntry !== void 0) return getDictionaryValue(await this.miss(key, sourceEntry));
-		if (!isDictionaryValue(sourceObject)) throw new DictionarySourceNotFoundError(key);
-		const translatedEntries = await Promise.all(Object.entries(sourceObject).map(async ([childKey, childSource]) => {
-			const childPath = key ? `${key}.${childKey}` : childKey;
-			return [childKey, await this.missObj(childPath, childSource)];
-		}));
-		const translatedObject = Object.fromEntries(translatedEntries);
-		this.setObj(key, translatedObject);
-		return translatedObject;
-	}
-	/**
-	* Miss the cache
-	* @param key - The dictionary key
-	* @returns The dictionary value
-	*/
-	async miss(key, sourceEntry) {
-		const value = await this.missCache(key, sourceEntry);
-		const entry = getDictionaryEntry(value);
-		if (entry === void 0) throw new Error("DictionaryCache missCache did not return a DictionaryEntry");
-		if (this.onMiss) this.onMiss({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue: value,
-			outputValue: entry
-		});
-		return entry;
-	}
-	/**
-	* Set the value for a key
-	*/
-	setCache(cacheKey, value) {
-		const cache = this.getMutableCache();
-		const dictionaryPath = getDictionaryPath(cacheKey);
-		if (dictionaryPath.length === 0) {
-			if (isDictionaryValue(value)) replaceDictionary(cache, value);
-			return;
-		}
-		let current = cache;
-		for (const key of dictionaryPath.slice(0, -1)) {
-			const next = current[key];
-			if (!isDictionaryValue(next)) current[key] = {};
-			current = current[key];
-		}
-		current[dictionaryPath[dictionaryPath.length - 1]] = value;
-	}
-	/**
-	* Look up the key
-	*/
-	getCache(key) {
-		const dictionaryPath = getDictionaryPath(this.genKey(key));
-		let current = this.getMutableCache();
-		if (dictionaryPath.length === 0) return current;
-		for (const pathSegment of dictionaryPath) {
-			if (!isDictionaryValue(current)) return;
-			current = current[pathSegment];
-		}
-		return current;
-	}
-	/**
-	* Generate a key for the cache
-	* @param key - The dictionary key
-	* @returns The key
-	*/
-	genKey(key) {
-		return key;
-	}
-	/**
-	* Get the fallback value for a cache miss
-	* @param key - The dictionary key
-	* @returns The fallback value
-	*
-	* @throws {Error} - If the fallback is not implemented
-	*/
-	fallback(key, sourceEntry) {
-		return this._runtimeTranslate(key, sourceEntry);
-	}
-};
-/**
-* Cache for looking up dictionaries by locale
-*/
-var LocalesDictionaryCache = class extends Cache {
-	/**
-	* Constructor
-	* @param {Object} params - The parameters for the cache
-	* @param {number | null} params.ttl - The time to live for cache entries
-	* @param {DictionaryLoader} params.loadDictionary - The dictionary loader function
-	*/
-	constructor({ ttl, defaultLocale, dictionary = {}, loadDictionary, runtimeTranslate, lifecycle: { onLocalesDictionaryCacheHit: onHit, onLocalesDictionaryCacheMiss: onMiss, onDictionaryCacheHit, onDictionaryCacheMiss, onDictionaryObjectCacheHit } }) {
-		super({}, {
-			onHit,
-			onMiss
-		});
-		this.ttl = DEFAULT_CACHE_EXPIRY_TIME;
-		this.ttl = ttl === null ? -1 : ttl ?? 6e4;
-		this._dictionaryLoader = loadDictionary;
-		this._runtimeTranslate = runtimeTranslate;
-		this._onDictionaryCacheHit = onDictionaryCacheHit;
-		this._onDictionaryCacheMiss = onDictionaryCacheMiss;
-		this._onDictionaryObjectCacheHit = onDictionaryObjectCacheHit;
-		this.setCache(defaultLocale, {
-			dictionaryCache: new DictionaryCache({
-				init: dictionary,
-				runtimeTranslate: this._createDictionaryRuntimeTranslate(defaultLocale),
-				lifecycle: this._createDictionaryCacheLifecycle(defaultLocale)
-			}),
-			expiresAt: -1
-		});
-	}
-	/**
-	* Get the dictionary for a given locale
-	* @param key - The locale
-	* @returns The dictionary
-	*/
-	get(key) {
-		const entry = this.getCache(key);
-		if (!entry || entry.expiresAt > 0 && entry.expiresAt < Date.now()) return;
-		const value = entry.dictionaryCache;
-		if (value != null && this.onHit) this.onHit({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue: entry,
-			outputValue: value
-		});
-		return value;
-	}
-	/**
-	* Miss the cache
-	* @param key - The locale
-	* @returns The dictionary cache
-	*/
-	async miss(key) {
-		const cacheValue = await this.missCache(key);
-		const value = cacheValue.dictionaryCache;
-		if (value != null && this.onMiss) this.onMiss({
-			inputKey: key,
-			cacheKey: this.genKey(key),
-			cacheValue,
-			outputValue: value
-		});
-		return value;
-	}
-	/**
-	* Generate the cache key for a given locale
-	* @param key - The locale
-	* @returns The cache key
-	*
-	* This is just an identity function, no transformation needed
-	*/
-	genKey(key) {
-		return key;
-	}
-	/**
-	* Fallback for a cache miss
-	* @param locale - The locale
-	* @returns The cache entry
-	*/
-	async fallback(locale) {
-		return {
-			dictionaryCache: new DictionaryCache({
-				init: await this._dictionaryLoader(locale),
-				runtimeTranslate: this._createDictionaryRuntimeTranslate(locale),
-				lifecycle: this._createDictionaryCacheLifecycle(locale)
-			}),
-			expiresAt: this.ttl < 0 ? this.ttl : Date.now() + this.ttl
-		};
-	}
-	/**
-	* Create the dictionary cache lifecycle
-	* @param locale - The locale
-	* @returns The dictionary cache lifecycle
-	*/
-	_createDictionaryCacheLifecycle(locale) {
-		return {
-			onHit: this._onDictionaryCacheHit ? (params) => this._onDictionaryCacheHit({
-				locale,
-				...params
-			}) : void 0,
-			onMiss: this._onDictionaryCacheMiss ? (params) => this._onDictionaryCacheMiss({
-				locale,
-				...params
-			}) : void 0,
-			onHitObj: this._onDictionaryObjectCacheHit ? (params) => this._onDictionaryObjectCacheHit({
-				locale,
-				...params
-			}) : void 0
-		};
-	}
-	_createDictionaryRuntimeTranslate(locale) {
-		return (key, sourceEntry) => this._runtimeTranslate(locale, key, sourceEntry);
-	}
-};
+const LOCALES_CACHE_HIT_EVENT_NAME = "locales-cache-hit";
 const LOCALES_CACHE_MISS_EVENT_NAME = "locales-cache-miss";
+const TRANSLATIONS_CACHE_HIT_EVENT_NAME = "translations-cache-hit";
 const TRANSLATIONS_CACHE_MISS_EVENT_NAME = "translations-cache-miss";
+const LOCALES_DICTIONARY_CACHE_HIT_EVENT_NAME = "locales-dictionary-cache-hit";
 const LOCALES_DICTIONARY_CACHE_MISS_EVENT_NAME = "locales-dictionary-cache-miss";
+const DICTIONARY_CACHE_HIT_EVENT_NAME = "dictionary-cache-hit";
 const DICTIONARY_CACHE_MISS_EVENT_NAME = "dictionary-cache-miss";
+const DICTIONARY_OBJECT_CACHE_HIT_EVENT_NAME = "dictionary-object-cache-hit";
 /**
 * Maps consumer-facing lifecycle callbacks to internal locales cache lifecycle callbacks.
 * The consumer API exposes simplified params (locale, hash, value) while the internal
@@ -5255,22 +5153,24 @@ const DICTIONARY_CACHE_MISS_EVENT_NAME = "dictionary-cache-miss";
 *
 * @deprecated - move to subscription api instead
 */
-function createLifecycleCallbacks(emit) {
+function createLifecycleCallbacks(emit, hasListeners = () => true) {
 	return {
 		onLocalesCacheHit: (params) => {
-			emit("locales-cache-hit", {
+			if (!hasListeners("locales-cache-hit")) return;
+			emit(LOCALES_CACHE_HIT_EVENT_NAME, {
 				locale: params.inputKey,
 				translations: params.outputValue.getInternalCache()
 			});
 		},
 		onLocalesCacheMiss: (params) => {
+			if (!hasListeners("locales-cache-miss")) return;
 			emit(LOCALES_CACHE_MISS_EVENT_NAME, {
 				locale: params.inputKey,
 				translations: params.outputValue.getInternalCache()
 			});
 		},
 		onTranslationsCacheHit: (params) => {
-			emit("translations-cache-hit", {
+			emit(TRANSLATIONS_CACHE_HIT_EVENT_NAME, {
 				locale: params.locale,
 				hash: params.cacheKey,
 				translation: params.outputValue
@@ -5284,19 +5184,21 @@ function createLifecycleCallbacks(emit) {
 			});
 		},
 		onLocalesDictionaryCacheHit: (params) => {
-			emit("locales-dictionary-cache-hit", {
+			if (!hasListeners("locales-dictionary-cache-hit")) return;
+			emit(LOCALES_DICTIONARY_CACHE_HIT_EVENT_NAME, {
 				locale: params.inputKey,
 				dictionary: params.outputValue.getInternalCache()
 			});
 		},
 		onLocalesDictionaryCacheMiss: (params) => {
+			if (!hasListeners("locales-dictionary-cache-miss")) return;
 			emit(LOCALES_DICTIONARY_CACHE_MISS_EVENT_NAME, {
 				locale: params.inputKey,
 				dictionary: params.outputValue.getInternalCache()
 			});
 		},
 		onDictionaryCacheHit: (params) => {
-			emit("dictionary-cache-hit", {
+			emit(DICTIONARY_CACHE_HIT_EVENT_NAME, {
 				locale: params.locale,
 				id: params.cacheKey,
 				dictionaryEntry: params.outputValue
@@ -5310,7 +5212,7 @@ function createLifecycleCallbacks(emit) {
 			});
 		},
 		onDictionaryObjectCacheHit: (params) => {
-			emit("dictionary-object-cache-hit", {
+			emit(DICTIONARY_OBJECT_CACHE_HIT_EVENT_NAME, {
 				locale: params.locale,
 				id: params.cacheKey,
 				dictionaryValue: params.outputValue
@@ -5345,6 +5247,9 @@ var EventEmitter = class {
 	emit(eventName, event) {
 		this.listeners[eventName]?.forEach((subscriber) => subscriber(event));
 	}
+	hasListeners(eventName) {
+		return (this.listeners[eventName]?.size ?? 0) > 0;
+	}
 };
 /**
 * Subscribes to the lifecycle callbacks and emits the events to the event emitter
@@ -5354,7 +5259,7 @@ var EventEmitter = class {
 * and is only used internally
 */
 function subscribeLifecycleCallbacks({ onLocalesCacheHit, onLocalesCacheMiss, onTranslationsCacheHit, onTranslationsCacheMiss, onLocalesDictionaryCacheHit, onLocalesDictionaryCacheMiss, onDictionaryCacheHit, onDictionaryCacheMiss, onDictionaryObjectCacheHit }, subscribe) {
-	if (onLocalesCacheHit) subscribe("locales-cache-hit", (event) => {
+	if (onLocalesCacheHit) subscribe(LOCALES_CACHE_HIT_EVENT_NAME, (event) => {
 		onLocalesCacheHit({
 			...event,
 			value: event.translations
@@ -5366,7 +5271,7 @@ function subscribeLifecycleCallbacks({ onLocalesCacheHit, onLocalesCacheMiss, on
 			value: event.translations
 		});
 	});
-	if (onTranslationsCacheHit) subscribe("translations-cache-hit", (event) => {
+	if (onTranslationsCacheHit) subscribe(TRANSLATIONS_CACHE_HIT_EVENT_NAME, (event) => {
 		onTranslationsCacheHit({
 			...event,
 			value: event.translation
@@ -5378,19 +5283,19 @@ function subscribeLifecycleCallbacks({ onLocalesCacheHit, onLocalesCacheMiss, on
 			value: event.translation
 		});
 	});
-	if (onLocalesDictionaryCacheHit) subscribe("locales-dictionary-cache-hit", (event) => {
+	if (onLocalesDictionaryCacheHit) subscribe(LOCALES_DICTIONARY_CACHE_HIT_EVENT_NAME, (event) => {
 		onLocalesDictionaryCacheHit(event);
 	});
 	if (onLocalesDictionaryCacheMiss) subscribe(LOCALES_DICTIONARY_CACHE_MISS_EVENT_NAME, (event) => {
 		onLocalesDictionaryCacheMiss(event);
 	});
-	if (onDictionaryCacheHit) subscribe("dictionary-cache-hit", (event) => {
+	if (onDictionaryCacheHit) subscribe(DICTIONARY_CACHE_HIT_EVENT_NAME, (event) => {
 		onDictionaryCacheHit(event);
 	});
 	if (onDictionaryCacheMiss) subscribe(DICTIONARY_CACHE_MISS_EVENT_NAME, (event) => {
 		onDictionaryCacheMiss(event);
 	});
-	if (onDictionaryObjectCacheHit) subscribe("dictionary-object-cache-hit", (event) => {
+	if (onDictionaryObjectCacheHit) subscribe(DICTIONARY_OBJECT_CACHE_HIT_EVENT_NAME, (event) => {
 		onDictionaryObjectCacheHit(event);
 	});
 }
@@ -5421,26 +5326,32 @@ var I18nManager = class extends EventEmitter {
 			locales: this.config.locales,
 			customMapping: this.config.customMapping
 		});
-		const loadTranslations = createTranslationLoader(params);
-		const loadDictionary = createDictionaryLoader(params);
+		const loadTranslations = routeCreateTranslationLoader({
+			loadTranslations: params.loadTranslations,
+			type: getLoadTranslationsType(params),
+			remoteTranslationLoaderParams: {
+				cacheUrl: params.cacheUrl,
+				projectId: params.projectId,
+				_versionId: params._versionId,
+				_branchId: params._branchId,
+				customMapping: params.customMapping
+			}
+		});
+		const loadDictionary = params.loadDictionary ?? (() => Promise.resolve({}));
 		const runtimeTranslationTimeout = this.config.runtimeTranslation?.timeout ?? DEFAULT_TRANSLATION_TIMEOUT;
 		const runtimeTranslationMetadata = this.config.runtimeTranslation?.metadata ?? {};
 		const createTranslateMany = createTranslateManyFactory(this.getGTClassClean(), runtimeTranslationTimeout, runtimeTranslationMetadata);
 		subscribeLifecycleCallbacks(params.lifecycle ?? {}, (...args) => this.subscribe(...args));
-		const lifecycle = createLifecycleCallbacks((...args) => this.emit(...args));
+		const lifecycle = createLifecycleCallbacks((...args) => this.emit(...args), (eventName) => this.hasListeners(eventName));
 		this.localesCache = new LocalesCache({
-			loadTranslations,
-			createTranslateMany,
-			lifecycle,
-			ttl: this.config.cacheExpiryTime,
-			batchConfig: this.config.batchConfig
-		});
-		this.localesDictionaryCache = new LocalesDictionaryCache({
 			defaultLocale: this.config.defaultLocale,
 			dictionary: params.dictionary,
+			loadTranslations,
 			loadDictionary,
-			runtimeTranslate: (locale, id, sourceEntry) => this.dictionaryRuntimeTranslate(locale, id, sourceEntry),
+			createTranslateMany,
+			translateDictionaryEntry: (locale, id, sourceEntry) => this.translateDictionaryEntry(locale, id, sourceEntry),
 			ttl: this.config.cacheExpiryTime,
+			batchConfig: this.config.batchConfig,
 			lifecycle
 		});
 	}
@@ -5512,9 +5423,7 @@ var I18nManager = class extends EventEmitter {
 		try {
 			const translationLocale = this.resolveCacheLocale(locale);
 			if (!translationLocale) return {};
-			let txCache = this.localesCache.get(translationLocale);
-			if (!txCache) txCache = await this.localesCache.miss(translationLocale);
-			return txCache.getInternalCache();
+			return (await this.localesCache.getOrLoadTranslations(translationLocale)).getInternalCache();
 		} catch (error) {
 			this.handleError(error);
 			return {};
@@ -5527,10 +5436,8 @@ var I18nManager = class extends EventEmitter {
 	async loadDictionary(locale) {
 		try {
 			const dictionaryLocale = this.resolveCacheLocale(locale);
-			if (!dictionaryLocale) return this.localesDictionaryCache.get(this.config.defaultLocale)?.getInternalCache() ?? {};
-			let dictionaryCache = this.localesDictionaryCache.get(dictionaryLocale);
-			if (!dictionaryCache) dictionaryCache = await this.localesDictionaryCache.miss(dictionaryLocale);
-			return dictionaryCache.getInternalCache();
+			if (!dictionaryLocale) return this.getDefaultDictionaryCache()?.getInternalCache() ?? {};
+			return (await this.localesCache.getOrLoadDictionary(dictionaryLocale)).getInternalCache();
 		} catch (error) {
 			this.handleError(error);
 			return {};
@@ -5541,8 +5448,8 @@ var I18nManager = class extends EventEmitter {
 	*/
 	lookupDictionary(locale, id) {
 		try {
-			const dictionaryLocale = this.resolveCacheLocale(locale) ?? this.config.defaultLocale;
-			return this.localesDictionaryCache.get(dictionaryLocale)?.get(id);
+			const dictionaryLocale = this.resolveDictionaryCacheLocale(locale);
+			return this.localesCache.getDictionary(dictionaryLocale)?.getEntry(id);
 		} catch (error) {
 			this.handleError(error);
 			return;
@@ -5553,8 +5460,8 @@ var I18nManager = class extends EventEmitter {
 	*/
 	lookupDictionaryObj(locale, id) {
 		try {
-			const dictionaryLocale = this.resolveCacheLocale(locale) ?? this.config.defaultLocale;
-			return this.localesDictionaryCache.get(dictionaryLocale)?.getObj(id);
+			const dictionaryLocale = this.resolveDictionaryCacheLocale(locale);
+			return this.localesCache.getDictionary(dictionaryLocale)?.getValue(id);
 		} catch (error) {
 			this.handleError(error);
 			return;
@@ -5567,19 +5474,10 @@ var I18nManager = class extends EventEmitter {
 	async lookupDictionaryWithFallback(locale, id) {
 		try {
 			const dictionaryLocale = this.resolveCacheLocale(locale);
-			if (!dictionaryLocale) {
-				const sourceEntry = this.localesDictionaryCache.get(this.config.defaultLocale)?.get(id);
-				if (sourceEntry === void 0) throw new DictionarySourceNotFoundError(id);
-				return sourceEntry;
-			}
-			let dictionaryCache = this.localesDictionaryCache.get(dictionaryLocale);
-			if (!dictionaryCache) dictionaryCache = await this.localesDictionaryCache.miss(dictionaryLocale);
-			let dictionaryEntry = dictionaryCache.get(id);
-			if (dictionaryEntry === void 0) {
-				const sourceEntry = this.localesDictionaryCache.get(this.config.defaultLocale)?.get(id);
-				if (sourceEntry === void 0) throw new DictionarySourceNotFoundError(id);
-				dictionaryEntry = await dictionaryCache.miss(id, sourceEntry);
-			}
+			if (!dictionaryLocale) return this.getSourceDictionaryEntry(id);
+			const dictionaryCache = await this.localesCache.getOrLoadDictionary(dictionaryLocale);
+			let dictionaryEntry = dictionaryCache.getEntry(id);
+			if (dictionaryEntry === void 0) dictionaryEntry = await dictionaryCache.materializeEntry(id, this.getSourceDictionaryEntry(id));
 			return dictionaryEntry;
 		} catch (error) {
 			this.handleError(error);
@@ -5593,25 +5491,41 @@ var I18nManager = class extends EventEmitter {
 	async lookupDictionaryObjWithFallback(locale, id) {
 		try {
 			const dictionaryLocale = this.resolveCacheLocale(locale);
-			if (!dictionaryLocale) {
-				const sourceObject = this.localesDictionaryCache.get(this.config.defaultLocale)?.getObj(id);
-				if (sourceObject === void 0) throw new DictionarySourceNotFoundError(id);
-				return sourceObject;
-			}
-			let dictionaryCache = this.localesDictionaryCache.get(dictionaryLocale);
-			if (!dictionaryCache) dictionaryCache = await this.localesDictionaryCache.miss(dictionaryLocale);
-			let dictionaryObject = dictionaryCache.getObj(id);
-			if (dictionaryObject === void 0) {
-				const sourceObject = this.localesDictionaryCache.get(this.config.defaultLocale)?.getObj(id);
-				if (sourceObject === void 0) throw new DictionarySourceNotFoundError(id);
-				dictionaryObject = await dictionaryCache.missObj(id, sourceObject);
+			if (!dictionaryLocale) return this.getSourceDictionaryObject(id);
+			const dictionaryCache = await this.localesCache.getOrLoadDictionary(dictionaryLocale);
+			const targetObject = dictionaryCache.getValue(id);
+			const sourceObject = this.getSourceDictionaryObject(id, { throwOnMissing: false });
+			if (sourceObject === void 0) {
+				if (targetObject !== void 0) return targetObject;
+				throw new DictionarySourceNotFoundError(id);
 			}
-			return dictionaryObject;
+			return await dictionaryCache.materializeValue(id, sourceObject, targetObject);
 		} catch (error) {
 			this.handleError(error);
 			return;
 		}
 	}
+	async translateDictionaryEntry(locale, id, sourceEntry) {
+		const translation = await this.lookupTranslationWithFallbackResolved(locale, sourceEntry.entry, resolveDictionaryLookupOptions(sourceEntry.options));
+		if (typeof translation !== "string") throw new Error(`Dictionary entry "${id}" could not be translated into a string. Check the source entry and translation loader output.`);
+		return translation;
+	}
+	getSourceDictionaryEntry(id) {
+		const sourceEntry = this.getDefaultDictionaryCache()?.getEntry(id);
+		if (sourceEntry === void 0) throw new DictionarySourceNotFoundError(id);
+		return sourceEntry;
+	}
+	getSourceDictionaryObject(id, { throwOnMissing = true } = {}) {
+		const sourceObject = this.getDefaultDictionaryCache()?.getValue(id);
+		if (sourceObject === void 0 && throwOnMissing) throw new DictionarySourceNotFoundError(id);
+		return sourceObject;
+	}
+	getDefaultDictionaryCache() {
+		return this.localesCache.getDictionary(this.config.defaultLocale);
+	}
+	resolveDictionaryCacheLocale(locale) {
+		return this.resolveCacheLocale(locale) ?? this.config.defaultLocale;
+	}
 	/**
 	* Just lookup a translation
 	*/
@@ -5619,7 +5533,7 @@ var I18nManager = class extends EventEmitter {
 		try {
 			const { translationLocale, options: lookupOptions } = this.resolveLookupParams(locale, options);
 			if (!translationLocale) return message;
-			const txCache = this.localesCache.get(translationLocale);
+			const txCache = this.localesCache.getTranslations(translationLocale);
 			if (!txCache) return void 0;
 			return txCache.get({
 				message,
@@ -5657,9 +5571,7 @@ var I18nManager = class extends EventEmitter {
 			if (!translationLocale) return (message) => message;
 			const resolvedPrefetchEntries = resolvePrefetchEntriesByLocale(prefetchEntries, translationLocale, (entryLocale) => this.resolveCacheLocale(entryLocale) ?? this.resolveLocale(entryLocale));
 			if (resolvedPrefetchEntries.length !== prefetchEntries.length) logger_default.warn(`I18nManager: getLookupTranslation(): prefetchEntries must all be the same locale, ignoring all entries that are not for ${translationLocale}`);
-			let txCache = this.localesCache.get(translationLocale);
-			if (!txCache) txCache = await this.localesCache.miss(translationLocale);
-			if (!txCache) return () => void 0;
+			const txCache = await this.localesCache.getOrLoadTranslations(translationLocale);
 			await Promise.all(resolvedPrefetchEntries.filter((entry) => txCache.get(entry) == null).map((entry) => txCache.miss(entry)));
 			return (message, options = {}) => {
 				return txCache.get({
@@ -5731,7 +5643,7 @@ var I18nManager = class extends EventEmitter {
 	}
 	resolveLocale(locale) {
 		const resolvedLocale = this.localeConfig.determineLocale(locale);
-		if (!this.localeConfig.isValidLocale(locale) || !resolvedLocale) throw new Error(`I18nManager: validateLocale(): locale ${locale} is not valid`);
+		if (!this.localeConfig.isValidLocale(locale) || !resolvedLocale) throw new Error(`Locale "${locale}" is not valid. Use a valid BCP 47 locale code or add a custom mapping.`);
 		return resolvedLocale;
 	}
 	/**
@@ -5761,8 +5673,7 @@ var I18nManager = class extends EventEmitter {
 	async lookupTranslationWithFallbackResolved(locale, message, options) {
 		const { translationLocale, options: lookupOptions } = this.resolveLookupParams(locale, options);
 		if (!translationLocale) return message;
-		let txCache = this.localesCache.get(translationLocale);
-		if (!txCache) txCache = await this.localesCache.miss(translationLocale);
+		const txCache = await this.localesCache.getOrLoadTranslations(translationLocale);
 		let translation = txCache.get({
 			message,
 			options: lookupOptions
@@ -5774,14 +5685,6 @@ var I18nManager = class extends EventEmitter {
 		return translation;
 	}
 	/**
-	* Runtime lookup function for dictionaries
-	*/
-	async dictionaryRuntimeTranslate(locale, id, sourceEntry) {
-		const translation = await this.lookupTranslationWithFallbackResolved(locale, sourceEntry.entry, resolveDictionaryLookupOptions(sourceEntry.options));
-		if (typeof translation !== "string") throw new Error(`I18nManager: dictionaryRuntimeTranslate(): unable to translate dictionary entry ${id}`);
-		return translation;
-	}
-	/**
 	* A helper function to create a gt class that is locale agnostic
 	* This is helpful for when our getLocale function is bound to a
 	* specific context
@@ -5878,28 +5781,6 @@ function resolvePrefetchEntriesByLocale(prefetchEntries, locale, resolveLocale)
 		}
 	});
 }
-/**
-* Helper function for creating a translation loader
-*/
-function createTranslationLoader(params) {
-	return routeCreateTranslationLoader({
-		loadTranslations: params.loadTranslations,
-		type: getLoadTranslationsType(params),
-		remoteTranslationLoaderParams: {
-			cacheUrl: params.cacheUrl,
-			projectId: params.projectId,
-			_versionId: params._versionId,
-			_branchId: params._branchId,
-			customMapping: params.customMapping
-		}
-	});
-}
-/**
-* Helper function for creating a dictionary loader
-*/
-function createDictionaryLoader(params) {
-	return params.loadDictionary ?? (() => Promise.resolve({}));
-}
 let i18nManager = void 0;
 let fallbackDefaultLocale = "en";
 let conditionStore = { getLocale: () => fallbackDefaultLocale };
@@ -5910,7 +5791,7 @@ let conditionStore = { getLocale: () => fallbackDefaultLocale };
 */
 function getI18nManager() {
 	if (!i18nManager) {
-		logger_default.warn("getI18nManager(): Translation failed because I18nManager not initialized.");
+		logger_default.warn("getI18nManager(): I18nManager was not initialized. Falling back to the default locale until initializeGT() configures translations.");
 		i18nManager = new I18nManager({
 			defaultLocale: "en",
 			locales: ["en"]
@@ -6042,10 +5923,30 @@ function resolveTranslationSyncWithFallback(locale, message, options = {}) {
 //#endregion
 //#region src/shared/messages.ts
 const PACKAGE_NAME = "gt-react";
-`${PACKAGE_NAME}${PACKAGE_NAME}`;
-`${PACKAGE_NAME}`;
-`${PACKAGE_NAME}`;
-const createTranslationFailedDueToBrowserEnvironmentWarning = (message) => `${PACKAGE_NAME} Warning: Translation failed for t("${typeof message === "string" ? message : "`" + message?.join("${}") + "`"}") because it was used outside of a browser environment. Falling back to original message.`;
+createDiagnosticMessage({
+	source: `${PACKAGE_NAME}/browser`,
+	severity: "Error",
+	whatHappened: "This module requires a browser environment",
+	fix: "Import it only from client-side code"
+});
+createDiagnosticMessage({
+	source: PACKAGE_NAME,
+	severity: "Error",
+	whatHappened: "A browser-only module was imported outside the browser",
+	fix: "Move this import to client-side code"
+});
+createDiagnosticMessage({
+	source: PACKAGE_NAME,
+	severity: "Error",
+	whatHappened: "BrowserI18nManager is not initialized",
+	fix: "Call initializeGT() before using browser translation APIs"
+});
+const createTranslationFailedDueToBrowserEnvironmentWarning = (message) => createDiagnosticMessage({
+	source: PACKAGE_NAME,
+	severity: "Warning",
+	whatHappened: `t("${typeof message === "string" ? message : "`" + message?.join("${}") + "`"}") could not be translated because it ran outside the browser`,
+	wayOut: "The original message will render as a fallback"
+});
 //#endregion
 //#region src/i18n-context/functions/translation/t.ts
 /**
@@ -6091,7 +5992,7 @@ const t = (messageOrStrings, ...values) => {
 */
 function handleTaggedTemplateLiteralTranslation(messageOrStrings, values) {
 	const locale = getLocale();
-	const translatedInterpolatedTemplate = resolveTranslationSync(locale, interpolateTemplateLiteral(messageOrStrings, values));
+	const translatedInterpolatedTemplate = resolveTranslationSync(locale, messageOrStrings.map((string, index) => string + (values[index] ?? "")).join(""));
 	if (translatedInterpolatedTemplate) return translatedInterpolatedTemplate;
 	const { message, variables } = extractInterpolatableValues(messageOrStrings, values);
 	return resolveTranslationSyncWithFallback(locale, message, variables);
@@ -6120,17 +6021,6 @@ function extractInterpolatableValues(strings, values) {
 		variables
 	};
 }
-/**
-* Interpolate a template literal
-* @param message - The message to interpolate.
-* @param variables - The variables to interpolate.
-* @returns The interpolated message.
-*/
-function interpolateTemplateLiteral(strings, values) {
-	return strings.map((string, index) => {
-		return string + (values[index] ?? "");
-	}).join("");
-}
 //#endregion
 //#region src/macros.ts
 globalThis.t = t;