@comvi/next 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Comvi (https://comvi.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,256 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="../../.github/assets/header-logo-dark.png">
+    <img alt="Comvi" src="../../.github/assets/header-logo-light.png" width="860">
+  </picture>
+</p>
+
+<h1 align="center">@comvi/next</h1>
+
+<p align="center">Next.js App Router integration for Comvi i18n — SSR, middleware, and locale routing.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@comvi/next"><img src="https://img.shields.io/npm/v/@comvi/next?color=blue" alt="npm"></a>
+  <a href="https://bundlejs.com/?q=%40comvi%2Fnext"><img src="https://deno.bundlejs.com/?q=@comvi/next&badge=&badge-style=flat&badge-raster" alt="Bundle size"></a>
+  <a href="https://github.com/comvi-io/comvi-js/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a>
+</p>
+
+---
+
+`@comvi/next` builds on [`@comvi/react`](../react) with SSR utilities and locale routing for the Next.js App Router. `createNextI18n()` handles i18n setup plus routing config; server-only functions load translations on the server side; client-only entries provide the React provider and locale-aware navigation.
+
+Designed for Next.js 14+ / 15+ with React 18+ / 19+.
+
+📖 **Documentation:** https://comvi.io/docs/i18n/next/
+
+## Why Comvi i18n?
+
+Comvi i18n is a modern, framework-agnostic internationalization library built on three principles: type-safe translations, real ICU MessageFormat, and zero compromises on bundle size or security.
+
+- **Rich text without XSS.** Embed components inside translation strings (`Click <link>here</link>`) — translators see clean markup, you decide what each tag renders to. No raw HTML, no unsafe DOM injection, no splitting a sentence across template fragments.
+- **Real ICU MessageFormat.** Plurals, ordinals, and select all follow locale-correct grammar via `Intl.PluralRules` — Polish, Ukrainian, Arabic, Welsh, and the rest. Same syntax every major TMS (Crowdin, Lokalise, Phrase) already speaks.
+- **Locale-aware formatters built in.** `formatNumber`, `formatDate`, `formatCurrency`, and `formatRelativeTime` follow the active locale via native `Intl`, with reactive updates in every framework binding.
+- **~8 kB gzipped, zero runtime dependencies.** No `eval` or `new Function` anywhere — runs under a strict CSP without `unsafe-eval`. Safe for Chrome extensions, Cloudflare Workers, and locked-down enterprise apps.
+- **Pluggable, not monolithic.** Translation loading (CDN/API), locale detection, and in-context editing are opt-in plugins via `@comvi/plugin-fetch-loader`, `@comvi/plugin-locale-detector`, and `@comvi/plugin-in-context-editor`. You only ship what you use.
+- **Same API across 6 frameworks.** `useI18n()` and `<T>` look the same in [Vue](https://www.npmjs.com/package/@comvi/vue), [React](https://www.npmjs.com/package/@comvi/react), [SolidJS](https://www.npmjs.com/package/@comvi/solid), [Svelte](https://www.npmjs.com/package/@comvi/svelte), [Next.js](https://www.npmjs.com/package/@comvi/next), and [Nuxt](https://www.npmjs.com/package/@comvi/nuxt) — switch frameworks without relearning your i18n layer.
+- **First-class SSR.** `@comvi/next` and `@comvi/nuxt` ship server-side translation loading, locale-routed layouts, and middleware for redirect-on-detect — no flash of untranslated content.
+
+## Why @comvi/next?
+
+- **No client-side translation flash.** `loadTranslations()` loads translations server-side for Server Components — users see complete content on first load, no suspense waterfall for i18n.
+- **Built-in `[locale]` segment routing.** `createNextI18n()` creates routing config for your `[locale]/layout.tsx` setup and pairs it with `createMiddleware()` for automatic locale detection and redirect-on-first-visit.
+- **Server-side cache friendly.** Use `loadTranslations()` in Server Components; Next.js can dedupe underlying `fetch()` calls within a request, while the core loader deduplicates concurrent locale/namespace loads.
+
+## Install
+
+```bash
+npm install @comvi/next
+# Peers: next ^14 || ^15, react ^18 || ^19
+```
+
+## Quick start
+
+```ts
+// src/i18n/config.ts
+import { createNextI18n } from "@comvi/next";
+
+export const nextI18n = createNextI18n({
+  locales: ["en", "uk", "de"],
+  defaultLocale: "en",
+  localePrefix: "as-needed",
+  fallbackLocale: "en",
+});
+
+nextI18n.i18n.registerLoader({
+  en: () => import("./locales/en.json"),
+  uk: () => import("./locales/uk.json"),
+  de: () => import("./locales/de.json"),
+});
+
+export const { i18n, routing } = nextI18n;
+```
+
+```ts
+// src/i18n/server.ts
+import "server-only";
+import { setI18n } from "@comvi/next/server";
+import { i18n } from "./config";
+
+setI18n(i18n);
+```
+
+```tsx
+// src/i18n/ComviProvider.tsx
+"use client";
+
+import { I18nProvider, type MessagesMap } from "@comvi/next/client";
+import { i18n, routing } from "./config";
+
+export function ComviProvider({
+  children,
+  locale,
+  messages,
+}: {
+  children: React.ReactNode;
+  locale: string;
+  messages: MessagesMap;
+}) {
+  return (
+    <I18nProvider i18n={i18n} locale={locale} messages={messages} routing={routing}>
+      {children}
+    </I18nProvider>
+  );
+}
+```
+
+```ts
+// src/middleware.ts
+import { createMiddleware } from "@comvi/next/middleware";
+import { routing } from "./i18n/config";
+
+export default createMiddleware(routing);
+export const config = { matcher: ["/((?!api|_next|.*\\..*).*)"] };
+```
+
+The full setup also includes a `[locale]/layout.tsx` that imports the server registration once, calls `loadTranslations(locale)`, and renders the client wrapper above. See the [documentation](https://comvi.io/docs/i18n/next/) for locale-aware `<Link>`, `useLocalizedRouter`, server/client subpath imports, and the lazy-plugin API.
+
+## Server-side translation loading
+
+`loadTranslations()` is a server-only function that loads translations for a locale using the i18n instance registered with `setI18n(i18n)`. Call it in Server Components or Server Actions, and pass the result to `<I18nProvider>` to hydrate the client without a flash of untranslated content.
+
+```tsx
+// app/[locale]/layout.tsx
+import "@/i18n/server";
+import { loadTranslations } from "@comvi/next/server";
+import { ComviProvider } from "@/i18n/ComviProvider";
+
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode;
+  params: Promise<{ locale: string }>;
+}) {
+  const { locale } = await params;
+  const messages = await loadTranslations(locale);
+
+  return (
+    <html lang={locale}>
+      <body>
+        <ComviProvider locale={locale} messages={messages}>
+          {children}
+        </ComviProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+Next.js deduplicates `fetch()` calls across Server Components within a single request, and the core loader deduplicates concurrent requests for the same locale/namespace.
+
+## Locale routing
+
+Create a `[locale]` dynamic segment in your app directory, and use `createMiddleware()` in `middleware.ts` for locale detection and redirect-on-first-visit.
+
+```tsx
+// middleware.ts
+import { createMiddleware } from "@comvi/next/middleware";
+import { routing } from "@/i18n/config";
+
+export default createMiddleware(routing);
+export const config = { matcher: ["/((?!api|_next|.*\\..*).*)"] };
+```
+
+The middleware extracts locale from the URL path first, then checks cookies and the Accept-Language header in your configured order. On first visit without a stored locale, it detects the user's language and redirects to the localized URL while persisting the choice in a cookie.
+
+For more routing details and custom locale-aware navigation helpers, see the [documentation](https://comvi.io/docs/i18n/next/).
+
+## Rich text with `<T>`
+
+The `<T>` component is inherited from [`@comvi/react`](../react). Embed components in translation strings without raw HTML or unsafe DOM injection.
+
+```json
+{ "help": "Click <link>here</link> for more information." }
+```
+
+```tsx
+import { T } from "@comvi/next/client";
+
+export function Help() {
+  return (
+    <T
+      i18nKey="help"
+      components={{
+        link: <a href="/help" />,
+      }}
+    />
+  );
+}
+```
+
+See the [React README](../react) for the full Rich Text section with tag interpolation examples and validation options.
+
+## ICU MessageFormat — locale-correct grammar, not just singular/plural
+
+ICU MessageFormat handles plurals, ordinals, and select with locale-correct grammar via `Intl.PluralRules` — Comvi i18n inherits the full ICU runtime from the underlying binding.
+
+```tsx
+import { useI18n } from "@comvi/next/client";
+
+function Stats() {
+  const { t } = useI18n();
+  return <p>{t("items", { count: 5 })}</p>;
+}
+```
+
+See the [@comvi/react ICU section](../react#icu-messageformat--locale-correct-grammar-not-just-singularplural) for the full multilingual examples, ordinals, and select.
+
+## Type-safe translation keys
+
+Extend the `TranslationKeys` interface via declaration merging for autocomplete and parameter validation. Type definitions can be generated automatically from the Comvi Platform via `@comvi/cli` or from local JSON files via `@comvi/vite-plugin`.
+
+```typescript
+// src/types/i18n.d.ts
+declare module "@comvi/core" {
+  interface TranslationKeys {
+    welcome: { name: string };
+    greeting: never;
+    "errors:NOT_FOUND": never;
+  }
+}
+```
+
+```tsx
+import { useI18n } from "@comvi/next/client";
+
+export function Welcome() {
+  const { t } = useI18n();
+
+  // ✓ Autocomplete, params required
+  const msg = t("welcome", { name: "Alice" });
+
+  return <h1>{msg}</h1>;
+}
+```
+
+**What TypeScript catches:**
+
+```ts
+// ✗ Expected 2 arguments, but got 1
+t("welcome");
+
+// ✗ Property 'name' is missing in type '{ age: number }'
+t("welcome", { age: 5 });
+
+// ✗ Type 'number' is not assignable to type 'string'
+t("welcome", { name: 42 });
+
+// ✗ Argument of type '"typo"' is not assignable to parameter
+t("typo", { name: "Alice" });
+```
+
+For CDN-delivered translations and visual in-context editing, pair with the [Comvi Platform](https://comvi.io) via [`@comvi/plugin-fetch-loader`](../plugin-fetch-loader) and [`@comvi/plugin-in-context-editor`](../plugin-in-context-editor).
+
+## License
+
+[MIT](https://github.com/comvi-io/comvi-js/blob/main/LICENSE) © Comvi

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#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
+exports.__toESM = __toESM;

package/dist/client/I18nProvider.cjs

@@ -0,0 +1,101 @@
+"use client";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_context = require("../routing/context.cjs");
+let react = require("react");
+react = require_runtime.__toESM(react);
+let _comvi_react = require("@comvi/react");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/client/I18nProvider.tsx
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? react.useLayoutEffect : react.useEffect;
+var isServer = typeof window === "undefined";
+/**
+* I18nProvider for Next.js App Router
+*
+* This provider handles hydration by syncing the server locale with the client
+* i18n instance, preventing hydration mismatches.
+*
+* Translations should be pre-loaded in the i18n instance via the `translation`
+* option in `createI18n()`.
+*
+* @example
+* ```tsx
+* // i18n/index.ts
+* import { createI18n } from '@comvi/next';
+* import { setI18n } from '@comvi/next/server';
+* import { translations } from './translations';
+*
+* export const i18n = createI18n({
+*   locale: 'en',
+*   defaultNs: 'default',
+*   translation: translations, // Pre-loaded translations
+* });
+*
+* setI18n(i18n);
+* ```
+*
+* @example
+* ```tsx
+* // app/[locale]/layout.tsx
+* import { I18nProvider } from '@comvi/next/client';
+* import { i18n } from '@/i18n';
+*
+* export default async function LocaleLayout({
+*   children,
+*   params
+* }: {
+*   children: React.ReactNode;
+*   params: Promise<{ locale: string }>;
+* }) {
+*   const { locale } = await params;
+*
+*   return (
+*     <html lang={locale}>
+*       <body>
+*         <I18nProvider i18n={i18n} locale={locale}>
+*           {children}
+*         </I18nProvider>
+*       </body>
+*     </html>
+*   );
+* }
+* ```
+*/
+function I18nProvider({ children, i18n, locale, messages, autoInit = true, routing, ...props }) {
+	const lastAddedMessagesRef = (0, react.useRef)(void 0);
+	const isFirstRenderRef = (0, react.useRef)(true);
+	if (isServer || isFirstRenderRef.current) {
+		if (i18n.locale !== locale) i18n.locale = locale;
+		if (messages && messages !== lastAddedMessagesRef.current) {
+			i18n.addTranslations(messages);
+			lastAddedMessagesRef.current = messages;
+		}
+		if (!isServer) isFirstRenderRef.current = false;
+	}
+	useIsomorphicLayoutEffect(() => {
+		if (i18n.locale !== locale) i18n.locale = locale;
+		if (messages && messages !== lastAddedMessagesRef.current) {
+			i18n.addTranslations(messages);
+			lastAddedMessagesRef.current = messages;
+		}
+	}, [
+		i18n,
+		locale,
+		messages
+	]);
+	const content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_comvi_react.I18nProvider, {
+		i18n,
+		autoInit,
+		ssrInitialLocale: locale,
+		ssrInitialIsLoading: false,
+		ssrInitialIsInitializing: false,
+		...props,
+		children
+	});
+	return routing ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_context.RoutingProvider, {
+		routing,
+		children: content
+	}) : content;
+}
+I18nProvider.displayName = "I18nProvider";
+//#endregion
+exports.I18nProvider = I18nProvider;

package/dist/client/I18nProvider.d.ts

@@ -0,0 +1,84 @@
+import { I18nProviderProps as ReactI18nProviderProps } from '@comvi/react';
+import { TranslationValue } from '@comvi/core';
+import { RoutingConfig } from '../routing/types';
+/**
+ * Translations result keyed by "locale:namespace"
+ */
+export type MessagesMap = Record<string, Record<string, TranslationValue>>;
+export interface I18nProviderProps extends Omit<ReactI18nProviderProps, "ssrInitialLocale"> {
+    /** Locale passed from server (from params.locale) */
+    locale: string;
+    /**
+     * Pre-loaded messages from loadTranslations().
+     * These will be added to the i18n cache on mount.
+     *
+     * @example
+     * ```tsx
+     * const messages = await loadTranslations(locale);
+     * <I18nProvider i18n={i18n} locale={locale} messages={messages}>
+     * ```
+     */
+    messages?: MessagesMap;
+    /**
+     * Routing configuration for locale prefixing and pathnames.
+     * Pass the `routing` value returned by createNextI18n().
+     */
+    routing?: RoutingConfig;
+}
+/**
+ * I18nProvider for Next.js App Router
+ *
+ * This provider handles hydration by syncing the server locale with the client
+ * i18n instance, preventing hydration mismatches.
+ *
+ * Translations should be pre-loaded in the i18n instance via the `translation`
+ * option in `createI18n()`.
+ *
+ * @example
+ * ```tsx
+ * // i18n/index.ts
+ * import { createI18n } from '@comvi/next';
+ * import { setI18n } from '@comvi/next/server';
+ * import { translations } from './translations';
+ *
+ * export const i18n = createI18n({
+ *   locale: 'en',
+ *   defaultNs: 'default',
+ *   translation: translations, // Pre-loaded translations
+ * });
+ *
+ * setI18n(i18n);
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // app/[locale]/layout.tsx
+ * import { I18nProvider } from '@comvi/next/client';
+ * import { i18n } from '@/i18n';
+ *
+ * export default async function LocaleLayout({
+ *   children,
+ *   params
+ * }: {
+ *   children: React.ReactNode;
+ *   params: Promise<{ locale: string }>;
+ * }) {
+ *   const { locale } = await params;
+ *
+ *   return (
+ *     <html lang={locale}>
+ *       <body>
+ *         <I18nProvider i18n={i18n} locale={locale}>
+ *           {children}
+ *         </I18nProvider>
+ *       </body>
+ *     </html>
+ *   );
+ * }
+ * ```
+ */
+export declare function I18nProvider({ children, i18n, locale, messages, autoInit, routing, ...props }: I18nProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace I18nProvider {
+    var displayName: string;
+}
+//# sourceMappingURL=I18nProvider.d.ts.map

package/dist/client/I18nProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"I18nProvider.d.ts","sourceRoot":"","sources":["../../src/client/I18nProvider.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,IAAI,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E,MAAM,WAAW,iBAAkB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,kBAAkB,CAAC;IACzF,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAC;IAEvB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,QAAe,EACf,OAAO,EACP,GAAG,KAAK,EACT,EAAE,iBAAiB,2CAuDnB;yBA/De,YAAY"}

package/dist/client/I18nProvider.js

@@ -0,0 +1,99 @@
+"use client";
+import { RoutingProvider } from "../routing/context.js";
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { I18nProvider } from "@comvi/react";
+import { jsx } from "react/jsx-runtime";
+//#region src/client/I18nProvider.tsx
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+var isServer = typeof window === "undefined";
+/**
+* I18nProvider for Next.js App Router
+*
+* This provider handles hydration by syncing the server locale with the client
+* i18n instance, preventing hydration mismatches.
+*
+* Translations should be pre-loaded in the i18n instance via the `translation`
+* option in `createI18n()`.
+*
+* @example
+* ```tsx
+* // i18n/index.ts
+* import { createI18n } from '@comvi/next';
+* import { setI18n } from '@comvi/next/server';
+* import { translations } from './translations';
+*
+* export const i18n = createI18n({
+*   locale: 'en',
+*   defaultNs: 'default',
+*   translation: translations, // Pre-loaded translations
+* });
+*
+* setI18n(i18n);
+* ```
+*
+* @example
+* ```tsx
+* // app/[locale]/layout.tsx
+* import { I18nProvider } from '@comvi/next/client';
+* import { i18n } from '@/i18n';
+*
+* export default async function LocaleLayout({
+*   children,
+*   params
+* }: {
+*   children: React.ReactNode;
+*   params: Promise<{ locale: string }>;
+* }) {
+*   const { locale } = await params;
+*
+*   return (
+*     <html lang={locale}>
+*       <body>
+*         <I18nProvider i18n={i18n} locale={locale}>
+*           {children}
+*         </I18nProvider>
+*       </body>
+*     </html>
+*   );
+* }
+* ```
+*/
+function I18nProvider$1({ children, i18n, locale, messages, autoInit = true, routing, ...props }) {
+	const lastAddedMessagesRef = useRef(void 0);
+	const isFirstRenderRef = useRef(true);
+	if (isServer || isFirstRenderRef.current) {
+		if (i18n.locale !== locale) i18n.locale = locale;
+		if (messages && messages !== lastAddedMessagesRef.current) {
+			i18n.addTranslations(messages);
+			lastAddedMessagesRef.current = messages;
+		}
+		if (!isServer) isFirstRenderRef.current = false;
+	}
+	useIsomorphicLayoutEffect(() => {
+		if (i18n.locale !== locale) i18n.locale = locale;
+		if (messages && messages !== lastAddedMessagesRef.current) {
+			i18n.addTranslations(messages);
+			lastAddedMessagesRef.current = messages;
+		}
+	}, [
+		i18n,
+		locale,
+		messages
+	]);
+	const content = /* @__PURE__ */ jsx(I18nProvider, {
+		i18n,
+		autoInit,
+		ssrInitialLocale: locale,
+		ssrInitialIsLoading: false,
+		ssrInitialIsInitializing: false,
+		...props,
+		children
+	});
+	return routing ? /* @__PURE__ */ jsx(RoutingProvider, {
+		routing,
+		children: content
+	}) : content;
+}
+I18nProvider$1.displayName = "I18nProvider";
+//#endregion
+export { I18nProvider$1 as I18nProvider };

package/dist/client/index.d.ts

@@ -0,0 +1,5 @@
+export { useI18n, useI18nContext, T, createI18n } from '@comvi/react';
+export type { UseI18nReturn, TProps } from '@comvi/react';
+export { I18nProvider } from './I18nProvider';
+export type { I18nProviderProps } from './I18nProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAEtE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/client.cjs

@@ -0,0 +1,31 @@
+"use client";
+"use client";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./_virtual/_rolldown/runtime.cjs");
+const require_I18nProvider = require("./client/I18nProvider.cjs");
+let _comvi_react = require("@comvi/react");
+exports.I18nProvider = require_I18nProvider.I18nProvider;
+Object.defineProperty(exports, "T", {
+	enumerable: true,
+	get: function() {
+		return _comvi_react.T;
+	}
+});
+Object.defineProperty(exports, "createI18n", {
+	enumerable: true,
+	get: function() {
+		return _comvi_react.createI18n;
+	}
+});
+Object.defineProperty(exports, "useI18n", {
+	enumerable: true,
+	get: function() {
+		return _comvi_react.useI18n;
+	}
+});
+Object.defineProperty(exports, "useI18nContext", {
+	enumerable: true,
+	get: function() {
+		return _comvi_react.useI18nContext;
+	}
+});

package/dist/client.d.ts

@@ -0,0 +1,5 @@
+export { useI18n, useI18nContext, T, createI18n } from '@comvi/react';
+export type { UseI18nReturn, TProps } from '@comvi/react';
+export { I18nProvider } from './client/I18nProvider';
+export type { I18nProviderProps, MessagesMap } from './client/I18nProvider';
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAEtE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/client.js

@@ -0,0 +1,5 @@
+"use client";
+"use client";
+import { I18nProvider } from "./client/I18nProvider.js";
+import { T, createI18n, useI18n, useI18nContext } from "@comvi/react";
+export { I18nProvider, T, createI18n, useI18n, useI18nContext };