@lingo.dev/compiler 0.1.0

package/build/react/server/useTranslation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslation.mjs","names":["useTranslation: TranslationHook"],"sources":["../../../src/react/server/useTranslation.ts"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { use } from \"react\";\nimport { getServerLocale } from \"@lingo.dev/compiler/virtual/locale/server\";\nimport { fetchTranslationsOnServer } from \"../server-only/translations\";\nimport {\n  renderRichText,\n  type RichTextParams,\n} from \"../shared/render-rich-text\";\nimport { logger } from \"../../utils/logger\";\nimport type { TranslationHook } from \"../types\";\n\n// TODO (AleksandrSl 01/12/2025): Should we add back the cache?\nconst getTranslations = async (hashes: string[]) => {\n  // 1. Resolve locale (framework-specific)\n  const locale = await getServerLocale();\n\n  // 2. Fetch translations (universal)\n  const translations = await fetchTranslationsOnServer(locale, hashes);\n\n  logger.debug(\n    `Server. The translations for locale ${locale} are: ${JSON.stringify(translations)}`,\n  );\n\n  return {\n    locale,\n    translations,\n  };\n};\n\n/**\n * Server-side translation hook\n *\n * Works in Server Components WITHOUT async/await!\n * Uses React's use() hook to unwrap the cached promise.\n *\n * This hook has the SAME signature as the client-side version,\n * making components truly isomorphic.\n *\n * @param hashes - List of translation hashes used in component (injected by compiler)\n * @returns Translation function\n *\n * @example\n * ```tsx\n * // Works in Server Components (no async needed!)\n * export default function ServerPage() {\n *   const t = useTranslation(['hash_abc', 'hash_def']);\n *   return <h1>{t('hash_abc', 'Welcome')}</h1>;\n * }\n *\n * // Also works in Client Components (via conditional exports)\n * 'use client';\n * export default function ClientPage() {\n *   const t = useTranslation(['hash_abc', 'hash_def']);\n *   return <h1>{t('hash_abc', 'Welcome')}</h1>;\n * }\n * ```\n */\nexport const useTranslation: TranslationHook = (hashes: string[]) => {\n  const { locale, translations } = use(getTranslations(hashes));\n  logger.debug(\n    `Server. The translations for locale ${locale} are: ${JSON.stringify(translations)}`,\n  );\n\n  return {\n    t: (\n      hash: string,\n      source: string,\n      params?: RichTextParams,\n    ): string | ReactNode => {\n      const text = translations[hash] || source;\n\n      if (!params) {\n        return text;\n      }\n\n      return renderRichText(text, params, locale);\n    },\n    locale,\n  };\n};\n"],"mappings":";;;;;;;AAYA,MAAM,kBAAkB,OAAO,WAAqB;CAElD,MAAM,SAAS,MAAM,iBAAiB;CAGtC,MAAM,eAAe,MAAM,0BAA0B,QAAQ,OAAO;AAEpE,QAAO,MACL,uCAAuC,OAAO,QAAQ,KAAK,UAAU,aAAa,GACnF;AAED,QAAO;EACL;EACA;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BH,MAAaA,kBAAmC,WAAqB;CACnE,MAAM,EAAE,QAAQ,iBAAiB,IAAI,gBAAgB,OAAO,CAAC;AAC7D,QAAO,MACL,uCAAuC,OAAO,QAAQ,KAAK,UAAU,aAAa,GACnF;AAED,QAAO;EACL,IACE,MACA,QACA,WACuB;GACvB,MAAM,OAAO,aAAa,SAAS;AAEnC,OAAI,CAAC,OACH,QAAO;AAGT,UAAO,eAAe,MAAM,QAAQ,OAAO;;EAE7C;EACD"}

package/build/react/server-only/index.cjs

@@ -0,0 +1,42 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../../utils/logger.cjs');
+const require_translations = require('./translations.cjs');
+const require_render_rich_text = require('../shared/render-rich-text.cjs');
+let _lingo_dev_compiler_virtual_locale_server = require("@lingo.dev/compiler/virtual/locale/server");
+
+//#region src/react/server-only/index.ts
+/**
+* Server-side translation utilities for React Server Components
+* Provides async API for explicit locale passing
+*
+* NOTE: For most cases, use the unified `useTranslation()` hook instead.
+* This module is for advanced use cases where you need explicit control.
+*
+* @module @lingo.dev/compiler-beta/react/server
+*/
+/**
+* Get server-side translations function
+* This is the async alternative to useTranslation() for Server Components
+*
+* For the most common use case, use the unified `useTranslation()` hook instead.
+*
+* The function automatically fetches translations from static files in production
+* and falls back to the development server in development mode.
+*/
+async function getServerTranslations(options) {
+	const locale = options.locale || await (0, _lingo_dev_compiler_virtual_locale_server.getServerLocale)();
+	require_logger.logger.debug(`Async Server. Fetching translations for ${locale}`);
+	const translations = await require_translations.fetchTranslationsOnServer(locale, options.hashes ?? [], { basePath: options.basePath });
+	return {
+		t: (hash, sourceText, params) => {
+			const text = translations[hash] || sourceText;
+			if (!params) return text;
+			return require_render_rich_text.renderRichText(text, params, locale);
+		},
+		locale,
+		translations
+	};
+}
+
+//#endregion
+exports.getServerTranslations = getServerTranslations;

package/build/react/server-only/index.d.cts

@@ -0,0 +1,38 @@
+import { RichTextParams } from "../shared/render-rich-text.cjs";
+import { LocaleCode } from "lingo.dev/spec";
+import { ReactNode } from "react";
+
+//#region src/react/server-only/index.d.ts
+
+/**
+ * Get server-side translations function
+ * This is the async alternative to useTranslation() for Server Components
+ *
+ * For the most common use case, use the unified `useTranslation()` hook instead.
+ *
+ * The function automatically fetches translations from static files in production
+ * and falls back to the development server in development mode.
+ */
+declare function getServerTranslations(options: {
+  /**
+   * Target locale for translations (required)
+   */
+  locale?: LocaleCode;
+  /**
+   * List of translation hashes needed for this component
+   * Typically injected at build time by the Babel plugin
+   */
+  hashes?: string[];
+  /**
+   * Base path for translation files
+   * @default process.cwd()
+   */
+  basePath?: string;
+}): Promise<{
+  t: (hash: string, sourceText: string, params?: RichTextParams) => string | ReactNode;
+  locale: LocaleCode;
+  translations: Record<string, string>;
+}>;
+//#endregion
+export { getServerTranslations };
+//# sourceMappingURL=index.d.cts.map

package/build/react/server-only/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/react/server-only/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBA8BsB,qBAAA;;;;WAIX;;;;;;;;;;;IAaP;iDAIS,4BACG;UACN;gBACM"}

package/build/react/server-only/index.d.mts

@@ -0,0 +1,38 @@
+import { RichTextParams } from "../shared/render-rich-text.mjs";
+import { ReactNode } from "react";
+import { LocaleCode } from "lingo.dev/spec";
+
+//#region src/react/server-only/index.d.ts
+
+/**
+ * Get server-side translations function
+ * This is the async alternative to useTranslation() for Server Components
+ *
+ * For the most common use case, use the unified `useTranslation()` hook instead.
+ *
+ * The function automatically fetches translations from static files in production
+ * and falls back to the development server in development mode.
+ */
+declare function getServerTranslations(options: {
+  /**
+   * Target locale for translations (required)
+   */
+  locale?: LocaleCode;
+  /**
+   * List of translation hashes needed for this component
+   * Typically injected at build time by the Babel plugin
+   */
+  hashes?: string[];
+  /**
+   * Base path for translation files
+   * @default process.cwd()
+   */
+  basePath?: string;
+}): Promise<{
+  t: (hash: string, sourceText: string, params?: RichTextParams) => string | ReactNode;
+  locale: LocaleCode;
+  translations: Record<string, string>;
+}>;
+//#endregion
+export { getServerTranslations };
+//# sourceMappingURL=index.d.mts.map

package/build/react/server-only/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/react/server-only/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBA8BsB,qBAAA;;;;WAIX;;;;;;;;;;;IAaP;iDAIS,4BACG;UACN;gBACM"}

package/build/react/server-only/index.mjs

@@ -0,0 +1,42 @@
+import { logger } from "../../utils/logger.mjs";
+import { fetchTranslationsOnServer } from "./translations.mjs";
+import { renderRichText } from "../shared/render-rich-text.mjs";
+import { getServerLocale } from "@lingo.dev/compiler/virtual/locale/server";
+
+//#region src/react/server-only/index.ts
+/**
+* Server-side translation utilities for React Server Components
+* Provides async API for explicit locale passing
+*
+* NOTE: For most cases, use the unified `useTranslation()` hook instead.
+* This module is for advanced use cases where you need explicit control.
+*
+* @module @lingo.dev/compiler-beta/react/server
+*/
+/**
+* Get server-side translations function
+* This is the async alternative to useTranslation() for Server Components
+*
+* For the most common use case, use the unified `useTranslation()` hook instead.
+*
+* The function automatically fetches translations from static files in production
+* and falls back to the development server in development mode.
+*/
+async function getServerTranslations(options) {
+	const locale = options.locale || await getServerLocale();
+	logger.debug(`Async Server. Fetching translations for ${locale}`);
+	const translations = await fetchTranslationsOnServer(locale, options.hashes ?? [], { basePath: options.basePath });
+	return {
+		t: (hash, sourceText, params) => {
+			const text = translations[hash] || sourceText;
+			if (!params) return text;
+			return renderRichText(text, params, locale);
+		},
+		locale,
+		translations
+	};
+}
+
+//#endregion
+export { getServerTranslations };
+//# sourceMappingURL=index.mjs.map

package/build/react/server-only/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/react/server-only/index.ts"],"sourcesContent":["/**\n * Server-side translation utilities for React Server Components\n * Provides async API for explicit locale passing\n *\n * NOTE: For most cases, use the unified `useTranslation()` hook instead.\n * This module is for advanced use cases where you need explicit control.\n *\n * @module @lingo.dev/compiler-beta/react/server\n */\n\nimport { fetchTranslationsOnServer } from \"./translations\";\nimport {\n  renderRichText,\n  type RichTextParams,\n} from \"../shared/render-rich-text\";\nimport type { ReactNode } from \"react\";\nimport { logger } from \"../../utils/logger\";\n// Keep this import full for replacement during build.\nimport { getServerLocale } from \"@lingo.dev/compiler/virtual/locale/server\";\nimport type { LocaleCode } from \"lingo.dev/spec\";\n\n/**\n * Get server-side translations function\n * This is the async alternative to useTranslation() for Server Components\n *\n * For the most common use case, use the unified `useTranslation()` hook instead.\n *\n * The function automatically fetches translations from static files in production\n * and falls back to the development server in development mode.\n */\nexport async function getServerTranslations(options: {\n  /**\n   * Target locale for translations (required)\n   */\n  locale?: LocaleCode;\n\n  /**\n   * List of translation hashes needed for this component\n   * Typically injected at build time by the Babel plugin\n   */\n  hashes?: string[];\n\n  /**\n   * Base path for translation files\n   * @default process.cwd()\n   */\n  basePath?: string;\n}): Promise<{\n  t: (\n    hash: string,\n    sourceText: string,\n    params?: RichTextParams,\n  ) => string | ReactNode;\n  locale: LocaleCode;\n  translations: Record<string, string>;\n}> {\n  const locale = options.locale || (await getServerLocale());\n\n  logger.debug(`Async Server. Fetching translations for ${locale}`);\n\n  const translations = await fetchTranslationsOnServer(\n    locale,\n    options.hashes ?? [],\n    {\n      basePath: options.basePath,\n    },\n  );\n\n  return {\n    t: (hash: string, sourceText: string, params?: RichTextParams) => {\n      const text = translations[hash] || sourceText;\n\n      if (!params) {\n        return text;\n      }\n\n      return renderRichText(text, params, locale);\n    },\n    locale,\n    translations,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,eAAsB,sBAAsB,SAyBzC;CACD,MAAM,SAAS,QAAQ,UAAW,MAAM,iBAAiB;AAEzD,QAAO,MAAM,2CAA2C,SAAS;CAEjE,MAAM,eAAe,MAAM,0BACzB,QACA,QAAQ,UAAU,EAAE,EACpB,EACE,UAAU,QAAQ,UACnB,CACF;AAED,QAAO;EACL,IAAI,MAAc,YAAoB,WAA4B;GAChE,MAAM,OAAO,aAAa,SAAS;AAEnC,OAAI,CAAC,OACH,QAAO;AAGT,UAAO,eAAe,MAAM,QAAQ,OAAO;;EAE7C;EACA;EACD"}

package/build/react/server-only/translations.cjs

@@ -0,0 +1,85 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../../utils/logger.cjs');
+const require_utils = require('../shared/utils.cjs');
+let _lingo_dev_compiler_virtual_config = require("@lingo.dev/compiler/virtual/config");
+let fs_promises = require("fs/promises");
+let path = require("path");
+
+//#region src/react/server-only/translations.ts
+/**
+* Core translation service - framework-agnostic
+* Handles fetching translations from dev server or filesystem
+*
+* This is the UNIVERSAL pattern that works across all frameworks:
+* Given a locale, fetch the translation dictionary for that locale.
+*
+* @module @lingo.dev/compiler/react/server/translations
+*/
+/**
+* Read translations from filesystem
+* Used in production builds or as fallback in development
+*
+* Tries multiple common locations for translation files:
+* - .lingo/cache/{locale}.json (dev cache)
+* - .next/{locale}.json (Next.js)
+*
+* @param locale - Target locale
+* @param basePath - Base directory to search from (default: cwd)
+* @returns Translation dictionary (hash -> translated text)
+*/
+async function readFromFilesystem(locale, basePath = process.cwd()) {
+	const possiblePaths = [(0, path.join)(basePath, _lingo_dev_compiler_virtual_config.cacheDir, `${locale}.json`), (0, path.join)(basePath, ".next", `${locale}.json`)];
+	for (const filePath of possiblePaths) try {
+		const fileContent = await (0, fs_promises.readFile)(filePath, "utf-8");
+		const translations = JSON.parse(fileContent).entries || {};
+		require_logger.logger.debug(`Loaded ${Object.keys(translations).length} translations from ${filePath}`);
+		return translations;
+	} catch {
+		continue;
+	}
+	if (process.env.NODE_ENV === "development") require_logger.logger.warn(`Translation file not found for locale: ${locale}. Tried: ${possiblePaths.join(", ")}`);
+	return {};
+}
+/**
+* Fetch translations for a given locale
+*
+* This is the CORE UNIVERSAL function that works across all frameworks.
+* It handles the logic of fetching translations from either:
+* - Development server (if running)
+* - Filesystem (production or fallback)
+*
+* Framework-specific code should NOT duplicate this logic.
+* Instead, they should:
+* 1. Resolve the locale (framework-specific: cookies, URL, headers, etc.)
+* 2. Call this function to get translations
+*
+* @example
+* ```typescript
+* // In Next.js locale resolver
+* const locale = await getLocaleFromCookies();
+* const translations = await fetchTranslations(locale);
+* ```
+*
+* @example
+* ```typescript
+* // In React Router loader
+* const locale = getLocaleFromUrl(request.url);
+* const translations = await fetchTranslations(locale);
+* ```
+*/
+async function fetchTranslationsOnServer(locale, hashes, config = {}) {
+	if (process.env.NODE_ENV === "development" && _lingo_dev_compiler_virtual_config.serverUrl) {
+		require_logger.logger.debug(`Server. Fetching translations for ${locale} and ${hashes.join(", ")} from dev server (${_lingo_dev_compiler_virtual_config.serverUrl})`);
+		try {
+			return await require_utils.fetchTranslations(locale, hashes, _lingo_dev_compiler_virtual_config.serverUrl);
+		} catch (error) {
+			require_logger.logger.warn(`Failed to fetch translations from translation server: ${error}.`);
+			return {};
+		}
+	}
+	require_logger.logger.debug(`Reading translations for ${locale} from filesystem`);
+	return await readFromFilesystem(locale, config.basePath);
+}
+
+//#endregion
+exports.fetchTranslationsOnServer = fetchTranslationsOnServer;

package/build/react/server-only/translations.mjs

@@ -0,0 +1,85 @@
+import { logger } from "../../utils/logger.mjs";
+import { fetchTranslations } from "../shared/utils.mjs";
+import { cacheDir, serverUrl } from "@lingo.dev/compiler/virtual/config";
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+//#region src/react/server-only/translations.ts
+/**
+* Core translation service - framework-agnostic
+* Handles fetching translations from dev server or filesystem
+*
+* This is the UNIVERSAL pattern that works across all frameworks:
+* Given a locale, fetch the translation dictionary for that locale.
+*
+* @module @lingo.dev/compiler/react/server/translations
+*/
+/**
+* Read translations from filesystem
+* Used in production builds or as fallback in development
+*
+* Tries multiple common locations for translation files:
+* - .lingo/cache/{locale}.json (dev cache)
+* - .next/{locale}.json (Next.js)
+*
+* @param locale - Target locale
+* @param basePath - Base directory to search from (default: cwd)
+* @returns Translation dictionary (hash -> translated text)
+*/
+async function readFromFilesystem(locale, basePath = process.cwd()) {
+	const possiblePaths = [join(basePath, cacheDir, `${locale}.json`), join(basePath, ".next", `${locale}.json`)];
+	for (const filePath of possiblePaths) try {
+		const fileContent = await readFile(filePath, "utf-8");
+		const translations = JSON.parse(fileContent).entries || {};
+		logger.debug(`Loaded ${Object.keys(translations).length} translations from ${filePath}`);
+		return translations;
+	} catch {
+		continue;
+	}
+	if (process.env.NODE_ENV === "development") logger.warn(`Translation file not found for locale: ${locale}. Tried: ${possiblePaths.join(", ")}`);
+	return {};
+}
+/**
+* Fetch translations for a given locale
+*
+* This is the CORE UNIVERSAL function that works across all frameworks.
+* It handles the logic of fetching translations from either:
+* - Development server (if running)
+* - Filesystem (production or fallback)
+*
+* Framework-specific code should NOT duplicate this logic.
+* Instead, they should:
+* 1. Resolve the locale (framework-specific: cookies, URL, headers, etc.)
+* 2. Call this function to get translations
+*
+* @example
+* ```typescript
+* // In Next.js locale resolver
+* const locale = await getLocaleFromCookies();
+* const translations = await fetchTranslations(locale);
+* ```
+*
+* @example
+* ```typescript
+* // In React Router loader
+* const locale = getLocaleFromUrl(request.url);
+* const translations = await fetchTranslations(locale);
+* ```
+*/
+async function fetchTranslationsOnServer(locale, hashes, config = {}) {
+	if (process.env.NODE_ENV === "development" && serverUrl) {
+		logger.debug(`Server. Fetching translations for ${locale} and ${hashes.join(", ")} from dev server (${serverUrl})`);
+		try {
+			return await fetchTranslations(locale, hashes, serverUrl);
+		} catch (error) {
+			logger.warn(`Failed to fetch translations from translation server: ${error}.`);
+			return {};
+		}
+	}
+	logger.debug(`Reading translations for ${locale} from filesystem`);
+	return await readFromFilesystem(locale, config.basePath);
+}
+
+//#endregion
+export { fetchTranslationsOnServer };
+//# sourceMappingURL=translations.mjs.map

package/build/react/server-only/translations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.mjs","names":["fetchFromDevServer"],"sources":["../../../src/react/server-only/translations.ts"],"sourcesContent":["/**\n * Core translation service - framework-agnostic\n * Handles fetching translations from dev server or filesystem\n *\n * This is the UNIVERSAL pattern that works across all frameworks:\n * Given a locale, fetch the translation dictionary for that locale.\n *\n * @module @lingo.dev/compiler/react/server/translations\n */\n\nimport { readFile } from \"fs/promises\";\nimport { join } from \"path\";\nimport { logger } from \"../../utils/logger\";\nimport { fetchTranslations as fetchFromDevServer } from \"../shared/utils\";\nimport { cacheDir, serverUrl } from \"@lingo.dev/compiler/virtual/config\";\nimport type { LocaleCode } from \"lingo.dev/spec\";\n\n/**\n * Configuration for translation fetching\n */\nexport interface TranslationFetchConfig {\n  /**\n   * Base path for translation files (default: process.cwd())\n   */\n  basePath?: string;\n}\n\n/**\n * Read translations from filesystem\n * Used in production builds or as fallback in development\n *\n * Tries multiple common locations for translation files:\n * - .lingo/cache/{locale}.json (dev cache)\n * - .next/{locale}.json (Next.js)\n *\n * @param locale - Target locale\n * @param basePath - Base directory to search from (default: cwd)\n * @returns Translation dictionary (hash -> translated text)\n */\nasync function readFromFilesystem(\n  locale: LocaleCode,\n  basePath: string = process.cwd(),\n): Promise<Record<string, string>> {\n  // TODO (AleksandrSl 15/12/2025): What should be the correct way here to load translations on server for other frameworks?\n  const possiblePaths = [\n    join(basePath, cacheDir, `${locale}.json`),\n    join(basePath, \".next\", `${locale}.json`),\n  ];\n\n  // Try each path until we find the file\n  for (const filePath of possiblePaths) {\n    try {\n      const fileContent = await readFile(filePath, \"utf-8\");\n      const data = JSON.parse(fileContent);\n      const translations = data.entries || {};\n\n      logger.debug(\n        `Loaded ${Object.keys(translations).length} translations from ${filePath}`,\n      );\n      return translations;\n    } catch {\n      // File doesn't exist at this path, try next one\n      continue;\n    }\n  }\n\n  // No translations found\n  if (process.env.NODE_ENV === \"development\") {\n    logger.warn(\n      `Translation file not found for locale: ${locale}. Tried: ${possiblePaths.join(\", \")}`,\n    );\n  }\n\n  return {};\n}\n\n/**\n * Fetch translations for a given locale\n *\n * This is the CORE UNIVERSAL function that works across all frameworks.\n * It handles the logic of fetching translations from either:\n * - Development server (if running)\n * - Filesystem (production or fallback)\n *\n * Framework-specific code should NOT duplicate this logic.\n * Instead, they should:\n * 1. Resolve the locale (framework-specific: cookies, URL, headers, etc.)\n * 2. Call this function to get translations\n *\n * @example\n * ```typescript\n * // In Next.js locale resolver\n * const locale = await getLocaleFromCookies();\n * const translations = await fetchTranslations(locale);\n * ```\n *\n * @example\n * ```typescript\n * // In React Router loader\n * const locale = getLocaleFromUrl(request.url);\n * const translations = await fetchTranslations(locale);\n * ```\n */\nexport async function fetchTranslationsOnServer(\n  locale: LocaleCode,\n  hashes: string[],\n  config: TranslationFetchConfig = {},\n): Promise<Record<string, string>> {\n  const isDev = process.env.NODE_ENV === \"development\";\n\n  // Development mode: Try dev server first, then filesystem\n  if (isDev && serverUrl) {\n    logger.debug(\n      `Server. Fetching translations for ${locale} and ${hashes.join(\", \")} from dev server (${serverUrl})`,\n    );\n    try {\n      return await fetchFromDevServer(locale, hashes, serverUrl);\n    } catch (error) {\n      logger.warn(\n        `Failed to fetch translations from translation server: ${error}.`,\n      );\n      return {};\n    }\n  }\n\n  logger.debug(`Reading translations for ${locale} from filesystem`);\n  return await readFromFilesystem(locale, config.basePath);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,eAAe,mBACb,QACA,WAAmB,QAAQ,KAAK,EACC;CAEjC,MAAM,gBAAgB,CACpB,KAAK,UAAU,UAAU,GAAG,OAAO,OAAO,EAC1C,KAAK,UAAU,SAAS,GAAG,OAAO,OAAO,CAC1C;AAGD,MAAK,MAAM,YAAY,cACrB,KAAI;EACF,MAAM,cAAc,MAAM,SAAS,UAAU,QAAQ;EAErD,MAAM,eADO,KAAK,MAAM,YAAY,CACV,WAAW,EAAE;AAEvC,SAAO,MACL,UAAU,OAAO,KAAK,aAAa,CAAC,OAAO,qBAAqB,WACjE;AACD,SAAO;SACD;AAEN;;AAKJ,KAAI,QAAQ,IAAI,aAAa,cAC3B,QAAO,KACL,0CAA0C,OAAO,WAAW,cAAc,KAAK,KAAK,GACrF;AAGH,QAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BX,eAAsB,0BACpB,QACA,QACA,SAAiC,EAAE,EACF;AAIjC,KAHc,QAAQ,IAAI,aAAa,iBAG1B,WAAW;AACtB,SAAO,MACL,qCAAqC,OAAO,OAAO,OAAO,KAAK,KAAK,CAAC,oBAAoB,UAAU,GACpG;AACD,MAAI;AACF,UAAO,MAAMA,kBAAmB,QAAQ,QAAQ,UAAU;WACnD,OAAO;AACd,UAAO,KACL,yDAAyD,MAAM,GAChE;AACD,UAAO,EAAE;;;AAIb,QAAO,MAAM,4BAA4B,OAAO,kBAAkB;AAClE,QAAO,MAAM,mBAAmB,QAAQ,OAAO,SAAS"}

package/build/react/shared/LingoContext.cjs

@@ -0,0 +1,14 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+
+//#region src/react/shared/LingoContext.ts
+const LingoContext = (0, react.createContext)(null);
+function useLingoContext() {
+	const context = (0, react.useContext)(LingoContext);
+	if (!context) throw new Error("useLingoContext must be used within LingoProvider");
+	return context;
+}
+
+//#endregion
+exports.LingoContext = LingoContext;
+exports.useLingoContext = useLingoContext;

package/build/react/shared/LingoContext.d.cts

@@ -0,0 +1,41 @@
+import { LocaleCode } from "lingo.dev/spec";
+
+//#region src/react/shared/LingoContext.d.ts
+interface LingoContextType {
+  /**
+   * Source locale (default language)
+   */
+  sourceLocale: LocaleCode;
+  /**
+   * Current locale (e.g., 'en', 'de', 'fr')
+   */
+  locale: LocaleCode;
+  /**
+   * Change the current locale and dynamically load translations
+   */
+  setLocale: (locale: LocaleCode) => Promise<void>;
+  /**
+   * Translation dictionary: hash -> translated text
+   */
+  translations: Record<string, string>;
+  /**
+   * Register a hash as being used in a component
+   * The provider will automatically request missing translations
+   */
+  registerHashes: (hashes: string[]) => void;
+  /**
+   * Whether translations are currently being loaded
+   */
+  isLoading: boolean;
+  /**
+   * Development statistics (only in dev mode)
+   */
+  _devStats?: {
+    pendingCount: number;
+    totalRegisteredCount: number;
+  };
+}
+declare function useLingoContext(): LingoContextType;
+//#endregion
+export { useLingoContext };
+//# sourceMappingURL=LingoContext.d.cts.map

package/build/react/shared/LingoContext.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LingoContext.d.cts","names":[],"sources":["../../../src/react/shared/LingoContext.ts"],"sourcesContent":[],"mappings":";;;UAGU,gBAAA;;AAFuC;;EAWvC,YAAA,EALM,UAKN;EAKY;;;EAKA,MAAA,EAVZ,UAUY;EAwBN;;;sBA7BM,eAAe;;;;gBAKrB;;;;;;;;;;;;;;;;;;iBAwBA,eAAA,CAAA,GAAmB"}

package/build/react/shared/LingoContext.d.mts

@@ -0,0 +1,41 @@
+import { LocaleCode } from "lingo.dev/spec";
+
+//#region src/react/shared/LingoContext.d.ts
+interface LingoContextType {
+  /**
+   * Source locale (default language)
+   */
+  sourceLocale: LocaleCode;
+  /**
+   * Current locale (e.g., 'en', 'de', 'fr')
+   */
+  locale: LocaleCode;
+  /**
+   * Change the current locale and dynamically load translations
+   */
+  setLocale: (locale: LocaleCode) => Promise<void>;
+  /**
+   * Translation dictionary: hash -> translated text
+   */
+  translations: Record<string, string>;
+  /**
+   * Register a hash as being used in a component
+   * The provider will automatically request missing translations
+   */
+  registerHashes: (hashes: string[]) => void;
+  /**
+   * Whether translations are currently being loaded
+   */
+  isLoading: boolean;
+  /**
+   * Development statistics (only in dev mode)
+   */
+  _devStats?: {
+    pendingCount: number;
+    totalRegisteredCount: number;
+  };
+}
+declare function useLingoContext(): LingoContextType;
+//#endregion
+export { useLingoContext };
+//# sourceMappingURL=LingoContext.d.mts.map

package/build/react/shared/LingoContext.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LingoContext.d.mts","names":[],"sources":["../../../src/react/shared/LingoContext.ts"],"sourcesContent":[],"mappings":";;;UAGU,gBAAA;;AAFuC;;EAWvC,YAAA,EALM,UAKN;EAKY;;;EAKA,MAAA,EAVZ,UAUY;EAwBN;;;sBA7BM,eAAe;;;;gBAKrB;;;;;;;;;;;;;;;;;;iBAwBA,eAAA,CAAA,GAAmB"}

package/build/react/shared/LingoContext.mjs

@@ -0,0 +1,13 @@
+import { createContext, useContext } from "react";
+
+//#region src/react/shared/LingoContext.ts
+const LingoContext = createContext(null);
+function useLingoContext() {
+	const context = useContext(LingoContext);
+	if (!context) throw new Error("useLingoContext must be used within LingoProvider");
+	return context;
+}
+
+//#endregion
+export { LingoContext, useLingoContext };
+//# sourceMappingURL=LingoContext.mjs.map

package/build/react/shared/LingoContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LingoContext.mjs","names":[],"sources":["../../../src/react/shared/LingoContext.ts"],"sourcesContent":["import { createContext, useContext } from \"react\";\nimport type { LocaleCode } from \"lingo.dev/spec\";\n\ninterface LingoContextType {\n  /**\n   * Source locale (default language)\n   */\n  sourceLocale: LocaleCode;\n\n  /**\n   * Current locale (e.g., 'en', 'de', 'fr')\n   */\n  locale: LocaleCode;\n\n  /**\n   * Change the current locale and dynamically load translations\n   */\n  setLocale: (locale: LocaleCode) => Promise<void>;\n\n  /**\n   * Translation dictionary: hash -> translated text\n   */\n  translations: Record<string, string>;\n\n  /**\n   * Register a hash as being used in a component\n   * The provider will automatically request missing translations\n   */\n  registerHashes: (hashes: string[]) => void;\n\n  /**\n   * Whether translations are currently being loaded\n   */\n  isLoading: boolean;\n\n  /**\n   * Development statistics (only in dev mode)\n   */\n  _devStats?: {\n    pendingCount: number;\n    totalRegisteredCount: number;\n  };\n}\n\nexport const LingoContext = createContext<LingoContextType | null>(null);\n\nexport function useLingoContext(): LingoContextType {\n  const context = useContext(LingoContext);\n\n  if (!context) {\n    // TODO (AleksandrSl 14/12/2025): Shouldn't throw in production\n    throw new Error(\"useLingoContext must be used within LingoProvider\");\n  }\n\n  return context;\n}\n"],"mappings":";;;AA4CA,MAAa,eAAe,cAAuC,KAAK;AAExE,SAAgB,kBAAoC;CAClD,MAAM,UAAU,WAAW,aAAa;AAExC,KAAI,CAAC,QAEH,OAAM,IAAI,MAAM,oDAAoD;AAGtE,QAAO"}