@comvi/next 0.1.0

package/dist/server/getI18n.cjs

@@ -0,0 +1,115 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_cache = require("./cache.cjs");
+const require_ensureInitialized = require("./ensureInitialized.cjs");
+const require_getLocale = require("./getLocale.cjs");
+const require_loadTranslations = require("./loadTranslations.cjs");
+let _comvi_core = require("@comvi/core");
+//#region src/server/getI18n.ts
+var virtualNodeToText = (node) => {
+	if (node.type === "text") return node.text;
+	let text = "";
+	for (const child of node.children) {
+		if (typeof child === "string") {
+			text += child;
+			continue;
+		}
+		text += virtualNodeToText(child);
+	}
+	return text;
+};
+var translationResultToString = (result) => {
+	if (typeof result === "string") return result;
+	let text = "";
+	for (const part of result) text += typeof part === "string" ? part : virtualNodeToText(part);
+	return text;
+};
+/**
+* Get i18n for use in Server Components, Server Actions, and Route Handlers
+*
+* This function uses the global i18n instance (configured via setI18n) and
+* automatically reads the locale from the request context (set by setRequestLocale
+* or middleware).
+*
+* @param options - Options object with locale and namespace
+* @returns Object with t() function and hasTranslation() helper
+*
+* @example
+* ```tsx
+* // Server Component - using keys from default namespace
+* import { getI18n } from '@comvi/next/server';
+*
+* export default async function HomePage() {
+*   const { t } = await getI18n();
+*   return (
+*     <div>
+*       <h1>{t('home.title')}</h1>
+*       <p>{t('common.description')}</p>
+*     </div>
+*   );
+* }
+* ```
+*
+* @example
+* ```tsx
+* // Using a different namespace
+* const { t } = await getI18n();
+* // Access admin namespace translations
+* t('title', { ns: 'admin' })        // → "Admin Dashboard"
+* t('roles.admin', { ns: 'admin' })  // → "Administrator"
+* ```
+*
+* @example
+* ```tsx
+* // With explicit locale (for generateMetadata)
+* export async function generateMetadata({ params }: { params: Promise<{ locale: string }> }) {
+*   const { locale } = await params;
+*   const { t } = await getI18n({ locale });
+*   return { title: t('common.title') };
+* }
+* ```
+*
+* @example
+* ```tsx
+* // Check if translation exists (with namespace support)
+* const { t, hasTranslation } = await getI18n();
+* hasTranslation('common.title')              // true (default namespace)
+* hasTranslation('title', { ns: 'admin' })    // true (admin namespace)
+* ```
+*
+* @remarks
+* getI18n auto-loads only the default namespace (or the namespace passed via
+* getI18n({ ns })). If you call t() with a different ns, ensure you preloaded it
+* via loadTranslations(locale, { namespaces: [...] }) in your layout or metadata.
+*/
+async function getI18n(options) {
+	const i18n = require_cache.getI18nInstance();
+	await require_ensureInitialized.ensureInitialized(i18n);
+	let locale = options?.locale;
+	if (!locale) try {
+		locale = await require_getLocale.getLocale();
+	} catch (e) {
+		const err = /* @__PURE__ */ new Error("[comvi/next] Locale not set. Call setRequestLocale(locale) in your layout/page first, or configure middleware.");
+		err.cause = e;
+		throw err;
+	}
+	const defaultNs = options?.ns ?? i18n.getDefaultNamespace();
+	if (!i18n.hasLocale(locale, defaultNs)) await require_loadTranslations.loadTranslations(locale, { namespaces: [defaultNs] });
+	const translate = (0, _comvi_core.createBoundTranslation)(i18n, defaultNs);
+	const t = ((key, params) => {
+		return translationResultToString(translate(key, {
+			...params,
+			locale
+		}));
+	});
+	const hasTranslation = (key, opts) => {
+		const checkLocale = opts?.locale ?? locale;
+		const checkNs = opts?.ns ?? defaultNs;
+		return i18n.hasTranslation(key, checkLocale, checkNs);
+	};
+	return {
+		t,
+		hasTranslation
+	};
+}
+//#endregion
+exports.getI18n = getI18n;

package/dist/server/getI18n.d.ts

@@ -0,0 +1,61 @@
+import { GetI18nOptions, ServerI18n } from './types';
+/**
+ * Get i18n for use in Server Components, Server Actions, and Route Handlers
+ *
+ * This function uses the global i18n instance (configured via setI18n) and
+ * automatically reads the locale from the request context (set by setRequestLocale
+ * or middleware).
+ *
+ * @param options - Options object with locale and namespace
+ * @returns Object with t() function and hasTranslation() helper
+ *
+ * @example
+ * ```tsx
+ * // Server Component - using keys from default namespace
+ * import { getI18n } from '@comvi/next/server';
+ *
+ * export default async function HomePage() {
+ *   const { t } = await getI18n();
+ *   return (
+ *     <div>
+ *       <h1>{t('home.title')}</h1>
+ *       <p>{t('common.description')}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using a different namespace
+ * const { t } = await getI18n();
+ * // Access admin namespace translations
+ * t('title', { ns: 'admin' })        // → "Admin Dashboard"
+ * t('roles.admin', { ns: 'admin' })  // → "Administrator"
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With explicit locale (for generateMetadata)
+ * export async function generateMetadata({ params }: { params: Promise<{ locale: string }> }) {
+ *   const { locale } = await params;
+ *   const { t } = await getI18n({ locale });
+ *   return { title: t('common.title') };
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Check if translation exists (with namespace support)
+ * const { t, hasTranslation } = await getI18n();
+ * hasTranslation('common.title')              // true (default namespace)
+ * hasTranslation('title', { ns: 'admin' })    // true (admin namespace)
+ * ```
+ *
+ * @remarks
+ * getI18n auto-loads only the default namespace (or the namespace passed via
+ * getI18n({ ns })). If you call t() with a different ns, ensure you preloaded it
+ * via loadTranslations(locale, { namespaces: [...] }) in your layout or metadata.
+ */
+export declare function getI18n(options?: GetI18nOptions): Promise<ServerI18n>;
+//# sourceMappingURL=getI18n.d.ts.map

package/dist/server/getI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getI18n.d.ts","sourceRoot":"","sources":["../../src/server/getI18n.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EAGX,MAAM,SAAS,CAAC;AA8BjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAsB,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,CAiD3E"}

package/dist/server/getI18n.js

@@ -0,0 +1,114 @@
+import { getI18nInstance } from "./cache.js";
+import { ensureInitialized } from "./ensureInitialized.js";
+import { getLocale } from "./getLocale.js";
+import { loadTranslations } from "./loadTranslations.js";
+import { createBoundTranslation } from "@comvi/core";
+//#region src/server/getI18n.ts
+var virtualNodeToText = (node) => {
+	if (node.type === "text") return node.text;
+	let text = "";
+	for (const child of node.children) {
+		if (typeof child === "string") {
+			text += child;
+			continue;
+		}
+		text += virtualNodeToText(child);
+	}
+	return text;
+};
+var translationResultToString = (result) => {
+	if (typeof result === "string") return result;
+	let text = "";
+	for (const part of result) text += typeof part === "string" ? part : virtualNodeToText(part);
+	return text;
+};
+/**
+* Get i18n for use in Server Components, Server Actions, and Route Handlers
+*
+* This function uses the global i18n instance (configured via setI18n) and
+* automatically reads the locale from the request context (set by setRequestLocale
+* or middleware).
+*
+* @param options - Options object with locale and namespace
+* @returns Object with t() function and hasTranslation() helper
+*
+* @example
+* ```tsx
+* // Server Component - using keys from default namespace
+* import { getI18n } from '@comvi/next/server';
+*
+* export default async function HomePage() {
+*   const { t } = await getI18n();
+*   return (
+*     <div>
+*       <h1>{t('home.title')}</h1>
+*       <p>{t('common.description')}</p>
+*     </div>
+*   );
+* }
+* ```
+*
+* @example
+* ```tsx
+* // Using a different namespace
+* const { t } = await getI18n();
+* // Access admin namespace translations
+* t('title', { ns: 'admin' })        // → "Admin Dashboard"
+* t('roles.admin', { ns: 'admin' })  // → "Administrator"
+* ```
+*
+* @example
+* ```tsx
+* // With explicit locale (for generateMetadata)
+* export async function generateMetadata({ params }: { params: Promise<{ locale: string }> }) {
+*   const { locale } = await params;
+*   const { t } = await getI18n({ locale });
+*   return { title: t('common.title') };
+* }
+* ```
+*
+* @example
+* ```tsx
+* // Check if translation exists (with namespace support)
+* const { t, hasTranslation } = await getI18n();
+* hasTranslation('common.title')              // true (default namespace)
+* hasTranslation('title', { ns: 'admin' })    // true (admin namespace)
+* ```
+*
+* @remarks
+* getI18n auto-loads only the default namespace (or the namespace passed via
+* getI18n({ ns })). If you call t() with a different ns, ensure you preloaded it
+* via loadTranslations(locale, { namespaces: [...] }) in your layout or metadata.
+*/
+async function getI18n(options) {
+	const i18n = getI18nInstance();
+	await ensureInitialized(i18n);
+	let locale = options?.locale;
+	if (!locale) try {
+		locale = await getLocale();
+	} catch (e) {
+		const err = /* @__PURE__ */ new Error("[comvi/next] Locale not set. Call setRequestLocale(locale) in your layout/page first, or configure middleware.");
+		err.cause = e;
+		throw err;
+	}
+	const defaultNs = options?.ns ?? i18n.getDefaultNamespace();
+	if (!i18n.hasLocale(locale, defaultNs)) await loadTranslations(locale, { namespaces: [defaultNs] });
+	const translate = createBoundTranslation(i18n, defaultNs);
+	const t = ((key, params) => {
+		return translationResultToString(translate(key, {
+			...params,
+			locale
+		}));
+	});
+	const hasTranslation = (key, opts) => {
+		const checkLocale = opts?.locale ?? locale;
+		const checkNs = opts?.ns ?? defaultNs;
+		return i18n.hasTranslation(key, checkLocale, checkNs);
+	};
+	return {
+		t,
+		hasTranslation
+	};
+}
+//#endregion
+export { getI18n };

package/dist/server/getLocale.cjs

@@ -0,0 +1,37 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_cache = require("./cache.cjs");
+let next_headers = require("next/headers");
+//#region src/server/getLocale.ts
+/**
+* Header name set by middleware to pass locale to Server Components
+*/
+var LOCALE_HEADER = "x-comvi-locale";
+/**
+* Get the current request locale
+*
+* This function reads the locale from:
+* 1. Request cache (set by setRequestLocale)
+* 2. x-comvi-locale header (set by middleware)
+*
+* @returns The current locale
+* @throws Error if locale cannot be determined
+*
+* @example
+* ```tsx
+* import { getLocale } from '@comvi/next/server';
+*
+* export default async function Page() {
+*   const locale = await getLocale();
+*   return <p>Current locale: {locale}</p>;
+* }
+* ```
+*/
+async function getLocale() {
+	const cachedLocale = require_cache.getRequestLocaleFromCache();
+	if (cachedLocale) return cachedLocale;
+	const localeFromHeader = (await (0, next_headers.headers)()).get(LOCALE_HEADER);
+	if (localeFromHeader) return localeFromHeader;
+	throw new Error("[comvi/next] Unable to determine locale. Make sure to call setRequestLocale() in your layout/page or configure middleware.");
+}
+//#endregion
+exports.getLocale = getLocale;

package/dist/server/getLocale.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get the current request locale
+ *
+ * This function reads the locale from:
+ * 1. Request cache (set by setRequestLocale)
+ * 2. x-comvi-locale header (set by middleware)
+ *
+ * @returns The current locale
+ * @throws Error if locale cannot be determined
+ *
+ * @example
+ * ```tsx
+ * import { getLocale } from '@comvi/next/server';
+ *
+ * export default async function Page() {
+ *   const locale = await getLocale();
+ *   return <p>Current locale: {locale}</p>;
+ * }
+ * ```
+ */
+export declare function getLocale(): Promise<string>;
+//# sourceMappingURL=getLocale.d.ts.map

package/dist/server/getLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocale.d.ts","sourceRoot":"","sources":["../../src/server/getLocale.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAmBjD"}

package/dist/server/getLocale.js

@@ -0,0 +1,36 @@
+import { getRequestLocaleFromCache } from "./cache.js";
+import { headers } from "next/headers";
+//#region src/server/getLocale.ts
+/**
+* Header name set by middleware to pass locale to Server Components
+*/
+var LOCALE_HEADER = "x-comvi-locale";
+/**
+* Get the current request locale
+*
+* This function reads the locale from:
+* 1. Request cache (set by setRequestLocale)
+* 2. x-comvi-locale header (set by middleware)
+*
+* @returns The current locale
+* @throws Error if locale cannot be determined
+*
+* @example
+* ```tsx
+* import { getLocale } from '@comvi/next/server';
+*
+* export default async function Page() {
+*   const locale = await getLocale();
+*   return <p>Current locale: {locale}</p>;
+* }
+* ```
+*/
+async function getLocale() {
+	const cachedLocale = getRequestLocaleFromCache();
+	if (cachedLocale) return cachedLocale;
+	const localeFromHeader = (await headers()).get(LOCALE_HEADER);
+	if (localeFromHeader) return localeFromHeader;
+	throw new Error("[comvi/next] Unable to determine locale. Make sure to call setRequestLocale() in your layout/page or configure middleware.");
+}
+//#endregion
+export { getLocale };

package/dist/server/loadTranslations.cjs

@@ -0,0 +1,54 @@
+const require_cache = require("./cache.cjs");
+const require_ensureInitialized = require("./ensureInitialized.cjs");
+//#region src/server/loadTranslations.ts
+var toError = (error) => error instanceof Error ? error : new Error(String(error));
+var noLoaderWarnings = /* @__PURE__ */ new WeakSet();
+var NO_LOADER_WARNING_MESSAGE = "[comvi/next] No loader configured. Register one via i18n.registerLoader(...) or createNextI18n(...).use(plugin).";
+var toPlainObject = (value) => {
+	return Object.fromEntries(Object.entries(value));
+};
+var warnNoLoaderConfigured = (i18n) => {
+	if (noLoaderWarnings.has(i18n)) return;
+	noLoaderWarnings.add(i18n);
+	console.warn(NO_LOADER_WARNING_MESSAGE);
+};
+/**
+* Load translations for a locale using the configured i18n loader.
+*
+* If no loader is configured, this function returns already-cached translations
+* for requested namespaces (if any) and logs a warning.
+*
+* @example
+* ```typescript
+* const messages = await loadTranslations(locale);
+* ```
+*
+* @example
+* ```typescript
+* const messages = await loadTranslations(locale, {
+*   namespaces: ["common", "admin"],
+* });
+* ```
+*/
+async function loadTranslations(locale, options = {}) {
+	const i18n = require_cache.getI18nInstance();
+	await require_ensureInitialized.ensureInitialized(i18n);
+	const defaultNs = i18n.getDefaultNamespace();
+	const namespaces = options.namespaces ?? [defaultNs];
+	const hasLoader = Boolean(i18n.getLoader());
+	const result = {};
+	for (const namespace of namespaces) {
+		const cacheKey = `${locale}:${namespace}`;
+		if (!i18n.hasLocale(locale, namespace) && hasLoader) try {
+			await i18n.reloadTranslations(locale, namespace);
+		} catch (error) {
+			const err = toError(error);
+			console.warn(`[comvi/next] Failed to load ${locale}:${namespace}:`, err.message);
+		}
+		if (i18n.hasLocale(locale, namespace)) result[cacheKey] = toPlainObject(i18n.getTranslations(locale, namespace));
+	}
+	if (!hasLoader && Object.keys(result).length === 0) warnNoLoaderConfigured(i18n);
+	return result;
+}
+//#endregion
+exports.loadTranslations = loadTranslations;

package/dist/server/loadTranslations.d.ts

@@ -0,0 +1,34 @@
+import { TranslationValue } from '@comvi/core';
+/**
+ * Options for loadTranslations
+ */
+export interface LoadTranslationsOptions {
+    /**
+     * Namespaces to load. Defaults to default namespace only.
+     */
+    namespaces?: string[];
+}
+/**
+ * Translations result keyed by "locale:namespace"
+ */
+export type TranslationsResult = Record<string, Record<string, TranslationValue>>;
+/**
+ * Load translations for a locale using the configured i18n loader.
+ *
+ * If no loader is configured, this function returns already-cached translations
+ * for requested namespaces (if any) and logs a warning.
+ *
+ * @example
+ * ```typescript
+ * const messages = await loadTranslations(locale);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const messages = await loadTranslations(locale, {
+ *   namespaces: ["common", "admin"],
+ * });
+ * ```
+ */
+export declare function loadTranslations(locale: string, options?: LoadTranslationsOptions): Promise<TranslationsResult>;
+//# sourceMappingURL=loadTranslations.d.ts.map

package/dist/server/loadTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadTranslations.d.ts","sourceRoot":"","sources":["../../src/server/loadTranslations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAI1D;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAyBlF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,kBAAkB,CAAC,CAuC7B"}

package/dist/server/loadTranslations.js

@@ -0,0 +1,54 @@
+import { getI18nInstance } from "./cache.js";
+import { ensureInitialized } from "./ensureInitialized.js";
+//#region src/server/loadTranslations.ts
+var toError = (error) => error instanceof Error ? error : new Error(String(error));
+var noLoaderWarnings = /* @__PURE__ */ new WeakSet();
+var NO_LOADER_WARNING_MESSAGE = "[comvi/next] No loader configured. Register one via i18n.registerLoader(...) or createNextI18n(...).use(plugin).";
+var toPlainObject = (value) => {
+	return Object.fromEntries(Object.entries(value));
+};
+var warnNoLoaderConfigured = (i18n) => {
+	if (noLoaderWarnings.has(i18n)) return;
+	noLoaderWarnings.add(i18n);
+	console.warn(NO_LOADER_WARNING_MESSAGE);
+};
+/**
+* Load translations for a locale using the configured i18n loader.
+*
+* If no loader is configured, this function returns already-cached translations
+* for requested namespaces (if any) and logs a warning.
+*
+* @example
+* ```typescript
+* const messages = await loadTranslations(locale);
+* ```
+*
+* @example
+* ```typescript
+* const messages = await loadTranslations(locale, {
+*   namespaces: ["common", "admin"],
+* });
+* ```
+*/
+async function loadTranslations(locale, options = {}) {
+	const i18n = getI18nInstance();
+	await ensureInitialized(i18n);
+	const defaultNs = i18n.getDefaultNamespace();
+	const namespaces = options.namespaces ?? [defaultNs];
+	const hasLoader = Boolean(i18n.getLoader());
+	const result = {};
+	for (const namespace of namespaces) {
+		const cacheKey = `${locale}:${namespace}`;
+		if (!i18n.hasLocale(locale, namespace) && hasLoader) try {
+			await i18n.reloadTranslations(locale, namespace);
+		} catch (error) {
+			const err = toError(error);
+			console.warn(`[comvi/next] Failed to load ${locale}:${namespace}:`, err.message);
+		}
+		if (i18n.hasLocale(locale, namespace)) result[cacheKey] = toPlainObject(i18n.getTranslations(locale, namespace));
+	}
+	if (!hasLoader && Object.keys(result).length === 0) warnNoLoaderConfigured(i18n);
+	return result;
+}
+//#endregion
+export { loadTranslations };

package/dist/server/setRequestLocale.cjs

@@ -0,0 +1,31 @@
+const require_cache = require("./cache.cjs");
+//#region src/server/setRequestLocale.ts
+/**
+* Enable static rendering for internationalized pages
+*
+* Call this at the top of your layout and page components before
+* using any translation functions. This is required for static
+* rendering with generateStaticParams().
+*
+* @param locale - The locale for this request (typically from params.locale)
+*
+* @example
+* ```tsx
+* // app/[locale]/page.tsx
+* import { setRequestLocale } from '@comvi/next/server';
+*
+* export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+*   const { locale } = await params;
+*   setRequestLocale(locale);
+*
+*   // Now you can use getTranslations()
+*   const t = await getTranslations('HomePage');
+*   return <h1>{t('title')}</h1>;
+* }
+* ```
+*/
+function setRequestLocale(locale) {
+	require_cache.setRequestLocaleInternal(locale);
+}
+//#endregion
+exports.setRequestLocale = setRequestLocale;

package/dist/server/setRequestLocale.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Enable static rendering for internationalized pages
+ *
+ * Call this at the top of your layout and page components before
+ * using any translation functions. This is required for static
+ * rendering with generateStaticParams().
+ *
+ * @param locale - The locale for this request (typically from params.locale)
+ *
+ * @example
+ * ```tsx
+ * // app/[locale]/page.tsx
+ * import { setRequestLocale } from '@comvi/next/server';
+ *
+ * export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+ *   const { locale } = await params;
+ *   setRequestLocale(locale);
+ *
+ *   // Now you can use getTranslations()
+ *   const t = await getTranslations('HomePage');
+ *   return <h1>{t('title')}</h1>;
+ * }
+ * ```
+ */
+export declare function setRequestLocale(locale: string): void;
+//# sourceMappingURL=setRequestLocale.d.ts.map

package/dist/server/setRequestLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setRequestLocale.d.ts","sourceRoot":"","sources":["../../src/server/setRequestLocale.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAErD"}

package/dist/server/setRequestLocale.js

@@ -0,0 +1,31 @@
+import { setRequestLocaleInternal } from "./cache.js";
+//#region src/server/setRequestLocale.ts
+/**
+* Enable static rendering for internationalized pages
+*
+* Call this at the top of your layout and page components before
+* using any translation functions. This is required for static
+* rendering with generateStaticParams().
+*
+* @param locale - The locale for this request (typically from params.locale)
+*
+* @example
+* ```tsx
+* // app/[locale]/page.tsx
+* import { setRequestLocale } from '@comvi/next/server';
+*
+* export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+*   const { locale } = await params;
+*   setRequestLocale(locale);
+*
+*   // Now you can use getTranslations()
+*   const t = await getTranslations('HomePage');
+*   return <h1>{t('title')}</h1>;
+* }
+* ```
+*/
+function setRequestLocale(locale) {
+	setRequestLocaleInternal(locale);
+}
+//#endregion
+export { setRequestLocale };

package/dist/server/types.d.ts

@@ -0,0 +1,43 @@
+import { TranslationParams, NamespacedKeys, Namespaces, NamespacedParamsArg, ParamsArg, PermissiveKey } from '@comvi/core';
+/**
+ * Options for getI18n function
+ */
+export interface GetI18nOptions {
+    /** Explicit locale (for generateMetadata, etc.) - defaults to request locale */
+    locale?: string;
+    /** Default namespace to use (overrides i18n.defaultNs) */
+    ns?: string;
+}
+/**
+ * Translation function type for Server Components (returns string)
+ */
+export interface TranslationFunction {
+    <NS extends Namespaces, K extends NamespacedKeys<NS>>(key: K, ...params: NamespacedParamsArg<NS, K>): string;
+    <K extends import('@comvi/core').DefaultNsKeys>(key: K, ...params: ParamsArg<K>): string;
+    (key: PermissiveKey, params?: TranslationParams): string;
+}
+/**
+ * Options for hasTranslation check
+ */
+export interface HasTranslationOptions {
+    /** Namespace to check (defaults to defaultNamespace) */
+    ns?: string;
+    /** Locale to check (defaults to current locale) */
+    locale?: string;
+}
+/**
+ * Result returned by getI18n
+ */
+export interface ServerI18n {
+    /** Translation function */
+    t: TranslationFunction;
+    /** Check if a translation key exists */
+    hasTranslation: (key: string, options?: HasTranslationOptions) => boolean;
+}
+/**
+ * Internal request store interface
+ */
+export interface RequestStore {
+    locale: string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map