everything-dev/dist/ui/i18n.cjs

A consolidated product package for building Module Federation apps with oRPC APIs.

Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const require_locale = require('./locale.cjs');
const require_message_catalogs = require('./message-catalogs.cjs');
let _lingui_core = require("@lingui/core");
let _lingui_react = require("@lingui/react");
let react = require("react");
let react_jsx_runtime = require("react/jsx-runtime");

//#region src/ui/i18n.tsx
const SharedLocaleContext = (0, react.createContext)(null);
const browserStores = /* @__PURE__ */ new Map();
function createLocaleStore(initialLocale) {
	let locale = initialLocale;
	const listeners = /* @__PURE__ */ new Set();
	return {
		get: () => locale,
		set: (nextLocale) => {
			if (nextLocale === locale) return;
			locale = nextLocale;
			for (const listener of listeners) listener();
		},
		subscribe: (listener) => {
			listeners.add(listener);
			return () => listeners.delete(listener);
		}
	};
}
function createLocaleRuntime({ locales, defaultLocale, cookieName }) {
	const LocaleContext = (0, react.createContext)(null);
	const getBrowserLocales = () => {
		if (typeof navigator === "undefined") return [];
		if (Array.isArray(navigator.languages)) return navigator.languages;
		return navigator.language ? [navigator.language] : [];
	};
	const detectLocale = (preferredLocale) => require_locale.resolveLocale({
		preferredLocale,
		cookie: typeof document === "undefined" ? "" : document.cookie,
		browserLocales: getBrowserLocales(),
		locales,
		defaultLocale,
		cookieName
	});
	const getStore = (initialLocale) => {
		const initial = require_locale.matchLocale(initialLocale, locales) ?? detectLocale();
		if (typeof window === "undefined") return createLocaleStore(initial);
		const existing = browserStores.get(cookieName);
		if (existing) return existing;
		const store = createLocaleStore(initial);
		browserStores.set(cookieName, store);
		return store;
	};
	function LocaleProvider({ children, messages, initialLocale, preferredLocale, onLocaleChange }) {
		const parent = (0, react.useContext)(SharedLocaleContext);
		const sharedParent = parent?.cookieName === cookieName ? parent : null;
		const resolvedInitial = require_locale.matchLocale(preferredLocale, locales) ?? require_locale.matchLocale(initialLocale, locales) ?? require_locale.matchLocale(sharedParent?.locale, locales);
		const serverLocale = resolvedInitial ?? defaultLocale;
		const store = (0, react.useMemo)(() => getStore(resolvedInitial), []);
		const locale = (0, react.useSyncExternalStore)(store.subscribe, store.get, () => serverLocale);
		const i18n = (0, react.useMemo)(() => (0, _lingui_core.setupI18n)({
			locale,
			messages: { [locale]: messages(locale) }
		}), [locale, messages]);
		(0, react.useEffect)(() => {
			if (sharedParent) return;
			const resolved = require_locale.matchLocale(preferredLocale, locales);
			if (resolved) {
				Reflect.set(document, "cookie", require_locale.serializeLocaleCookie(cookieName, resolved, window.location.protocol === "https:"));
				store.set(resolved);
			}
		}, [
			preferredLocale,
			sharedParent,
			store
		]);
		(0, react.useEffect)(() => {
			if (sharedParent) return;
			const previousLocale = document.documentElement.lang;
			document.documentElement.lang = locale;
			return () => {
				document.documentElement.lang = previousLocale;
			};
		}, [locale, sharedParent]);
		const selectLocale = (0, react.useCallback)(async (nextLocale) => {
			if (!locales.includes(nextLocale)) return;
			if (sharedParent && !onLocaleChange) {
				await sharedParent.selectLocale(nextLocale);
				return;
			}
			if (onLocaleChange) await onLocaleChange(nextLocale);
			if (typeof document !== "undefined") Reflect.set(document, "cookie", require_locale.serializeLocaleCookie(cookieName, nextLocale, typeof window !== "undefined" && window.location.protocol === "https:"));
			store.set(nextLocale);
		}, [
			onLocaleChange,
			sharedParent,
			store
		]);
		const value = (0, react.useMemo)(() => ({
			locale,
			selectLocale
		}), [locale, selectLocale]);
		const sharedValue = (0, react.useMemo)(() => ({
			cookieName,
			locale,
			selectLocale: async (next) => {
				const matched = require_locale.matchLocale(next, locales);
				if (matched) await selectLocale(matched);
			}
		}), [locale, selectLocale]);
		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SharedLocaleContext.Provider, {
			value: sharedValue,
			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LocaleContext.Provider, {
				value,
				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_lingui_react.I18nProvider, {
					i18n,
					children
				})
			})
		});
	}
	function useLocale() {
		const value = (0, react.useContext)(LocaleContext);
		if (!value) throw new Error("useLocale must be used within LocaleProvider");
		return value;
	}
	function useTranslation() {
		const { _ } = (0, _lingui_react.useLingui)();
		return (0, react.useCallback)((id, values) => _(id, values), [_]);
	}
	const getLocale = () => require_locale.matchLocale(browserStores.get(cookieName)?.get(), locales) ?? detectLocale();
	return {
		LocaleProvider,
		useLocale,
		useTranslation,
		detectLocale,
		getLocale
	};
}

//#endregion
Object.defineProperty(exports, 'Trans', {
  enumerable: true,
  get: function () {
    return _lingui_react.Trans;
  }
});
exports.createLocaleRuntime = createLocaleRuntime;
exports.createMessageCatalogs = require_message_catalogs.createMessageCatalogs;
exports.matchLocale = require_locale.matchLocale;
exports.readAcceptLanguage = require_locale.readAcceptLanguage;
exports.readLocaleCookie = require_locale.readLocaleCookie;
exports.resolveLocale = require_locale.resolveLocale;
exports.serializeLocaleCookie = require_locale.serializeLocaleCookie;
//# sourceMappingURL=i18n.cjs.map