@lingo.dev/react 1.0.1 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,343 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _lingo_dev_spec = require("@lingo.dev/spec");
+let react = require("react");
+let intl_messageformat = require("intl-messageformat");
+intl_messageformat = __toESM(intl_messageformat);
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/format.ts
+/**
+* Locale-aware formatting methods wrapping native Intl APIs.
+* Near-zero bundle cost - each method delegates to built-in browser/Node Intl formatters.
+* All methods are pure functions that take a locale string and return formatted strings.
+*/
+const FILE_SIZE_UNITS = [
+	"B",
+	"KB",
+	"MB",
+	"GB",
+	"TB",
+	"PB"
+];
+/**
+* Creates all formatting methods bound to a specific locale.
+*/
+function createFormatMethods(locale) {
+	return {
+		num: (value, options) => new Intl.NumberFormat(locale, options).format(value),
+		currency: (value, currency, options) => new Intl.NumberFormat(locale, {
+			...options,
+			style: "currency",
+			currency
+		}).format(value),
+		percent: (value, options) => new Intl.NumberFormat(locale, {
+			...options,
+			style: "percent"
+		}).format(value),
+		unit: (value, unit, options) => new Intl.NumberFormat(locale, {
+			...options,
+			style: "unit",
+			unit
+		}).format(value),
+		compact: (value, options) => new Intl.NumberFormat(locale, {
+			...options,
+			notation: "compact"
+		}).format(value),
+		date: (value, options) => new Intl.DateTimeFormat(locale, {
+			dateStyle: "medium",
+			...options
+		}).format(value),
+		time: (value, options) => new Intl.DateTimeFormat(locale, {
+			timeStyle: "short",
+			...options
+		}).format(value),
+		datetime: (value, options) => new Intl.DateTimeFormat(locale, {
+			dateStyle: "medium",
+			timeStyle: "short",
+			...options
+		}).format(value),
+		relative: (value, unit, options) => new Intl.RelativeTimeFormat(locale, options).format(value, unit),
+		list: (items, options) => new Intl.ListFormat(locale, {
+			type: "conjunction",
+			...options
+		}).format(items),
+		displayName: (code, type) => {
+			try {
+				return new Intl.DisplayNames(locale, { type }).of(code);
+			} catch {
+				return;
+			}
+		},
+		sort: (items, options) => {
+			const collator = new Intl.Collator(locale, options);
+			return [...items].sort(collator.compare);
+		},
+		segment: (text, granularity = "grapheme") => [...new Intl.Segmenter(locale, { granularity }).segment(text)].map((s) => s.segment),
+		fileSize: (bytes) => {
+			if (bytes === 0) return `0 ${FILE_SIZE_UNITS[0]}`;
+			const exp = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), FILE_SIZE_UNITS.length - 1);
+			const value = bytes / 1024 ** exp;
+			return `${new Intl.NumberFormat(locale, { maximumFractionDigits: exp === 0 ? 0 : 1 }).format(value)} ${FILE_SIZE_UNITS[exp]}`;
+		}
+	};
+}
+//#endregion
+//#region src/text.ts
+const ICU_COMPLEX = /\{[^}]+,\s*(?:plural|select|selectordinal|number|date|time)\s*[,}]/;
+const formatCache = /* @__PURE__ */ new Map();
+const warnedKeys = /* @__PURE__ */ new Set();
+function warnOnce(id, message, level = "warn") {
+	if (process.env.NODE_ENV === "production") return;
+	if (warnedKeys.has(id)) return;
+	warnedKeys.add(id);
+	console[level](`[lingo] ${message}`);
+}
+function simpleInterpolate(template, values) {
+	return template.replace(/\{(\w+)\}/g, (_, key) => {
+		const val = values[key];
+		return val !== void 0 ? String(val) : `{${key}}`;
+	});
+}
+function getFormatter(template, locale) {
+	const cacheKey = `${locale}\0${template}`;
+	let formatter = formatCache.get(cacheKey);
+	if (!formatter) {
+		formatter = new intl_messageformat.default(template, locale);
+		formatCache.set(cacheKey, formatter);
+	}
+	return formatter;
+}
+/**
+* Looks up a translation by hash key with dev-mode diagnostics.
+* Falls back to source text when translation is missing or empty.
+*/
+function lookupTemplate(source, messages, locale, context) {
+	const key = (0, _lingo_dev_spec.computeKey)(source, context);
+	const raw = messages[key];
+	if (process.env.NODE_ENV !== "production") {
+		if (raw === void 0) warnOnce(`missing:${key}:${locale}`, `Missing translation for "${source}"\n  Key: ${key}\n  Locale: ${locale}\n  → Run \`lingo extract\` to add this string to your locale files`);
+		else if (raw === "") warnOnce(`empty:${key}:${locale}`, `Empty translation for "${source}"\n  Key: ${key}\n  Locale: ${locale}\n  → This key exists in your locale file but has no translation`);
+	}
+	return raw || source;
+}
+/**
+* Resolves a translated string from messages by hash, falling back to source text.
+* Uses simple regex for {placeholder} substitution; loads ICU parser only for complex syntax.
+*/
+function resolveText(source, messages, locale, options) {
+	const template = lookupTemplate(source, messages, locale, options?.context);
+	if (!options?.values) return template;
+	if (!ICU_COMPLEX.test(template)) return simpleInterpolate(template, options.values);
+	try {
+		return getFormatter(template, locale).format(options.values);
+	} catch (error) {
+		if (process.env.NODE_ENV !== "production") {
+			const key = (0, _lingo_dev_spec.computeKey)(source, options?.context);
+			warnOnce(`icu:${key}:${locale}`, `Failed to format "${template}"\n  Key: ${key}\n  Locale: ${locale}\n  Error: ${error instanceof Error ? error.message : String(error)}\n  → Check the ICU MessageFormat syntax in your locale file`, "error");
+		}
+		return template;
+	}
+}
+//#endregion
+//#region src/rich.ts
+const TAG_RE = /<(\w+)>([\s\S]*?)<\/\1>|<(\w+)\s*\/>/g;
+function renderTemplate(template, tags, values) {
+	const parts = [];
+	let lastIndex = 0;
+	let keyCounter = 0;
+	for (const match of template.matchAll(TAG_RE)) {
+		if (match.index > lastIndex) parts.push(simpleInterpolate(template.slice(lastIndex, match.index), values));
+		const tagName = match[1] ?? match[3];
+		const content = match[2];
+		const tagFn = tags[tagName];
+		if (tagFn) {
+			const children = content != null ? renderTemplate(content, tags, values) : null;
+			parts.push((0, react.createElement)(react.Fragment, { key: keyCounter++ }, tagFn(children)));
+		} else parts.push(match[0]);
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < template.length) parts.push(simpleInterpolate(template.slice(lastIndex), values));
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	return (0, react.createElement)(react.Fragment, null, ...parts);
+}
+/**
+* Resolves a translated string with rich text tag interpolation.
+* Parses <tag>children</tag> and <tag/> patterns, mapping them to React components.
+*/
+function resolveRich(source, messages, locale, options) {
+	return renderTemplate(lookupTemplate(source, messages, locale, options?.context), options?.tags ?? {}, options?.values ?? {});
+}
+//#endregion
+//#region src/lingo.ts
+const RTL_LANGS = new Set([
+	"ar",
+	"arc",
+	"dv",
+	"fa",
+	"ha",
+	"he",
+	"khw",
+	"ks",
+	"ku",
+	"ps",
+	"ur",
+	"yi"
+]);
+function fallbackDirection(locale) {
+	const lang = locale.split("-")[0].toLowerCase();
+	return RTL_LANGS.has(lang) ? "rtl" : "ltr";
+}
+function resolveDirection(locale) {
+	try {
+		const direction = new Intl.Locale(locale).textInfo?.direction;
+		if (direction === "rtl" || direction === "ltr") return direction;
+	} catch {}
+	return fallbackDirection(locale);
+}
+function resolveLocaleInfo(locale) {
+	try {
+		const loc = new Intl.Locale(locale).maximize();
+		return {
+			script: loc.script,
+			region: loc.region
+		};
+	} catch {
+		return {
+			script: void 0,
+			region: void 0
+		};
+	}
+}
+/**
+* Creates a `Lingo` object for translating text outside of React context.
+* Used by `@lingo.dev/react-next` for Server Components and internally by `LingoProvider`.
+*
+* @param locale - BCP-47 locale string (e.g., "en", "es", "ar-SA")
+* @param messages - Hash-keyed translations from JSONC locale files
+*
+* @example
+* ```ts
+* const l = createLingo("es", messages);
+* l.text("Hello", { context: "Hero greeting" });
+* l.direction;  // "ltr"
+* l.script;     // "Latn"
+* ```
+*/
+function createLingo(locale, messages = {}) {
+	const direction = resolveDirection(locale);
+	const { script, region } = resolveLocaleInfo(locale);
+	return {
+		locale,
+		direction,
+		script,
+		region,
+		text: (source, options) => resolveText(source, messages, locale, options),
+		rich: (source, options) => resolveRich(source, messages, locale, options),
+		plural: (count, forms, options) => {
+			return resolveText((0, _lingo_dev_spec.buildIcuPlural)(forms), messages, locale, {
+				context: options?.context ?? "",
+				values: { count }
+			});
+		},
+		select: (value, forms, options) => {
+			return resolveText((0, _lingo_dev_spec.buildIcuSelect)(forms), messages, locale, {
+				context: options?.context ?? "",
+				values: { value }
+			});
+		},
+		...createFormatMethods(locale)
+	};
+}
+//#endregion
+//#region src/provider.tsx
+const LingoContext = (0, react.createContext)(null);
+/**
+* Provides locale and translations to all descendant components via `useLingo()`.
+*
+* Nested providers with the **same locale** merge messages (child overrides parent,
+* missing keys fall through). Nested providers with **different locales** are standalone.
+*
+* @example
+* ```tsx
+* // Root layout: shared messages
+* <LingoProvider locale="es" messages={sharedMessages}>
+*   {/* Dashboard: adds route-specific messages *​/}
+*   <LingoProvider locale="es" messages={dashboardMessages}>
+*     <App />
+*   </LingoProvider>
+* </LingoProvider>
+* ```
+*/
+function LingoProvider({ locale, messages = {}, children }) {
+	const parent = (0, react.useContext)(LingoContext);
+	const parentMessages = parent?.messages;
+	const parentLocale = parent?.lingo.locale;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LingoContext, {
+		value: (0, react.useMemo)(() => {
+			const merged = parentMessages && parentLocale === locale ? {
+				...parentMessages,
+				...messages
+			} : messages;
+			return {
+				lingo: createLingo(locale, merged),
+				messages: merged
+			};
+		}, [
+			parentMessages,
+			parentLocale,
+			locale,
+			messages
+		]),
+		children
+	});
+}
+/**
+* Access the `Lingo` translation object from the nearest `LingoProvider`.
+*
+* @throws If called outside a `<LingoProvider>`.
+*
+* @example
+* ```tsx
+* function Greeting() {
+*   const l = useLingo();
+*   return <h1>{l.text("Hello")}</h1>;
+* }
+* ```
+*/
+function useLingo() {
+	const ctx = (0, react.useContext)(LingoContext);
+	if (ctx === null) throw new Error("useLingo() called outside <LingoProvider>. Wrap your component tree with <LingoProvider locale=\"en\"> to fix this.");
+	return ctx.lingo;
+}
+//#endregion
+exports.LingoProvider = LingoProvider;
+Object.defineProperty(exports, "computeKey", {
+	enumerable: true,
+	get: function() {
+		return _lingo_dev_spec.computeKey;
+	}
+});
+exports.createLingo = createLingo;
+exports.useLingo = useLingo;