gt-react 10.20.4 → 11.0.0-odysseus.1

package/dist/index.client.cjs

@@ -0,0 +1,1044 @@
+"use client";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _generaltranslation_react_core_pure = require("@generaltranslation/react-core/pure");
+let gt_i18n_internal = require("gt-i18n/internal");
+require("@generaltranslation/react-core/components-rsc");
+let react = require("react");
+let _generaltranslation_react_core_hooks = require("@generaltranslation/react-core/hooks");
+let _generaltranslation_react_core_components = require("@generaltranslation/react-core/components");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/i18n-cache/constants.ts
+const DEFAULT_HTML_TAG_OPTIONS = {
+	updateHtmlLangTag: true,
+	updateHtmlDirTag: true
+};
+//#endregion
+//#region src/i18n-cache/LocalStorageTranslationCache.ts
+const STORAGE_KEY_PREFIX = "gt:tx:";
+const PURGE_TIMESTAMP_PREFIX = "gt:tx:purge:";
+const FLUSH_INTERVAL = 500;
+const DEFAULT_MAX_SIZE = 1e6;
+const DEFAULT_TTL_MS = 864e5;
+const DEFAULT_PURGE_INTERVAL_MS = 3e5;
+const PURGE_TARGET_RATIO = .8;
+const activeIntervals = /* @__PURE__ */ new Map();
+/**
+* A localStorage-backed translation cache for a single locale.
+* Used in development mode only to persist runtime translations across page refreshes.
+*
+* Entries are stored with per-entry expiry timestamps and the cache is purged
+* when estimated size exceeds the configured maximum.
+*/
+var LocalStorageTranslationCache = class {
+	/**
+	* @param locale - The locale this cache is for
+	* @param projectId - The project id (namespaces localStorage keys)
+	* @param init - Optional initial translations to merge on top of localStorage data.
+	*               init values take priority over stale localStorage entries.
+	* @param maxSize - Maximum cache size in characters (default: ~1M)
+	* @param ttl - TTL in milliseconds for each entry (default: 24 hours)
+	* @param purgeInterval - Background purge check interval in ms (default: 5 min)
+	*/
+	constructor({ locale, projectId, init, maxSize, ttl, purgeInterval }) {
+		this._writeBuffer = {};
+		this._flushTimer = null;
+		this._estimatedSize = 0;
+		this._storageKey = `${STORAGE_KEY_PREFIX}${projectId}:${locale}`;
+		this._purgeTimestampKey = `${PURGE_TIMESTAMP_PREFIX}${projectId}:${locale}`;
+		this._maxSize = maxSize ?? DEFAULT_MAX_SIZE;
+		this._ttl = ttl ?? DEFAULT_TTL_MS;
+		this._purgeInterval = purgeInterval ?? DEFAULT_PURGE_INTERVAL_MS;
+		if (init) this.initStorage(init);
+		if (activeIntervals.has(this._storageKey)) clearInterval(activeIntervals.get(this._storageKey));
+		const intervalId = setInterval(() => this._backgroundPurge(), this._purgeInterval);
+		activeIntervals.set(this._storageKey, intervalId);
+	}
+	/**
+	* Returns the full translation map (cache + pending buffer writes).
+	* Filters out expired entries. Buffer entries take priority.
+	*/
+	getInternalCache() {
+		const now = Date.now();
+		const cache = this._readFromStorage();
+		const result = {};
+		for (const [key, entry] of Object.entries(cache)) if (entry.exp > now) result[key] = entry.t;
+		Object.assign(result, this._writeBuffer);
+		return result;
+	}
+	/**
+	* Queue a translation for writing to localStorage.
+	* Writes are batched via a debounced flush.
+	*/
+	write(hash, translation) {
+		this._writeBuffer[hash] = translation;
+		this._scheduleFlush();
+	}
+	/**
+	* Remove specific entries from the cache by hash.
+	*/
+	purge(hashes) {
+		const cache = this._readFromStorage();
+		for (const hash of hashes) delete cache[hash];
+		this._writeRaw(JSON.stringify(cache));
+	}
+	/**
+	* Schedule a flush of the write buffer.
+	* Uses a leading throttle — the first write in a burst schedules a flush
+	* after FLUSH_INTERVAL ms; subsequent writes before the timer fires are
+	* batched into the same flush.
+	*/
+	_scheduleFlush() {
+		if (this._flushTimer) return;
+		this._flushTimer = setTimeout(() => {
+			this._flushTimer = null;
+			this._flush();
+		}, FLUSH_INTERVAL);
+	}
+	/**
+	* Merge the write buffer into the cache and persist to localStorage.
+	* Purges before writing if estimated size exceeds max.
+	*/
+	_flush() {
+		if (Object.keys(this._writeBuffer).length === 0) return;
+		try {
+			const cache = this._readFromStorage();
+			const now = Date.now();
+			if (this._estimatedSize > this._maxSize) this._purgeCache(cache, now);
+			const exp = now + this._ttl;
+			for (const [key, value] of Object.entries(this._writeBuffer)) cache[key] = {
+				t: value,
+				exp
+			};
+			this._writeRaw(JSON.stringify(cache));
+		} catch {}
+		this._writeBuffer = {};
+	}
+	/**
+	* Purge entries from the cache in place.
+	* Phase 1: Remove expired entries.
+	* Phase 2: If still over target, drop oldest entries by expiry time.
+	*/
+	_purgeCache(cache, now) {
+		const keysBeforePurge = Object.keys(cache);
+		if (keysBeforePurge.length === 0) return;
+		const avgEntrySize = this._estimatedSize / keysBeforePurge.length;
+		deleteExpiredEntries(cache, now);
+		const targetSize = this._maxSize * PURGE_TARGET_RATIO;
+		const maxEntries = Math.floor(targetSize / avgEntrySize);
+		const remaining = Object.entries(cache);
+		if (remaining.length > maxEntries) {
+			remaining.sort((a, b) => a[1].exp - b[1].exp);
+			const toDrop = remaining.length - maxEntries;
+			for (let i = 0; i < toDrop; i++) delete cache[remaining[i][0]];
+		}
+	}
+	/**
+	* Background purge triggered by setInterval.
+	* Checks the last purge timestamp to avoid redundant work across tabs,
+	* then removes expired entries. Only writes back if something changed.
+	* Timestamp is updated after the purge completes.
+	*/
+	_backgroundPurge() {
+		try {
+			const raw = localStorage.getItem(this._purgeTimestampKey);
+			const lastPurge = raw ? parseInt(raw, 10) : 0;
+			const now = Date.now();
+			if (now - lastPurge < this._purgeInterval) return;
+			const cache = this._readFromStorage();
+			const keysBefore = Object.keys(cache).length;
+			deleteExpiredEntries(cache, now);
+			if (Object.keys(cache).length < keysBefore) this._writeRaw(JSON.stringify(cache));
+			localStorage.setItem(this._purgeTimestampKey, String(now));
+		} catch {}
+	}
+	/**
+	* Read and parse translations from localStorage.
+	* Recalibrates estimated size as a side effect.
+	* Returns empty object on any error (unavailable, corrupt data, etc.)
+	*/
+	_readFromStorage() {
+		try {
+			const raw = localStorage.getItem(this._storageKey);
+			if (!raw) {
+				this._estimatedSize = 0;
+				return {};
+			}
+			this._estimatedSize = raw.length;
+			return JSON.parse(raw);
+		} catch {
+			this._estimatedSize = 0;
+			return {};
+		}
+	}
+	/**
+	* Persist new entries to localStorage with expiry timestamps.
+	* Reads current cache, merges buffer on top, writes back.
+	*/
+	initStorage(buffer) {
+		try {
+			const cache = this._readFromStorage();
+			const exp = Date.now() + this._ttl;
+			for (const [key, value] of Object.entries(buffer)) cache[key] = {
+				t: value,
+				exp
+			};
+			this._writeRaw(JSON.stringify(cache));
+		} catch {}
+	}
+	/**
+	* Write a pre-serialized string to localStorage and recalibrate estimate.
+	*/
+	_writeRaw(serialized) {
+		try {
+			localStorage.setItem(this._storageKey, serialized);
+			this._estimatedSize = serialized.length;
+		} catch {}
+	}
+};
+/**
+* Helper function deletes expired entries from a cache in place.
+*/
+function deleteExpiredEntries(cache, now = Date.now()) {
+	for (const key of Object.keys(cache)) if (cache[key].exp <= now) delete cache[key];
+}
+//#endregion
+//#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;
+}
+//#endregion
+//#region src/i18n-cache/BrowserI18nCache.ts
+/**
+* I18nCache implementation for Browser.
+*/
+var BrowserI18nCache = class extends gt_i18n_internal.I18nCache {
+	constructor(config) {
+		const { htmlTagOptions, ...managerConfig } = config;
+		const localStorageCaches = {};
+		const i18nConfig = (0, gt_i18n_internal.getI18nConfig)();
+		const devHotReloadEnabled = !!config.loadTranslations && i18nConfig.isDevHotReloadEnabled();
+		const projectId = i18nConfig.getProjectId();
+		const loadTranslations = devHotReloadEnabled ? wrapLoaderWithLocalStorage(config.loadTranslations, projectId, localStorageCaches) : config.loadTranslations;
+		super({
+			...managerConfig,
+			loadTranslations
+		});
+		this._devHotReloadJsx = false;
+		this._localStorageCaches = localStorageCaches;
+		this._devHotReloadJsx = devHotReloadEnabled;
+		this.htmlTagOptions = {
+			...DEFAULT_HTML_TAG_OPTIONS,
+			...htmlTagOptions
+		};
+		if (devHotReloadEnabled) this.subscribe("translations-cache-miss", ({ locale, hash, translation }) => {
+			const cache = localStorageCaches[locale];
+			if (cache) cache.write(hash, translation);
+			else localStorageCaches[locale] = new LocalStorageTranslationCache({
+				locale,
+				projectId,
+				init: { [hash]: translation }
+			});
+		});
+	}
+	/**
+	* Whether dev hot reload JSX (Suspense-based <T>) is active
+	*/
+	isDevHotReloadJsx() {
+		return this._devHotReloadJsx;
+	}
+	/**
+	* Get or create a LocalStorageTranslationCache for the given locale.
+	* Instances are lazily created and cached per locale.
+	* Returns undefined if not in development mode.
+	*/
+	getLocalStorageTranslationCache(locale, init) {
+		if (!{}?.DEV) return void 0;
+		if (!this._localStorageCaches[locale]) this._localStorageCaches[locale] = new LocalStorageTranslationCache({
+			locale,
+			projectId: this.config.projectId,
+			init
+		});
+		return this._localStorageCaches[locale];
+	}
+	/**
+	* Update the html tag (lang, dir)
+	*
+	* @deprecated, TODO: we should use a different system for managing this html tag
+	* this should just be for managing translations
+	*/
+	updateHtmlTag(locale, htmlTagOptions) {
+		const htmlLocale = htmlTagOptions?.lang || locale;
+		const i18nConfig = (0, gt_i18n_internal.getI18nConfig)();
+		const canonicalLocale = i18nConfig.resolveCanonicalLocale(htmlLocale);
+		if (!i18nConfig.isValidLocale(canonicalLocale)) {
+			console.warn(createInvalidLocaleWarning(htmlLocale));
+			return;
+		}
+		const localeDirection = htmlTagOptions?.dir || i18nConfig.getLocaleDirection(canonicalLocale);
+		const mergedHtmlTagOptions = {
+			...this.htmlTagOptions,
+			...htmlTagOptions
+		};
+		if (mergedHtmlTagOptions.updateHtmlLangTag) document.documentElement.lang = canonicalLocale;
+		if (mergedHtmlTagOptions.updateHtmlDirTag) document.documentElement.dir = localeDirection;
+	}
+};
+/**
+* Wraps a translation loader to merge localStorage translations in dev mode.
+* On each call: runs the original loader, seeds a LocalStorageTranslationCache
+* with the result (loader wins over stale localStorage), and returns the merged
+* translations — preserving runtime tx() translations from previous sessions.
+*
+* TODO: this should be moved to wrapping in I18nStore
+*/
+function wrapLoaderWithLocalStorage(originalLoader, projectId, localStorageCaches) {
+	return async (locale) => {
+		const loaderTranslations = await originalLoader(locale);
+		localStorageCaches[locale] ||= new LocalStorageTranslationCache({
+			locale,
+			projectId,
+			init: loaderTranslations
+		});
+		return localStorageCaches[locale].getInternalCache();
+	};
+}
+const createInvalidLocaleWarning = (locale) => createDiagnosticMessage({
+	source: "gt-react",
+	severity: "Warning",
+	whatHappened: `Locale "${locale}" is not valid`,
+	fix: "Use a valid BCP 47 locale code or add a custom mapping"
+});
+//#endregion
+//#region src/condition-store/cookies.ts
+/**
+* Minimally parses a cookie value for a given cookie name
+* @param cookieName - The name of the cookie
+* @returns The locale from the cookie or undefined if not found or invalid
+*/
+function getCookieValue({ cookieName }) {
+	if (typeof document === "undefined") return void 0;
+	return document.cookie.split("; ").find((row) => row.startsWith(`${cookieName}=`))?.split("=")[1];
+}
+/**
+* Sets a cookie value for a given cookie name
+* @param cookieName - The name of the cookie
+* @param value - The value to set
+* @returns The value that was set
+*/
+function setCookieValue({ cookieName, value }) {
+	if (typeof document === "undefined") return;
+	document.cookie = `${cookieName}=${value};path=/`;
+}
+//#endregion
+//#region src/condition-store/readBrowserLocale.ts
+function readBrowserLocale(localeCookieName) {
+	const candidates = [];
+	const cookieLocale = getCookieValue({ cookieName: localeCookieName });
+	if (cookieLocale) candidates.push(cookieLocale);
+	const navigatorLocales = navigator?.languages || [];
+	candidates.push(...navigatorLocales);
+	return candidates;
+}
+//#endregion
+//#region src/cookie-names.ts
+/**
+* Cookie name for tracking the user's selected locale.
+*/
+const defaultLocaleCookieName = "generaltranslation.locale";
+/**
+* Cookie name for tracking the user's selected region.
+*/
+const defaultRegionCookieName = "generaltranslation.region";
+/**
+* Cookie name for persisting the enableI18n feature flag.
+*/
+const defaultEnableI18nCookieName = "generaltranslation.enable-i18n";
+/**
+* Cookie name for tracking the locale reset
+* Used by gt-next middleware
+*
+* TODO: remove this cookie when come up with better solution
+*/
+const defaultResetLocaleCookieName = "generaltranslation.locale-reset";
+//#endregion
+//#region src/condition-store/BrowserConditionStore.ts
+/**
+* Condition store implementation for Browser.
+*/
+var BrowserConditionStore = class {
+	constructor(config) {
+		this.getLocale = () => {
+			return getBrowserLocale(this.localeCookieName, this.customGetLocale);
+		};
+		this.setLocale = (locale) => {
+			this.updateLocale(locale);
+			setCookieValue({
+				cookieName: defaultResetLocaleCookieName,
+				value: "true"
+			});
+			this.reload();
+		};
+		this.getRegion = () => {
+			const cookieRegion = getCookieValue({ cookieName: this.regionCookieName });
+			if (cookieRegion) return cookieRegion;
+			return this.customGetRegion?.();
+		};
+		this.setRegion = (region) => {
+			this.updateRegion(region);
+			this.reload();
+		};
+		this.getEnableI18n = () => {
+			const cookieEnableI18n = getCookieValue({ cookieName: this.enableI18nCookieName });
+			if (cookieEnableI18n === void 0) return this.customGetEnableI18n?.() ?? true;
+			return cookieEnableI18n === "true";
+		};
+		this.setEnableI18n = (enableI18n) => {
+			this.updateEnableI18n(enableI18n);
+			this.reload();
+		};
+		this.updateLocale = (locale) => {
+			const i18nConfig = (0, gt_i18n_internal.getI18nConfig)();
+			setCookieValue({
+				cookieName: this.localeCookieName,
+				value: i18nConfig.determineLocale(locale) || i18nConfig.getDefaultLocale()
+			});
+		};
+		this.updateRegion = (region) => {
+			setCookieValue({
+				cookieName: this.regionCookieName,
+				value: region ?? ""
+			});
+		};
+		this.updateEnableI18n = (enableI18n) => {
+			setCookieValue({
+				cookieName: this.enableI18nCookieName,
+				value: enableI18n ? "true" : "false"
+			});
+		};
+		this.reload = () => {
+			const state = {
+				locale: this.getLocale(),
+				region: this.getRegion(),
+				enableI18n: this.getEnableI18n()
+			};
+			this.customReload(state);
+		};
+		this.customReload = config._reload ?? (() => typeof window !== "undefined" ? window.location.reload() : void 0);
+		this.customGetLocale = config._getLocale;
+		this.customGetRegion = config._getRegion;
+		this.customGetEnableI18n = config._getEnableI18n;
+		this.localeCookieName = config.localeCookieName ?? "generaltranslation.locale";
+		this.regionCookieName = config.regionCookieName ?? "generaltranslation.region";
+		this.enableI18nCookieName = config.enableI18nCookieName ?? "generaltranslation.enable-i18n";
+		const i18nConfig = (0, gt_i18n_internal.getI18nConfig)();
+		setCookieValue({
+			cookieName: this.localeCookieName,
+			value: i18nConfig.determineLocale(config.locale) || i18nConfig.getDefaultLocale()
+		});
+		if (config.region !== void 0) setCookieValue({
+			cookieName: this.regionCookieName,
+			value: config.region
+		});
+		this.updateEnableI18n(config.enableI18n ?? true);
+	}
+};
+function getBrowserLocale(cookieName, getLocale) {
+	const candidates = readBrowserLocale(cookieName);
+	if (getLocale) candidates.push(getLocale());
+	const i18nConfig = (0, gt_i18n_internal.getI18nConfig)();
+	return i18nConfig.determineLocale(candidates) || i18nConfig.getDefaultLocale();
+}
+//#endregion
+//#region src/internal.ts
+/**
+* @deprecated gt-react/internal is deprecated. Use public gt-react exports instead.
+*/
+const defaultEnableI18nCookieName$1 = defaultEnableI18nCookieName;
+/**
+* @deprecated gt-react/internal is deprecated. Use public gt-react exports instead.
+*/
+const defaultLocaleCookieName$1 = defaultLocaleCookieName;
+/**
+* @deprecated gt-react/internal is deprecated. Use public gt-react exports instead.
+*/
+const defaultRegionCookieName$1 = defaultRegionCookieName;
+//#endregion
+//#region src/condition-store/singleton-operations.ts
+const { setConditionStore: setReadonlyConditionStore, isConditionStoreInitialized: isReadonlyConditionStoreInitialized } = (0, gt_i18n_internal.createConditionStoreSingleton)("ReadonlyConditionStore is not initialized.");
+const { getConditionStore: getBrowserConditionStore, setConditionStore: setBrowserConditionStore, isConditionStoreInitialized: isBrowserConditionStoreInitialized } = (0, gt_i18n_internal.createConditionStoreSingleton)("BrowserConditionStore is not initialized.");
+//#endregion
+//#region src/condition-store/createBrowserConditionStore.ts
+/**
+* Factory to create a BrowserConditionStore for Singleton
+*
+* This exists so we can keep the locale param as required in the constructor
+*
+* We want the values that we read from the cookies to override as this
+* persists state across page reloads
+*/
+function createOrUpdateBrowserConditionStore(config) {
+	const locale = determineLocale(config);
+	const region = determineRegion(config);
+	const enableI18n = determineEnableI18n(config);
+	if (isBrowserConditionStoreInitialized()) {
+		const conditionStore = getBrowserConditionStore();
+		conditionStore.updateLocale(locale);
+		if (region !== void 0) conditionStore.updateRegion(region);
+		conditionStore.updateEnableI18n(enableI18n);
+		return conditionStore;
+	}
+	const conditionStore = new BrowserConditionStore({
+		...config,
+		localeCookieName: defaultLocaleCookieName$1,
+		regionCookieName: defaultRegionCookieName$1,
+		enableI18nCookieName: defaultEnableI18nCookieName$1,
+		locale,
+		region,
+		enableI18n
+	});
+	setBrowserConditionStore(conditionStore);
+	return conditionStore;
+}
+function determineLocale({ localeCookieName = defaultLocaleCookieName$1, _getLocale: getLocale, locale }) {
+	const candidates = [];
+	candidates.push(...readBrowserLocale(localeCookieName));
+	if (locale) candidates.push(...locale);
+	if (getLocale) candidates.push(getLocale());
+	return resolveLocale(candidates);
+}
+function resolveLocale(candidates) {
+	const i18nConfig = (0, gt_i18n_internal.getI18nConfig)();
+	return i18nConfig.determineLocale(candidates) || i18nConfig.getDefaultLocale();
+}
+function determineRegion({ regionCookieName = defaultRegionCookieName$1, _getRegion: getRegion, region }) {
+	return getCookieValue({ cookieName: regionCookieName }) || getRegion?.() || region;
+}
+function determineEnableI18n({ enableI18n, enableI18nCookieName = defaultEnableI18nCookieName$1, _getEnableI18n: getEnableI18n }) {
+	const cookieEnableI18n = getCookieValue({ cookieName: enableI18nCookieName });
+	if (cookieEnableI18n === void 0) return getEnableI18n?.() ?? enableI18n ?? true;
+	return cookieEnableI18n === "true";
+}
+//#endregion
+//#region src/setup/initializeGTSPA.ts
+/**
+* Initialize GT for an SPA
+* - i18nCache
+* - conditionStore
+* - i18nStore
+*
+* This is SPA for browser runtime
+*/
+async function initializeGTSPA(config) {
+	(0, gt_i18n_internal.setupGTServicesEnabled)(config);
+	(0, _generaltranslation_react_core_pure.initializeI18nConfig)(config, "SPA");
+	(0, _generaltranslation_react_core_pure.setReactI18nCache)(new BrowserI18nCache(config));
+	createOrUpdateBrowserConditionStore(config);
+	(0, _generaltranslation_react_core_pure.setI18nStore)(new _generaltranslation_react_core_pure.I18nStore());
+	await (0, _generaltranslation_react_core_pure.getTranslationsSnapshot)((0, _generaltranslation_react_core_pure.getReadonlyConditionStoreWithFallback)().getLocale());
+}
+//#endregion
+//#region src/hooks/conditions-store.ts
+/**
+* Returns a function that sets the locale
+*/
+function useSetLocale() {
+	const conditionStore = (0, _generaltranslation_react_core_hooks.useConditionStore)();
+	return (0, react.useCallback)((locale) => {
+		conditionStore.setLocale(locale);
+	}, [conditionStore]);
+}
+/**
+* Returns a function that sets the region
+*/
+function useSetRegion() {
+	const conditionStore = (0, _generaltranslation_react_core_hooks.useConditionStore)();
+	return (0, react.useCallback)((region) => {
+		conditionStore.setRegion(region);
+	}, [conditionStore]);
+}
+/**
+* Returns a function that sets the enableI18n flag in the condition store.
+*/
+function useSetEnableI18n() {
+	const conditionStore = (0, _generaltranslation_react_core_hooks.useConditionStore)();
+	return (0, react.useCallback)((enableI18n) => {
+		conditionStore.setEnableI18n(enableI18n);
+	}, [conditionStore]);
+}
+//#endregion
+//#region src/components/useLocaleSelector.ts
+/**
+* Gets the list of properties for using a locale selector.
+* Provides locale management utilities for the application.
+*
+* @param locales an optional list of locales to use for the drop down. These locales must be a subset of the locales provided by the `<GTProvider>` context. When not provided, the list of locales from the `<GTProvider>` context is used.
+*
+* @returns {Object} An object containing locale-related utilities:
+* @returns {string} return.locale - The currently selected locale.
+* @returns {string[]} return.locales - The list of all available locales.
+* @returns {function} return.setLocale - Function to update the current locale.
+* @returns {(locale: string) => LocaleProperties} return.getLocaleProperties - Function to retrieve properties for a given locale.
+*/
+function useLocaleSelector(locales) {
+	return {
+		setLocale: useSetLocale(),
+		...(0, _generaltranslation_react_core_hooks.useInternalLocaleSelector)(locales)
+	};
+}
+//#endregion
+//#region src/components/useRegionSelector.ts
+/**
+* Gets the list of properties for using a region selector.
+* Provides region management utilities for the application.
+*
+* @param {Object} [options] - Optional configuration object.
+* @param {string[]} [options.regions] - An optional array of ISO 3166 region codes to display. If not provided, regions are inferred from supported locales.
+* @param {Object} [options.customMapping] - Optional mapping to override region display names, emojis, or associated locales.
+* @param {boolean} [options.prioritizeCurrentLocaleRegion=true] - If true, the region corresponding to the current locale is prioritized in the list.
+* @param {boolean} [options.sortRegionsAlphabetically=true] - If true, regions are sorted alphabetically by display name.
+*
+* @returns {Object} An object containing region-related utilities:
+* @returns {string | undefined} return.region - The currently selected region code.
+* @returns {function} return.setRegion - Function to update the current region.
+* @returns {string[]} return.regions - The ordered list of available region codes.
+* @returns {Map<string, RegionData>} return.regionData - Map of region codes to their display data (name, emoji, locale).
+* @returns {string} return.locale - The current locale.
+* @returns {function} return.setLocale - Function to update the current locale.
+*/
+function useRegionSelector(options) {
+	return {
+		setRegion: useSetRegion(),
+		setLocale: useSetLocale(),
+		...(0, _generaltranslation_react_core_hooks.useInternalRegionSelector)(options)
+	};
+}
+//#endregion
+//#region src/components/LocaleSelector.tsx
+/**
+* A dropdown component that allows users to select a locale.
+* @param {string[]} [locales] - An optional list of locales to use for the dropdown. If not provided, the list of locales from the `<GTProvider>` context is used.
+* @param {object} [customNames] - (deprecated) An optional object to map locales to custom names. Use `customMapping` instead.
+* @param {CustomMapping} [customMapping] - An optional object to map locales to custom display names, emojis, or other properties.
+* @returns {React.ReactElement | null} The rendered locale dropdown component or null to prevent rendering.
+*/
+function LocaleSelector({ locales: _locales, ...props }) {
+	const { locale, locales, getLocaleProperties, setLocale } = useLocaleSelector(_locales);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_generaltranslation_react_core_components.InternalLocaleSelector, {
+		locale,
+		locales,
+		setLocale,
+		getLocaleProperties,
+		...props
+	});
+}
+//#endregion
+//#region src/components/RegionSelector.tsx
+/**
+* A dropdown component that allows users to select a region.
+* @param {string[]} [regions] - An optional array of ISO 3166 region codes to display. If not provided, regions are inferred from the supported locales in the `<GTProvider>` context.
+* @param {React.ReactNode} [placeholder] - Optional placeholder node to display as the first option when no region is selected.
+* @param {object} [customMapping] - An optional object to map region codes to custom display names, emojis, or associated locales.
+* @param {boolean} [prioritizeCurrentLocaleRegion] - If true, the region corresponding to the current locale is prioritized in the list.
+* @param {boolean} [sortRegionsAlphabetically] - If true, regions are sorted alphabetically by display name.
+* @param {boolean} [asLocaleSelector=false] - If true, selecting a region will also update the locale to the region's associated locale.
+* @returns {React.ReactElement | null} The rendered region dropdown component or null to prevent rendering.
+*
+* @example
+* ```tsx
+* <RegionSelector
+*   regions={['US', 'CA']}
+*   customMapping={{ US: { name: "United States", emoji: "🇺🇸" } }}
+*   placeholder="Select a region"
+* />
+* ```
+*/
+function RegionSelector({ regions: _regions, customMapping, prioritizeCurrentLocaleRegion, sortRegionsAlphabetically, asLocaleSelector = false, ...props }) {
+	const { region, regions, regionData, locale, setRegion, setLocale } = useRegionSelector({
+		regions: _regions,
+		customMapping,
+		prioritizeCurrentLocaleRegion,
+		sortRegionsAlphabetically
+	});
+	const changeRegion = (region) => {
+		if (asLocaleSelector) {
+			const regionLocale = regionData.get(region)?.locale;
+			if (regionLocale && locale !== regionLocale) setLocale(regionLocale);
+		}
+		setRegion(region);
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_generaltranslation_react_core_components.InternalRegionSelector, {
+		region,
+		regions,
+		regionData,
+		setRegion: changeRegion,
+		...props
+	});
+}
+//#endregion
+//#region src/provider/BrowserGTProvider.tsx
+/**
+* Consumes snapshot from server
+* Implementation for client-side only
+*/
+function BrowserGTProvider(props) {
+	const conditionStore = (0, react.useMemo)(() => {
+		return createOrUpdateBrowserConditionStore(props);
+	}, [
+		props.locale,
+		props.region,
+		props.enableI18n,
+		props._reload
+	]);
+	const i18nStoreRef = (0, react.useRef)(null);
+	if (i18nStoreRef.current == null) i18nStoreRef.current = new _generaltranslation_react_core_components.I18nStore();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_generaltranslation_react_core_components.InternalGTProvider, {
+		...props,
+		conditionStore,
+		i18nStore: i18nStoreRef.current
+	});
+}
+//#endregion
+//#region src/index.client.ts
+async function Tx(_props) {
+	throw new Error("Tx is only supported via RSC");
+}
+//#endregion
+Object.defineProperty(exports, "Branch", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.Branch;
+	}
+});
+Object.defineProperty(exports, "Currency", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.Currency;
+	}
+});
+Object.defineProperty(exports, "DateTime", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.DateTime;
+	}
+});
+Object.defineProperty(exports, "Derive", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.Derive;
+	}
+});
+exports.GTProvider = BrowserGTProvider;
+Object.defineProperty(exports, "GtInternalRuntimeTranslateJsx", {
+	enumerable: true,
+	get: function() {
+		return gt_i18n_internal.GtInternalRuntimeTranslateJsx;
+	}
+});
+Object.defineProperty(exports, "GtInternalRuntimeTranslateString", {
+	enumerable: true,
+	get: function() {
+		return gt_i18n_internal.GtInternalRuntimeTranslateString;
+	}
+});
+Object.defineProperty(exports, "GtInternalTranslateJsx", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.GtInternalTranslateJsx;
+	}
+});
+Object.defineProperty(exports, "GtInternalVar", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.GtInternalVar;
+	}
+});
+exports.LocaleSelector = LocaleSelector;
+Object.defineProperty(exports, "Num", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.Num;
+	}
+});
+Object.defineProperty(exports, "Plural", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.Plural;
+	}
+});
+Object.defineProperty(exports, "ReactI18nCache", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.ReactI18nCache;
+	}
+});
+exports.RegionSelector = RegionSelector;
+Object.defineProperty(exports, "RelativeTime", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.RelativeTime;
+	}
+});
+Object.defineProperty(exports, "T", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.T;
+	}
+});
+exports.Tx = Tx;
+Object.defineProperty(exports, "Var", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_components.Var;
+	}
+});
+Object.defineProperty(exports, "createRenderPipeline", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.createRenderPipeline;
+	}
+});
+Object.defineProperty(exports, "declareVar", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.declareVar;
+	}
+});
+Object.defineProperty(exports, "decodeMsg", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.decodeMsg;
+	}
+});
+Object.defineProperty(exports, "decodeOptions", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.decodeOptions;
+	}
+});
+Object.defineProperty(exports, "decodeVars", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.decodeVars;
+	}
+});
+exports.defaultEnableI18nCookieName = defaultEnableI18nCookieName;
+exports.defaultLocaleCookieName = defaultLocaleCookieName;
+exports.defaultRegionCookieName = defaultRegionCookieName;
+Object.defineProperty(exports, "derive", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.derive;
+	}
+});
+Object.defineProperty(exports, "getDefaultLocale", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getDefaultLocale;
+	}
+});
+Object.defineProperty(exports, "getFormatLocales", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getFormatLocales;
+	}
+});
+Object.defineProperty(exports, "getGTClass", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getGTClass;
+	}
+});
+Object.defineProperty(exports, "getLocaleProperties", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getLocaleProperties;
+	}
+});
+Object.defineProperty(exports, "getLocales", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getLocales;
+	}
+});
+Object.defineProperty(exports, "getReactI18nCache", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getReactI18nCache;
+	}
+});
+Object.defineProperty(exports, "getTranslationsSnapshot", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getTranslationsSnapshot;
+	}
+});
+Object.defineProperty(exports, "getVersionId", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.getVersionId;
+	}
+});
+Object.defineProperty(exports, "gtFallback", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.gtFallback;
+	}
+});
+Object.defineProperty(exports, "initializeGT", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.initializeGT;
+	}
+});
+exports.initializeGTSPA = initializeGTSPA;
+Object.defineProperty(exports, "mFallback", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.mFallback;
+	}
+});
+Object.defineProperty(exports, "msg", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.msg;
+	}
+});
+Object.defineProperty(exports, "setReactI18nCache", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.setReactI18nCache;
+	}
+});
+Object.defineProperty(exports, "t", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_pure.t;
+	}
+});
+Object.defineProperty(exports, "useCustomMapping", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useCustomMapping;
+	}
+});
+Object.defineProperty(exports, "useDefaultLocale", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useDefaultLocale;
+	}
+});
+Object.defineProperty(exports, "useEnableI18n", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useEnableI18n;
+	}
+});
+Object.defineProperty(exports, "useFormatLocales", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useFormatLocales;
+	}
+});
+Object.defineProperty(exports, "useGT", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useGT;
+	}
+});
+Object.defineProperty(exports, "useGTClass", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useGTClass;
+	}
+});
+Object.defineProperty(exports, "useLocale", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useLocale;
+	}
+});
+Object.defineProperty(exports, "useLocaleDirection", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useLocaleDirection;
+	}
+});
+Object.defineProperty(exports, "useLocaleProperties", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useLocaleProperties;
+	}
+});
+exports.useLocaleSelector = useLocaleSelector;
+Object.defineProperty(exports, "useLocales", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useLocales;
+	}
+});
+Object.defineProperty(exports, "useMessages", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useMessages;
+	}
+});
+Object.defineProperty(exports, "useRegion", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useRegion;
+	}
+});
+exports.useRegionSelector = useRegionSelector;
+exports.useSetEnableI18n = useSetEnableI18n;
+exports.useSetLocale = useSetLocale;
+exports.useSetRegion = useSetRegion;
+Object.defineProperty(exports, "useTranslations", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useTranslations;
+	}
+});
+Object.defineProperty(exports, "useVersionId", {
+	enumerable: true,
+	get: function() {
+		return _generaltranslation_react_core_hooks.useVersionId;
+	}
+});
+
+//# sourceMappingURL=index.client.cjs.map