@od-oneapp/internationalization 2026.1.1301

package/dist/react19-cache-DHL04P0L.mjs

@@ -0,0 +1,485 @@
+import { a as locale } from "./routing-CK71AHzC.mjs";
+import { logDebug, logError, logWarn } from "@od-oneapp/shared/logger";
+
+//#region src/shared/dictionary-loader.ts
+/**
+* @fileoverview Shared dictionary loading utility
+*
+* This utility provides type-safe dictionary loading with proper error handling
+* and fallback mechanisms. It eliminates code duplication between server.ts and index.ts.
+*
+* Features:
+* - In-memory LRU cache for loaded dictionaries
+* - Cache statistics for monitoring
+* - Error handling with fallback to default locale
+* - Support for multiple locales
+*
+* @module @od-oneapp/internationalization/shared/dictionary-loader
+*/
+const locales = [locale.source, ...locale.targets];
+const MAX_CACHE_SIZE = Number.parseInt(process.env.I18N_CACHE_MAX_SIZE ?? "10", 10) ?? 10;
+const dictionaryCache = /* @__PURE__ */ new Map();
+const MAX_SAFE_COUNT = Number.MAX_SAFE_INTEGER;
+const cacheStats = {
+	hits: 0,
+	misses: 0,
+	evictions: 0,
+	errors: 0
+};
+/**
+* Gets current cache statistics for monitoring and debugging.
+* Useful for production performance analysis.
+*
+* @returns Cache statistics object with hits, misses, evictions, and errors
+*/
+function getCacheStats() {
+	return {
+		...cacheStats,
+		size: dictionaryCache.size,
+		maxSize: MAX_CACHE_SIZE,
+		hitRate: cacheStats.hits + cacheStats.misses > 0 ? `${(cacheStats.hits / (cacheStats.hits + cacheStats.misses) * 100).toFixed(2)}%` : "0%"
+	};
+}
+/**
+* Resets cache statistics. Useful for testing or periodic reset.
+* Also prevents overflow in long-running processes.
+*
+* Note: This only resets statistics counters, not the cache itself.
+* To clear the cache entries, create a new dictionary loader instance.
+*/
+function resetCacheStats() {
+	cacheStats.hits = 0;
+	cacheStats.misses = 0;
+	cacheStats.evictions = 0;
+	cacheStats.errors = 0;
+}
+/**
+* Implements LRU (Least Recently Used) cache eviction.
+* Moves accessed item to end of Map (most recent).
+* Node 22 Map maintains insertion order.
+*
+* @param locale - The locale to mark as recently used
+*/
+function touchCache(locale) {
+	const value = dictionaryCache.get(locale);
+	if (value) {
+		dictionaryCache.delete(locale);
+		dictionaryCache.set(locale, value);
+	}
+}
+/**
+* Removes the least-recently-used dictionary from the in-memory cache when the cache size reaches the configured maximum.
+*
+* If an entry is evicted, increments the `cacheStats.evictions` counter with overflow protection and emits a debug log entry with eviction metadata when a logger is available.
+*/
+function evictOldestIfNeeded() {
+	if (dictionaryCache.size >= MAX_CACHE_SIZE) {
+		const oldestKey = dictionaryCache.keys().next().value;
+		if (oldestKey) {
+			dictionaryCache.delete(oldestKey);
+			cacheStats.evictions = Math.min((cacheStats.evictions ?? 0) + 1, MAX_SAFE_COUNT);
+			logDebug("Dictionary cache eviction", {
+				evictedLocale: oldestKey,
+				cacheSize: dictionaryCache.size,
+				totalEvictions: cacheStats.evictions,
+				context: {
+					function: "evictOldestIfNeeded",
+					package: "@od-oneapp/internationalization"
+				}
+			});
+		}
+	}
+}
+const EMPTY_DICTIONARY = {
+	common: {
+		locale: "",
+		language: ""
+	},
+	web: {
+		global: {
+			primaryCta: "",
+			secondaryCta: ""
+		},
+		header: {
+			home: "",
+			product: {
+				title: "",
+				description: "",
+				pricing: ""
+			},
+			blog: "",
+			docs: "",
+			contact: "",
+			signIn: "",
+			signUp: ""
+		},
+		home: {
+			meta: {
+				title: "",
+				description: ""
+			},
+			hero: { announcement: "" },
+			cases: { title: "" },
+			features: {
+				title: "",
+				description: "",
+				items: []
+			},
+			stats: {
+				title: "",
+				description: "",
+				items: []
+			},
+			testimonials: {
+				title: "",
+				items: []
+			},
+			faq: {
+				title: "",
+				description: "",
+				cta: "",
+				items: []
+			},
+			cta: {
+				title: "",
+				description: ""
+			}
+		},
+		blog: { meta: {
+			title: "",
+			description: ""
+		} },
+		contact: {
+			meta: {
+				title: "",
+				description: ""
+			},
+			hero: {
+				benefits: [],
+				form: {
+					title: "",
+					date: "",
+					firstName: "",
+					lastName: "",
+					resume: "",
+					cta: ""
+				}
+			}
+		}
+	}
+};
+/**
+* Import a module with a timeout to prevent indefinite hangs.
+* Uses Promise.race for timeout handling (import() cannot be cancelled).
+*
+* @param path - The module path to import
+* @param timeoutMs - Timeout in milliseconds (default: 5000ms)
+* @returns Promise that resolves to the imported module
+* @throws Error if import times out or fails
+*/
+async function importWithTimeout(path, timeoutMs = 5e3) {
+	let timeoutId;
+	try {
+		const result = await Promise.race([import(path), new Promise((_resolve, reject) => {
+			timeoutId = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Import timeout after ${timeoutMs}ms: ${path}`));
+			}, timeoutMs);
+		})]);
+		if (timeoutId !== void 0) clearTimeout(timeoutId);
+		return result;
+	} catch (error) {
+		if (timeoutId !== void 0) clearTimeout(timeoutId);
+		throw error;
+	}
+}
+/**
+* Validates and normalizes a locale string to prevent path traversal attacks.
+*
+* @param locale - The locale string to validate
+* @returns The normalized locale if valid, null otherwise
+*/
+function validateAndNormalizeLocale(locale) {
+	if (!locale || typeof locale !== "string" || locale.length > 20) return null;
+	if (!/^[a-z]{2}(-[a-z]{2,4})?$/i.test(locale)) return null;
+	const normalizedLocale = (locale.split("-")[0] ?? locale).toLowerCase();
+	if (!locales.includes(normalizedLocale)) return null;
+	return normalizedLocale;
+}
+/**
+* Creates a type-safe dictionary loader with proper error handling
+*
+* @returns An object with methods to load dictionaries and check locale support
+*/
+function createDictionaryLoader() {
+	const dictionaries = Object.fromEntries(locales.map((locale) => [locale, () => {
+		if (dictionaryCache.has(locale)) {
+			touchCache(locale);
+			cacheStats.hits = Math.min((cacheStats.hits ?? 0) + 1, MAX_SAFE_COUNT);
+			const cached = dictionaryCache.get(locale);
+			if (!cached) throw new Error(`Cache inconsistency: locale ${locale} was in cache but get returned undefined`);
+			logDebug("Dictionary cache hit", {
+				locale,
+				cached: true,
+				cacheSize: dictionaryCache.size,
+				hitRate: getCacheStats().hitRate,
+				context: {
+					function: "createDictionaryLoader",
+					package: "@od-oneapp/internationalization"
+				}
+			});
+			return cached;
+		}
+		cacheStats.misses = Math.min((cacheStats.misses ?? 0) + 1, MAX_SAFE_COUNT);
+		evictOldestIfNeeded();
+		let originalLoadSucceeded = false;
+		const loadPromise = (async () => {
+			const startTime = performance.now();
+			try {
+				const mod = await importWithTimeout(`../dictionaries/${locale}.json`, 5e3);
+				originalLoadSucceeded = true;
+				const duration = performance.now() - startTime;
+				const dictionary = mod.default;
+				logDebug("Dictionary loaded successfully", {
+					locale,
+					duration: `${duration.toFixed(2)}ms`,
+					cached: false,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					context: {
+						function: "createDictionaryLoader",
+						package: "@od-oneapp/internationalization"
+					}
+				});
+				return dictionary;
+			} catch (error) {
+				const duration = performance.now() - startTime;
+				cacheStats.errors = Math.min((cacheStats.errors ?? 0) + 1, MAX_SAFE_COUNT);
+				const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+				const errorStack = error instanceof Error ? error.stack : void 0;
+				logError(`Failed to load dictionary for locale: ${locale}`, {
+					error: errorMessage,
+					stack: errorStack,
+					locale,
+					duration: `${duration.toFixed(2)}ms`,
+					totalErrors: cacheStats.errors,
+					context: {
+						function: "createDictionaryLoader",
+						package: "@od-oneapp/internationalization"
+					}
+				});
+				try {
+					const fallbackStartTime = performance.now();
+					const fallbackMod = await importWithTimeout("../dictionaries/en.json", 5e3);
+					const fallbackDuration = performance.now() - fallbackStartTime;
+					const fallbackDictionary = fallbackMod.default;
+					logDebug("English fallback dictionary loaded", {
+						originalLocale: locale,
+						fallbackLocale: "en",
+						duration: `${fallbackDuration.toFixed(2)}ms`,
+						context: {
+							function: "createDictionaryLoader",
+							package: "@od-oneapp/internationalization"
+						}
+					});
+					return fallbackDictionary;
+				} catch (fallbackError) {
+					logError("Critical: English fallback dictionary failed to load", {
+						error: fallbackError instanceof Error ? fallbackError.message : typeof fallbackError === "string" ? fallbackError : "Unknown error",
+						stack: fallbackError instanceof Error ? fallbackError.stack : void 0,
+						locale
+					});
+					throw fallbackError;
+				}
+			}
+		})();
+		const cachedPromiseWrapper = async () => {
+			try {
+				const result = await loadPromise;
+				const cached = dictionaryCache.get(locale);
+				if (!originalLoadSucceeded && cached === cachedPromise) dictionaryCache.delete(locale);
+				return result;
+			} catch (error) {
+				if (dictionaryCache.get(locale) === cachedPromise) dictionaryCache.delete(locale);
+				throw error;
+			}
+		};
+		const cachedPromise = cachedPromiseWrapper();
+		dictionaryCache.set(locale, cachedPromise);
+		return cachedPromise;
+	}]));
+	return {
+		async getDictionary(locale) {
+			const startTime = performance.now();
+			const validatedLocale = validateAndNormalizeLocale(locale);
+			if (!validatedLocale) {
+				logWarn(`Invalid or unsupported locale "${locale}", defaulting to "en"`, {
+					locale,
+					context: {
+						function: "getDictionary",
+						package: "@od-oneapp/internationalization"
+					}
+				});
+				try {
+					const resolvedDictionary = await (dictionaries.en?.() ?? Promise.resolve(EMPTY_DICTIONARY));
+					logDebug("Dictionary loaded via fallback", {
+						requestedLocale: locale,
+						actualLocale: "en",
+						duration: `${(performance.now() - startTime).toFixed(2)}ms`,
+						cached: dictionaryCache.has("en"),
+						context: {
+							function: "getDictionary",
+							package: "@od-oneapp/internationalization"
+						}
+					});
+					return resolvedDictionary;
+				} catch (error) {
+					const duration = performance.now() - startTime;
+					logError("Failed to load English fallback dictionary", {
+						error: error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error",
+						stack: error instanceof Error ? error.stack : void 0,
+						duration: `${duration.toFixed(2)}ms`
+					});
+					return EMPTY_DICTIONARY;
+				}
+			}
+			try {
+				const resolvedDictionary = await (dictionaries[validatedLocale]?.() ?? Promise.resolve(EMPTY_DICTIONARY));
+				logDebug("Dictionary retrieved", {
+					locale: validatedLocale,
+					duration: `${(performance.now() - startTime).toFixed(2)}ms`,
+					cached: dictionaryCache.has(validatedLocale),
+					context: {
+						function: "getDictionary",
+						package: "@od-oneapp/internationalization"
+					}
+				});
+				return resolvedDictionary;
+			} catch (error) {
+				const duration = performance.now() - startTime;
+				logError(`Error loading dictionary for locale "${validatedLocale}", falling back to "en"`, {
+					error: error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error",
+					stack: error instanceof Error ? error.stack : void 0,
+					locale: validatedLocale,
+					duration: `${duration.toFixed(2)}ms`,
+					context: {
+						function: "getDictionary",
+						package: "@od-oneapp/internationalization"
+					}
+				});
+				try {
+					return await (dictionaries.en?.() ?? Promise.resolve(EMPTY_DICTIONARY));
+				} catch (fallbackError) {
+					logError("Failed to load English fallback dictionary", {
+						error: fallbackError instanceof Error ? fallbackError.message : typeof fallbackError === "string" ? fallbackError : "Unknown error",
+						stack: fallbackError instanceof Error ? fallbackError.stack : void 0
+					});
+					return EMPTY_DICTIONARY;
+				}
+			}
+		},
+		getLocales: () => locales,
+		isLocaleSupported: (locale) => {
+			return validateAndNormalizeLocale(locale) !== null;
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/react19-cache.ts
+/**
+* @fileoverview React 19 optimized dictionary cache
+*
+* This module provides React 19-aware dictionary caching that works
+* seamlessly with React Server Components and the `use` hook.
+*
+* Features:
+* - Promise-based dictionary loading for React 19's `use` hook
+* - Suspense support for Server Components
+* - Cache management and preloading utilities
+*
+* @module @od-oneapp/internationalization/shared/react19-cache
+*/
+const dictionaryLoader = createDictionaryLoader();
+/**
+* Cache for dictionary promises that can be used with React 19's `use` hook.
+* React 19 can suspend on promises, so we expose the raw promises.
+*
+* @example
+* ```tsx
+* // In a React 19 Server Component
+* import { use } from 'react';
+* import { getDictionaryPromise } from '@od-oneapp/internationalization/server';
+*
+* export default function Page({ locale }: { locale: string }) {
+*   // React 19's `use` hook will suspend until dictionary loads
+*   const dict = use(getDictionaryPromise(locale));
+*   return <h1>{dict.web.home.meta.title}</h1>;
+* }
+* ```
+*/
+const react19PromiseCache = /* @__PURE__ */ new Map();
+/**
+* Gets a dictionary promise suitable for React 19's `use` hook.
+* The promise is cached to prevent unnecessary re-renders.
+* This cache is synchronized with the LRU cache to prevent desynchronization.
+*
+* @param locale - The locale to load
+* @returns A promise that resolves to the dictionary (stable reference)
+*/
+function getDictionaryPromise(locale) {
+	const promise = dictionaryLoader.getDictionary(locale);
+	react19PromiseCache.set(locale, promise);
+	return promise;
+}
+/**
+* Preloads a dictionary for optimal React 19 performance.
+* Call this in route handlers or middleware to warm the cache.
+*
+* @param locale - The locale to preload
+* @returns The preload promise (fire and forget)
+*
+* @example
+* ```tsx
+* // In middleware or route handler
+* import { preloadDictionary } from '@od-oneapp/internationalization/server';
+*
+* export function middleware(request: NextRequest) {
+*   const locale = getLocaleFromRequest(request);
+*   preloadDictionary(locale); // Fire and forget
+*   // ...
+* }
+* ```
+*/
+function preloadDictionary(locale) {
+	return getDictionaryPromise(locale);
+}
+/**
+* Clears the React 19 promise cache.
+* Useful for testing or manual cache invalidation.
+*/
+function clearReact19Cache() {
+	react19PromiseCache.clear();
+}
+/**
+* Type guard for checking if a value is a valid locale.
+* React 19 benefits from proper type narrowing.
+* Uses the same validation logic as dictionary-loader for consistency.
+*
+* @param value - The value to check
+* @returns True if the value is a valid Locale
+*/
+function isValidLocale(value) {
+	if (typeof value !== "string" || value.length === 0 || value.length > 20) return false;
+	if (!/^[a-z]{2}(-[a-z]{2,4})?$/i.test(value)) return false;
+	const normalizedLocale = (value.split("-")[0] ?? value).toLowerCase();
+	return [
+		"en",
+		"es",
+		"de",
+		"fr",
+		"pt"
+	].includes(normalizedLocale);
+}
+
+//#endregion
+export { createDictionaryLoader as a, preloadDictionary as i, getDictionaryPromise as n, getCacheStats as o, isValidLocale as r, resetCacheStats as s, clearReact19Cache as t };
+//# sourceMappingURL=react19-cache-DHL04P0L.mjs.map

package/dist/react19-cache-DHL04P0L.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react19-cache-DHL04P0L.mjs","names":[],"sources":["../src/shared/dictionary-loader.ts","../src/shared/react19-cache.ts"],"sourcesContent":["/**\n * @fileoverview Shared dictionary loading utility\n *\n * This utility provides type-safe dictionary loading with proper error handling\n * and fallback mechanisms. It eliminates code duplication between server.ts and index.ts.\n *\n * Features:\n * - In-memory LRU cache for loaded dictionaries\n * - Cache statistics for monitoring\n * - Error handling with fallback to default locale\n * - Support for multiple locales\n *\n * @module @repo/internationalization/shared/dictionary-loader\n */\n\nimport { logDebug, logError, logWarn } from '@repo/shared/logger';\n\nimport languine from '../../languine.json';\n\nimport type en from '../dictionaries/en.json';\n\nconst locales = [languine.locale.source, ...languine.locale.targets] as const;\n\nexport type Locale = (typeof locales)[number];\nexport type Dictionary = typeof en;\n\n// In-memory cache for loaded dictionaries with LRU eviction\n// Limited to prevent memory bloat in long-running Node 22 processes\n// Can be configured via environment variable for different deployment scenarios\nconst MAX_CACHE_SIZE = Number.parseInt(process.env.I18N_CACHE_MAX_SIZE ?? '10', 10) ?? 10;\nconst dictionaryCache = new Map<Locale, Promise<Dictionary>>();\n\n// Cache statistics for monitoring (Node 22 performance tracking)\n// Use Number.MAX_SAFE_INTEGER to prevent overflow in long-running processes\nconst MAX_SAFE_COUNT = Number.MAX_SAFE_INTEGER;\nconst cacheStats = {\n  hits: 0,\n  misses: 0,\n  evictions: 0,\n  errors: 0,\n};\n\n/**\n * Gets current cache statistics for monitoring and debugging.\n * Useful for production performance analysis.\n *\n * @returns Cache statistics object with hits, misses, evictions, and errors\n */\nexport function getCacheStats() {\n  return {\n    ...cacheStats,\n    size: dictionaryCache.size,\n    maxSize: MAX_CACHE_SIZE,\n    hitRate:\n      cacheStats.hits + cacheStats.misses > 0\n        ? `${((cacheStats.hits / (cacheStats.hits + cacheStats.misses)) * 100).toFixed(2)}%`\n        : '0%',\n  };\n}\n\n/**\n * Resets cache statistics. Useful for testing or periodic reset.\n * Also prevents overflow in long-running processes.\n *\n * Note: This only resets statistics counters, not the cache itself.\n * To clear the cache entries, create a new dictionary loader instance.\n */\nexport function resetCacheStats(): void {\n  cacheStats.hits = 0;\n  cacheStats.misses = 0;\n  cacheStats.evictions = 0;\n  cacheStats.errors = 0;\n}\n\n/**\n * Implements LRU (Least Recently Used) cache eviction.\n * Moves accessed item to end of Map (most recent).\n * Node 22 Map maintains insertion order.\n *\n * @param locale - The locale to mark as recently used\n */\nfunction touchCache(locale: Locale): void {\n  const value = dictionaryCache.get(locale);\n  if (value) {\n    // Remove and re-add to move to end (most recent)\n    dictionaryCache.delete(locale);\n    dictionaryCache.set(locale, value);\n  }\n}\n\n/**\n * Removes the least-recently-used dictionary from the in-memory cache when the cache size reaches the configured maximum.\n *\n * If an entry is evicted, increments the `cacheStats.evictions` counter with overflow protection and emits a debug log entry with eviction metadata when a logger is available.\n */\nfunction evictOldestIfNeeded(): void {\n  if (dictionaryCache.size >= MAX_CACHE_SIZE) {\n    // First key is oldest (Map maintains insertion order)\n    const oldestKey = dictionaryCache.keys().next().value;\n    if (oldestKey) {\n      dictionaryCache.delete(oldestKey);\n      // Atomic increment with overflow protection\n      cacheStats.evictions = Math.min((cacheStats.evictions ?? 0) + 1, MAX_SAFE_COUNT);\n      logDebug('Dictionary cache eviction', {\n        evictedLocale: oldestKey,\n        cacheSize: dictionaryCache.size,\n        totalEvictions: cacheStats.evictions,\n        context: {\n          function: 'evictOldestIfNeeded',\n          package: '@repo/internationalization',\n        },\n      });\n    }\n  }\n}\n\n// Minimal valid dictionary structure for fallback\n// Matches the complete structure of en.json to prevent runtime errors\nconst EMPTY_DICTIONARY: Dictionary = {\n  common: {\n    locale: '',\n    language: '',\n  },\n  web: {\n    global: {\n      primaryCta: '',\n      secondaryCta: '',\n    },\n    header: {\n      home: '',\n      product: {\n        title: '',\n        description: '',\n        pricing: '',\n      },\n      blog: '',\n      docs: '',\n      contact: '',\n      signIn: '',\n      signUp: '',\n    },\n    home: {\n      meta: {\n        title: '',\n        description: '',\n      },\n      hero: {\n        announcement: '',\n      },\n      cases: {\n        title: '',\n      },\n      features: {\n        title: '',\n        description: '',\n        items: [],\n      },\n      stats: {\n        title: '',\n        description: '',\n        items: [],\n      },\n      testimonials: {\n        title: '',\n        items: [],\n      },\n      faq: {\n        title: '',\n        description: '',\n        cta: '',\n        items: [],\n      },\n      cta: {\n        title: '',\n        description: '',\n      },\n    },\n    blog: {\n      meta: {\n        title: '',\n        description: '',\n      },\n    },\n    contact: {\n      meta: {\n        title: '',\n        description: '',\n      },\n      hero: {\n        benefits: [],\n        form: {\n          title: '',\n          date: '',\n          firstName: '',\n          lastName: '',\n          resume: '',\n          cta: '',\n        },\n      },\n    },\n  },\n};\n\n// Use the structured empty dictionary for type-safe fallback\n// EMPTY_DICTIONARY already provides the correct shape\n\n// Type-safe error for dictionary loading (reserved for future use)\nexport interface _DictionaryLoadError {\n  locale: string;\n  message: string;\n  originalError: unknown;\n}\n\n/**\n * Import a module with a timeout to prevent indefinite hangs.\n * Uses Promise.race for timeout handling (import() cannot be cancelled).\n *\n * @param path - The module path to import\n * @param timeoutMs - Timeout in milliseconds (default: 5000ms)\n * @returns Promise that resolves to the imported module\n * @throws Error if import times out or fails\n */\nasync function importWithTimeout<T>(path: string, timeoutMs = 5000): Promise<T> {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  try {\n    // Race between import and timeout\n    // Note: import() cannot be cancelled, but we can reject the promise on timeout\n    const result = await Promise.race([\n      import(path) as Promise<T>,\n      new Promise<never>((_resolve, reject) => {\n        timeoutId = setTimeout(() => {\n          reject(new Error(`Import timeout after ${timeoutMs}ms: ${path}`));\n        }, timeoutMs);\n      }),\n    ]);\n\n    // Clear timeout if import succeeded before timeout\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId);\n    }\n\n    return result;\n  } catch (error: unknown) {\n    // Ensure timeout is cleared on error\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId);\n    }\n    throw error;\n  }\n}\n\n/**\n * Validates and normalizes a locale string to prevent path traversal attacks.\n *\n * @param locale - The locale string to validate\n * @returns The normalized locale if valid, null otherwise\n */\nfunction validateAndNormalizeLocale(locale: string): Locale | null {\n  // Validate input length and type\n  if (!locale || typeof locale !== 'string' || locale.length > 20) {\n    return null;\n  }\n\n  // Validate pattern (alphanumeric and hyphens only, BCP 47 format)\n  // Safe regex: bounded quantifiers ({2}, {2,4}), input length pre-validated (max 20), no catastrophic backtracking\n  // eslint-disable-next-line regexp/no-unused-capturing-group, security/detect-unsafe-regex -- Capturing group needed for validation; regex is safe (bounded quantifiers, input length limited)\n  if (!/^[a-z]{2}(-[a-z]{2,4})?$/i.test(locale)) {\n    return null;\n  }\n\n  // Normalize to base locale (e.g., 'en-US' -> 'en')\n  const localeParts = locale.split('-');\n  const normalizedLocale = (localeParts[0] ?? locale).toLowerCase();\n\n  // Validate normalized locale exists in supported locales\n  if (!locales.includes(normalizedLocale)) {\n    return null;\n  }\n\n  return normalizedLocale;\n}\n\n/**\n * Creates a type-safe dictionary loader with proper error handling\n *\n * @returns An object with methods to load dictionaries and check locale support\n */\nexport function createDictionaryLoader() {\n  const dictionaries: Record<Locale, () => Promise<Dictionary>> = Object.fromEntries(\n    locales.map(locale => [\n      locale,\n      (): Promise<Dictionary> => {\n        // Check cache first (LRU-aware)\n        if (dictionaryCache.has(locale)) {\n          touchCache(locale); // Mark as recently used\n          // Atomic increment for cache hit statistics with overflow protection\n          cacheStats.hits = Math.min((cacheStats.hits ?? 0) + 1, MAX_SAFE_COUNT);\n          const cached = dictionaryCache.get(locale);\n          if (!cached) {\n            throw new Error(\n              `Cache inconsistency: locale ${locale} was in cache but get returned undefined`,\n            );\n          }\n          // Log cache hit without sensitive performance data in production\n          if (process.env.NODE_ENV === 'development') {\n            logDebug('Dictionary cache hit', {\n              locale,\n              cached: true,\n              cacheSize: dictionaryCache.size,\n              hitRate: getCacheStats().hitRate,\n              context: {\n                function: 'createDictionaryLoader',\n                package: '@repo/internationalization',\n              },\n            });\n          }\n          return cached;\n        }\n\n        // Cache miss - atomic increment with overflow protection\n        cacheStats.misses = Math.min((cacheStats.misses ?? 0) + 1, MAX_SAFE_COUNT);\n\n        // Evict oldest entry if cache is full\n        evictOldestIfNeeded();\n\n        // Load and cache dictionary\n        // Track whether the original locale load succeeded (not a fallback)\n        let originalLoadSucceeded = false;\n        const loadPromise = (async (): Promise<Dictionary> => {\n          const startTime = performance.now();\n\n          try {\n            // Locale is guaranteed safe here as it comes from the locales array\n            // Use timeout to prevent indefinite hangs\n            const mod = await importWithTimeout<{ default: Dictionary }>(\n              `../dictionaries/${locale}.json`,\n              5000,\n            );\n\n            // Mark that original load succeeded (not a fallback)\n            originalLoadSucceeded = true;\n            const duration = performance.now() - startTime;\n\n            const dictionary = mod.default;\n\n            logDebug('Dictionary loaded successfully', {\n              locale,\n              duration: `${duration.toFixed(2)}ms`,\n              cached: false,\n              timestamp: new Date().toISOString(),\n              context: {\n                function: 'createDictionaryLoader',\n                package: '@repo/internationalization',\n              },\n            });\n\n            return dictionary;\n          } catch (error: unknown) {\n            const duration = performance.now() - startTime;\n            // Atomic increment for error statistics with overflow protection\n            cacheStats.errors = Math.min((cacheStats.errors ?? 0) + 1, MAX_SAFE_COUNT);\n            const errorMessage =\n              error instanceof Error\n                ? error.message\n                : typeof error === 'string'\n                  ? error\n                  : 'Unknown error';\n            const errorStack = error instanceof Error ? error.stack : undefined;\n\n            logError(`Failed to load dictionary for locale: ${locale}`, {\n              error: errorMessage,\n              stack: errorStack,\n              locale,\n              duration: `${duration.toFixed(2)}ms`,\n              totalErrors: cacheStats.errors,\n              context: {\n                function: 'createDictionaryLoader',\n                package: '@repo/internationalization',\n              },\n            });\n\n            // Fallback to English dictionary\n            // IMPORTANT: Do not cache fallback results - they should not be cached\n            // under the original locale key to prevent incorrect caching\n            try {\n              const fallbackStartTime = performance.now();\n              const fallbackMod = await importWithTimeout<{ default: Dictionary }>(\n                '../dictionaries/en.json',\n                5000,\n              );\n              const fallbackDuration = performance.now() - fallbackStartTime;\n\n              const fallbackDictionary = fallbackMod.default;\n\n              logDebug('English fallback dictionary loaded', {\n                originalLocale: locale,\n                fallbackLocale: 'en',\n                duration: `${fallbackDuration.toFixed(2)}ms`,\n                context: {\n                  function: 'createDictionaryLoader',\n                  package: '@repo/internationalization',\n                },\n              });\n\n              // Return fallback but don't cache it - let it fail again next time\n              // This ensures we don't cache incorrect locale mappings\n              return fallbackDictionary;\n            } catch (fallbackError: unknown) {\n              logError('Critical: English fallback dictionary failed to load', {\n                error:\n                  fallbackError instanceof Error\n                    ? fallbackError.message\n                    : typeof fallbackError === 'string'\n                      ? fallbackError\n                      : 'Unknown error',\n                stack: fallbackError instanceof Error ? fallbackError.stack : undefined,\n                locale,\n              });\n              // Bubble up failure so callers can log additional context\n              throw fallbackError;\n            }\n          }\n        })();\n\n        // Wrap promise to check if original load succeeded before caching\n        const cachedPromiseWrapper = async (): Promise<Dictionary> => {\n          try {\n            const result = await loadPromise;\n            // Only keep in cache if original load succeeded (not a fallback)\n            // If original load failed and we used fallback, remove from cache\n            const cached = dictionaryCache.get(locale);\n            if (!originalLoadSucceeded && cached === cachedPromise) {\n              dictionaryCache.delete(locale);\n            }\n            return result;\n          } catch (error: unknown) {\n            // If promise rejects, remove from cache\n            const cached = dictionaryCache.get(locale);\n            if (cached === cachedPromise) {\n              dictionaryCache.delete(locale);\n            }\n            throw error;\n          }\n        };\n\n        // Create the promise and cache it\n        const cachedPromise = cachedPromiseWrapper();\n\n        // Cache the promise initially - we'll remove it later if it was a fallback\n        dictionaryCache.set(locale, cachedPromise);\n\n        return cachedPromise;\n      },\n    ]) satisfies Array<[Locale, () => Promise<Dictionary>]>,\n  ) as Record<Locale, () => Promise<Dictionary>>;\n\n  return {\n    /**\n     * Loads a dictionary for the specified locale with proper type safety and fallbacks.\n     *\n     * @param locale - The locale string to load (e.g., 'en', 'en-US', 'es')\n     * @returns A promise that resolves to the dictionary for the locale\n     *\n     * @example\n     * ```typescript\n     * const loader = createDictionaryLoader();\n     * const dict = await loader.getDictionary('en');\n     * ```\n     */\n    async getDictionary(locale: string): Promise<Dictionary> {\n      const startTime = performance.now();\n\n      // Validate and normalize locale to prevent path traversal\n      const validatedLocale = validateAndNormalizeLocale(locale);\n\n      if (!validatedLocale) {\n        logWarn(`Invalid or unsupported locale \"${locale}\", defaulting to \"en\"`, {\n          locale,\n          context: {\n            function: 'getDictionary',\n            package: '@repo/internationalization',\n          },\n        });\n        // Safely attempt English fallback\n        try {\n          const result = await (dictionaries.en?.() ?? Promise.resolve(EMPTY_DICTIONARY));\n          const resolvedDictionary = result;\n          const duration = performance.now() - startTime;\n\n          logDebug('Dictionary loaded via fallback', {\n            requestedLocale: locale,\n            actualLocale: 'en',\n            duration: `${duration.toFixed(2)}ms`,\n            cached: dictionaryCache.has('en'),\n            context: {\n              function: 'getDictionary',\n              package: '@repo/internationalization',\n            },\n          });\n\n          return resolvedDictionary;\n        } catch (error: unknown) {\n          const duration = performance.now() - startTime;\n\n          logError('Failed to load English fallback dictionary', {\n            error:\n              error instanceof Error\n                ? error.message\n                : typeof error === 'string'\n                  ? error\n                  : 'Unknown error',\n            stack: error instanceof Error ? error.stack : undefined,\n            duration: `${duration.toFixed(2)}ms`,\n          });\n          return EMPTY_DICTIONARY;\n        }\n      }\n\n      try {\n        const result = await (dictionaries[validatedLocale]?.() ??\n          Promise.resolve(EMPTY_DICTIONARY));\n        const resolvedDictionary = result;\n        const duration = performance.now() - startTime;\n\n        logDebug('Dictionary retrieved', {\n          locale: validatedLocale,\n          duration: `${duration.toFixed(2)}ms`,\n          cached: dictionaryCache.has(validatedLocale),\n          context: {\n            function: 'getDictionary',\n            package: '@repo/internationalization',\n          },\n        });\n\n        return resolvedDictionary;\n      } catch (error: unknown) {\n        const duration = performance.now() - startTime;\n\n        logError(`Error loading dictionary for locale \"${validatedLocale}\", falling back to \"en\"`, {\n          error:\n            error instanceof Error\n              ? error.message\n              : typeof error === 'string'\n                ? error\n                : 'Unknown error',\n          stack: error instanceof Error ? error.stack : undefined,\n          locale: validatedLocale,\n          duration: `${duration.toFixed(2)}ms`,\n          context: {\n            function: 'getDictionary',\n            package: '@repo/internationalization',\n          },\n        });\n        // Safely attempt English fallback\n        try {\n          const fallbackResult = await (dictionaries.en?.() ?? Promise.resolve(EMPTY_DICTIONARY));\n          return fallbackResult;\n        } catch (fallbackError: unknown) {\n          logError('Failed to load English fallback dictionary', {\n            error:\n              fallbackError instanceof Error\n                ? fallbackError.message\n                : typeof fallbackError === 'string'\n                  ? fallbackError\n                  : 'Unknown error',\n            stack: fallbackError instanceof Error ? fallbackError.stack : undefined,\n          });\n          return EMPTY_DICTIONARY;\n        }\n      }\n    },\n\n    /**\n     * Get all available locales.\n     *\n     * @returns An array of all supported locale codes\n     */\n    getLocales: () => locales,\n\n    /**\n     * Check if a locale is supported.\n     *\n     * @param locale - The locale string to check\n     * @returns True if the locale is supported, false otherwise\n     *\n     * @example\n     * ```typescript\n     * const loader = createDictionaryLoader();\n     * if (loader.isLocaleSupported('en-US')) {\n     *   // Load dictionary\n     * }\n     * ```\n     */\n    isLocaleSupported: (locale: string): boolean => {\n      return validateAndNormalizeLocale(locale) !== null;\n    },\n  };\n}\n","/**\n * @fileoverview React 19 optimized dictionary cache\n *\n * This module provides React 19-aware dictionary caching that works\n * seamlessly with React Server Components and the `use` hook.\n *\n * Features:\n * - Promise-based dictionary loading for React 19's `use` hook\n * - Suspense support for Server Components\n * - Cache management and preloading utilities\n *\n * @module @repo/internationalization/shared/react19-cache\n */\n\nimport { createDictionaryLoader } from './dictionary-loader';\n\nimport type { Dictionary, Locale } from './dictionary-loader';\n\n// Create dictionary loader instance for React 19 integration\nconst dictionaryLoader = createDictionaryLoader();\n\n/**\n * Cache for dictionary promises that can be used with React 19's `use` hook.\n * React 19 can suspend on promises, so we expose the raw promises.\n *\n * @example\n * ```tsx\n * // In a React 19 Server Component\n * import { use } from 'react';\n * import { getDictionaryPromise } from '@repo/internationalization/server';\n *\n * export default function Page({ locale }: { locale: string }) {\n *   // React 19's `use` hook will suspend until dictionary loads\n *   const dict = use(getDictionaryPromise(locale));\n *   return <h1>{dict.web.home.meta.title}</h1>;\n * }\n * ```\n */\n\n// React 19 promise cache for `use` hook compatibility\n// This cache is synchronized with the LRU cache in dictionary-loader to prevent memory leaks\nconst react19PromiseCache = new Map<Locale, Promise<Dictionary>>();\n\n/**\n * Gets a dictionary promise suitable for React 19's `use` hook.\n * The promise is cached to prevent unnecessary re-renders.\n * This cache is synchronized with the LRU cache to prevent desynchronization.\n *\n * @param locale - The locale to load\n * @returns A promise that resolves to the dictionary (stable reference)\n */\nexport function getDictionaryPromise(locale: Locale): Promise<Dictionary> {\n  // Always get fresh promise from dictionary loader to ensure cache synchronization\n  // The dictionary loader's LRU cache handles the actual caching\n  const promise = dictionaryLoader.getDictionary(locale);\n\n  // Store in React 19 cache for stable reference (required for `use` hook)\n  // This is safe because dictionaryLoader.getDictionary returns the same promise\n  // for the same locale when cached, maintaining referential equality\n  react19PromiseCache.set(locale, promise);\n\n  return promise;\n}\n\n/**\n * Preloads a dictionary for optimal React 19 performance.\n * Call this in route handlers or middleware to warm the cache.\n *\n * @param locale - The locale to preload\n * @returns The preload promise (fire and forget)\n *\n * @example\n * ```tsx\n * // In middleware or route handler\n * import { preloadDictionary } from '@repo/internationalization/server';\n *\n * export function middleware(request: NextRequest) {\n *   const locale = getLocaleFromRequest(request);\n *   preloadDictionary(locale); // Fire and forget\n *   // ...\n * }\n * ```\n */\nexport function preloadDictionary(locale: Locale): Promise<Dictionary> {\n  return getDictionaryPromise(locale);\n}\n\n/**\n * Clears the React 19 promise cache.\n * Useful for testing or manual cache invalidation.\n */\nexport function clearReact19Cache(): void {\n  react19PromiseCache.clear();\n}\n\n/**\n * Type guard for checking if a value is a valid locale.\n * React 19 benefits from proper type narrowing.\n * Uses the same validation logic as dictionary-loader for consistency.\n *\n * @param value - The value to check\n * @returns True if the value is a valid Locale\n */\nexport function isValidLocale(value: unknown): value is Locale {\n  if (typeof value !== 'string' || value.length === 0 || value.length > 20) {\n    return false;\n  }\n\n  // Validate pattern (BCP 47 format: 2-letter code optionally followed by region)\n  // Safe regex: bounded quantifiers ({2}, {2,4}), input length pre-validated (max 20), no catastrophic backtracking\n  // eslint-disable-next-line regexp/no-unused-capturing-group, security/detect-unsafe-regex -- Capturing group needed for validation; regex is safe (bounded quantifiers, input length limited)\n  if (!/^[a-z]{2}(-[a-z]{2,4})?$/i.test(value)) {\n    return false;\n  }\n\n  // Normalize and check against supported locales\n  const localeParts = value.split('-');\n  const normalizedLocale = (localeParts[0] ?? value).toLowerCase();\n  const supportedLocales: readonly Locale[] = ['en', 'es', 'de', 'fr', 'pt'];\n  return supportedLocales.includes(normalizedLocale);\n}\n\n/**\n * React 19 Suspense boundary helper types\n */\nexport type SuspendedDictionary = Promise<Dictionary> | Dictionary;\n\n/**\n * Unwraps a dictionary that might be suspended (React 19 pattern).\n * This is a type helper for components using `use`.\n */\nexport type UnwrapDictionary<T> = T extends Promise<infer U> ? U : T;\n"],"mappings":"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"}

package/dist/request.d.mts

@@ -0,0 +1,5 @@
+//#region src/request.d.ts
+declare const _default: any;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=request.d.mts.map

package/dist/request.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.mts","names":[],"sources":["../src/request.ts"],"mappings":""}

package/dist/request.mjs

@@ -0,0 +1,114 @@
+import { n as routing } from "./routing-CK71AHzC.mjs";
+import { i as getRequestConfig } from "./next-intl-server-CnBEO3Z3.mjs";
+import { logError, logWarn } from "@od-oneapp/shared/logger";
+import { hasLocale } from "next-intl";
+
+//#region src/shared/constants.ts
+/**
+* Default currency code used when locale-specific currency is not available
+*/
+const DEFAULT_CURRENCY = "USD";
+/**
+* Default timezone used when locale-specific timezone is not available
+*/
+const DEFAULT_TIMEZONE = "UTC";
+/**
+* Map of locales to their default currency codes
+*/
+const LOCALE_CURRENCY_MAP = {
+	en: "USD",
+	es: "EUR",
+	fr: "EUR",
+	de: "EUR",
+	pt: "EUR"
+};
+/**
+* Map of locales to their default timezones
+*/
+const LOCALE_TIMEZONE_MAP = {
+	en: "America/New_York",
+	es: "Europe/Madrid",
+	fr: "Europe/Paris",
+	de: "Europe/Berlin",
+	pt: "Europe/Lisbon"
+};
+
+//#endregion
+//#region src/request.ts
+/**
+* @fileoverview Request-scoped configuration for next-intl
+*
+* This file is used by the next-intl plugin to provide
+* messages and other i18n settings to Server Components.
+* Configures locale detection, currency, timezone, and formatting.
+*
+* @module @od-oneapp/internationalization/request
+*/
+var request_default = getRequestConfig(async ({ requestLocale }) => {
+	const requested = await requestLocale;
+	const locale = requested && hasLocale(routing.locales, requested) ? requested : routing.defaultLocale;
+	if (requested && requested !== locale) logWarn(`Unsupported locale "${requested}" requested, falling back to "${locale}"`, {
+		requested,
+		locale,
+		context: {
+			function: "getRequestConfig",
+			package: "@od-oneapp/internationalization"
+		}
+	});
+	try {
+		const messages = (await import(`./dictionaries/${locale}.json`)).default;
+		const currency = LOCALE_CURRENCY_MAP[locale] ?? DEFAULT_CURRENCY;
+		const timeZone = LOCALE_TIMEZONE_MAP[locale] ?? DEFAULT_TIMEZONE;
+		return {
+			locale,
+			messages,
+			formats: {
+				dateTime: { short: {
+					day: "numeric",
+					month: "short",
+					year: "numeric"
+				} },
+				number: { currency: {
+					style: "currency",
+					currency
+				} }
+			},
+			timeZone,
+			now: /* @__PURE__ */ new Date()
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+		const errorStack = error instanceof Error ? error.stack : void 0;
+		logError(`Failed to load messages for locale "${locale}"`, {
+			error: errorMessage,
+			stack: errorStack,
+			locale,
+			context: {
+				function: "getRequestConfig",
+				package: "@od-oneapp/internationalization"
+			}
+		});
+		try {
+			return {
+				locale: "en",
+				messages: (await import("./en-BG_-Eo3m.mjs")).default,
+				timeZone: LOCALE_TIMEZONE_MAP.en ?? DEFAULT_TIMEZONE,
+				now: /* @__PURE__ */ new Date()
+			};
+		} catch (fallbackError) {
+			logError("Failed to load fallback messages", {
+				error: fallbackError instanceof Error ? fallbackError.message : typeof fallbackError === "string" ? fallbackError : "Unknown error",
+				stack: fallbackError instanceof Error ? fallbackError.stack : void 0,
+				context: {
+					function: "getRequestConfig",
+					package: "@od-oneapp/internationalization"
+				}
+			});
+			throw new Error("Unable to load any translation messages");
+		}
+	}
+});
+
+//#endregion
+export { request_default as default };
+//# sourceMappingURL=request.mjs.map