@comvi/next 0.1.0

package/dist/middleware/createMiddleware.cjs

@@ -0,0 +1,185 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_defineRouting = require("../routing/defineRouting.cjs");
+const require_utils = require("../routing/utils.cjs");
+let next_server = require("next/server");
+//#region src/middleware/createMiddleware.ts
+/**
+* Header name for passing locale to Server Components
+*/
+var LOCALE_HEADER = "x-comvi-locale";
+/**
+* Default detection order
+*/
+var DEFAULT_DETECTION_ORDER = ["cookie", "accept-language"];
+/**
+* Creates i18n middleware for Next.js
+*
+* The middleware handles:
+* - Locale detection from URL, cookie, header, and Accept-Language
+* - Locale persistence via cookie
+* - URL prefix handling based on localePrefix mode
+* - Setting x-comvi-locale header for Server Components
+*
+* @param config - Middleware configuration
+* @returns Next.js middleware function
+*
+* @example
+* ```typescript
+* // middleware.ts - Basic usage
+* import { createMiddleware } from '@comvi/next/middleware';
+* import { routing } from './i18n/routing';
+*
+* export default createMiddleware(routing);
+* ```
+*
+* @example
+* ```typescript
+* // middleware.ts - Custom detection order
+* export default createMiddleware({
+*   ...routing,
+*   localeDetection: {
+*     order: ['header', 'cookie', 'accept-language'],
+*     headerName: 'x-user-locale',
+*     cookieName: 'MY_LOCALE',
+*   },
+* });
+* ```
+*/
+function createMiddleware(config) {
+	const { locales, defaultLocale, localePrefix = "as-needed", localeCookie = "NEXT_LOCALE", detectLocale: customDetector, localeDetection } = config;
+	const detectionOrder = localeDetection?.order ?? DEFAULT_DETECTION_ORDER;
+	const cookieName = localeDetection?.cookieName ?? localeCookie;
+	const cookieSecureConfig = localeDetection?.cookieSecure ?? true;
+	const isDev = process.env.NODE_ENV === "development";
+	const headerName = localeDetection?.headerName;
+	const resolveAcceptLanguage = localeDetection?.resolveAcceptLanguage ?? defaultResolveAcceptLanguage;
+	const routing = {
+		locales,
+		defaultLocale,
+		localePrefix,
+		localeCookie,
+		pathnames: config.pathnames ?? {}
+	};
+	const getPathname = require_defineRouting.createGetPathname(routing);
+	return function middleware(request) {
+		const { pathname } = request.nextUrl;
+		if (shouldSkipPath(pathname)) return next_server.NextResponse.next();
+		const pathLocale = extractLocaleFromPath(pathname, locales);
+		let detectedLocale;
+		if (customDetector) detectedLocale = customDetector(request);
+		if (!detectedLocale && pathLocale) detectedLocale = pathLocale;
+		if (!detectedLocale) for (const source of detectionOrder) {
+			const detected = detectFromSource(request, source, locales, defaultLocale, cookieName, headerName, resolveAcceptLanguage);
+			if (detected) {
+				detectedLocale = detected;
+				break;
+			}
+		}
+		const locale = detectedLocale && locales.includes(detectedLocale) ? detectedLocale : defaultLocale;
+		const requestHeaders = new Headers(request.headers);
+		requestHeaders.set(LOCALE_HEADER, locale);
+		const canonicalPathname = require_utils.getCanonicalPathname(require_utils.stripLocalePrefix(pathname, locales), routing, locale);
+		const publicPathname = getPathname({
+			locale,
+			href: canonicalPathname
+		});
+		let response;
+		if (pathname !== publicPathname) {
+			const url = request.nextUrl.clone();
+			url.pathname = publicPathname;
+			response = next_server.NextResponse.redirect(url);
+		} else {
+			const internalPathname = getInternalPathname(locale, canonicalPathname);
+			const middlewareInit = { request: { headers: requestHeaders } };
+			if (pathname === internalPathname) response = next_server.NextResponse.next(middlewareInit);
+			else {
+				const url = request.nextUrl.clone();
+				url.pathname = internalPathname;
+				response = next_server.NextResponse.rewrite(url, middlewareInit);
+			}
+		}
+		response.headers.set(LOCALE_HEADER, locale);
+		if (request.cookies.get(cookieName)?.value !== locale) response.cookies.set(cookieName, locale, {
+			path: "/",
+			maxAge: 365 * 24 * 60 * 60,
+			sameSite: "lax",
+			secure: isDev ? false : cookieSecureConfig
+		});
+		return response;
+	};
+}
+/**
+* Detect locale from a specific source
+*/
+function detectFromSource(request, source, locales, defaultLocale, cookieName, headerName, resolveAcceptLanguage) {
+	switch (source) {
+		case "cookie": {
+			const cookieValue = request.cookies.get(cookieName)?.value;
+			if (cookieValue && locales.includes(cookieValue)) return cookieValue;
+			return;
+		}
+		case "header": {
+			if (!headerName) return void 0;
+			const headerValue = request.headers.get(headerName);
+			if (headerValue && locales.includes(headerValue)) return headerValue;
+			return;
+		}
+		case "accept-language": {
+			const acceptLanguage = request.headers.get("accept-language");
+			if (!acceptLanguage) return void 0;
+			return resolveAcceptLanguage(acceptLanguage, locales, defaultLocale);
+		}
+		default: return;
+	}
+}
+/**
+* Check if path should be skipped by middleware.
+* Static asset filtering is expected to be handled by Next.js matcher config.
+*/
+function shouldSkipPath(pathname) {
+	const isApiPath = pathname === "/api" || pathname.startsWith("/api/");
+	return pathname.startsWith("/_next") || isApiPath;
+}
+/**
+* Extract locale from URL path
+*/
+function extractLocaleFromPath(pathname, locales) {
+	const firstSegment = pathname.split("/").filter(Boolean)[0];
+	return locales.includes(firstSegment) ? firstSegment : void 0;
+}
+/**
+* Default Accept-Language resolver
+*
+* Handles common cases with a simple parser. For production apps with
+* diverse locales (CJK, regional variants), use @formatjs/intl-localematcher.
+*
+* Matching strategy:
+* 1. Try exact match (e.g., "en-US" matches "en-US")
+* 2. Try base language match (e.g., "en-US" matches "en")
+* 3. Try finding a locale that starts with the language (e.g., "en" matches "en-US")
+*/
+function defaultResolveAcceptLanguage(acceptLanguage, locales, _defaultLocale) {
+	const languages = acceptLanguage.split(",").map((lang) => {
+		const [code, q = "q=1"] = lang.trim().split(";");
+		const quality = parseFloat(q.split("=")[1] || "1");
+		return {
+			code: code.trim(),
+			quality: isNaN(quality) ? 1 : quality
+		};
+	}).filter(({ code, quality }) => code.length > 0 && quality > 0).sort((a, b) => b.quality - a.quality);
+	for (const { code } of languages) {
+		const normalizedCode = code.toLowerCase();
+		const exactMatch = locales.find((locale) => locale.toLowerCase() === normalizedCode);
+		if (exactMatch) return exactMatch;
+		const baseLang = normalizedCode.split("-")[0];
+		const baseMatch = locales.find((locale) => locale.toLowerCase() === baseLang);
+		if (baseMatch) return baseMatch;
+		const prefixMatch = locales.find((locale) => locale.toLowerCase().startsWith(baseLang + "-"));
+		if (prefixMatch) return prefixMatch;
+	}
+}
+function getInternalPathname(locale, canonicalPathname) {
+	return canonicalPathname === "/" ? `/${locale}` : `/${locale}${canonicalPathname}`;
+}
+//#endregion
+exports.createMiddleware = createMiddleware;

package/dist/middleware/createMiddleware.d.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { MiddlewareConfig } from './types';
+/**
+ * Creates i18n middleware for Next.js
+ *
+ * The middleware handles:
+ * - Locale detection from URL, cookie, header, and Accept-Language
+ * - Locale persistence via cookie
+ * - URL prefix handling based on localePrefix mode
+ * - Setting x-comvi-locale header for Server Components
+ *
+ * @param config - Middleware configuration
+ * @returns Next.js middleware function
+ *
+ * @example
+ * ```typescript
+ * // middleware.ts - Basic usage
+ * import { createMiddleware } from '@comvi/next/middleware';
+ * import { routing } from './i18n/routing';
+ *
+ * export default createMiddleware(routing);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // middleware.ts - Custom detection order
+ * export default createMiddleware({
+ *   ...routing,
+ *   localeDetection: {
+ *     order: ['header', 'cookie', 'accept-language'],
+ *     headerName: 'x-user-locale',
+ *     cookieName: 'MY_LOCALE',
+ *   },
+ * });
+ * ```
+ */
+export declare function createMiddleware(config: MiddlewareConfig): (request: NextRequest) => NextResponse;
+//# sourceMappingURL=createMiddleware.d.ts.map

package/dist/middleware/createMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMiddleware.d.ts","sourceRoot":"","sources":["../../src/middleware/createMiddleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,SAAS,CAAC;AAevE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,IA2B5B,SAAS,WAAW,KAAG,YAAY,CA6F/D"}

package/dist/middleware/createMiddleware.js

@@ -0,0 +1,184 @@
+import { createGetPathname } from "../routing/defineRouting.js";
+import { getCanonicalPathname, stripLocalePrefix } from "../routing/utils.js";
+import { NextResponse } from "next/server";
+//#region src/middleware/createMiddleware.ts
+/**
+* Header name for passing locale to Server Components
+*/
+var LOCALE_HEADER = "x-comvi-locale";
+/**
+* Default detection order
+*/
+var DEFAULT_DETECTION_ORDER = ["cookie", "accept-language"];
+/**
+* Creates i18n middleware for Next.js
+*
+* The middleware handles:
+* - Locale detection from URL, cookie, header, and Accept-Language
+* - Locale persistence via cookie
+* - URL prefix handling based on localePrefix mode
+* - Setting x-comvi-locale header for Server Components
+*
+* @param config - Middleware configuration
+* @returns Next.js middleware function
+*
+* @example
+* ```typescript
+* // middleware.ts - Basic usage
+* import { createMiddleware } from '@comvi/next/middleware';
+* import { routing } from './i18n/routing';
+*
+* export default createMiddleware(routing);
+* ```
+*
+* @example
+* ```typescript
+* // middleware.ts - Custom detection order
+* export default createMiddleware({
+*   ...routing,
+*   localeDetection: {
+*     order: ['header', 'cookie', 'accept-language'],
+*     headerName: 'x-user-locale',
+*     cookieName: 'MY_LOCALE',
+*   },
+* });
+* ```
+*/
+function createMiddleware(config) {
+	const { locales, defaultLocale, localePrefix = "as-needed", localeCookie = "NEXT_LOCALE", detectLocale: customDetector, localeDetection } = config;
+	const detectionOrder = localeDetection?.order ?? DEFAULT_DETECTION_ORDER;
+	const cookieName = localeDetection?.cookieName ?? localeCookie;
+	const cookieSecureConfig = localeDetection?.cookieSecure ?? true;
+	const isDev = process.env.NODE_ENV === "development";
+	const headerName = localeDetection?.headerName;
+	const resolveAcceptLanguage = localeDetection?.resolveAcceptLanguage ?? defaultResolveAcceptLanguage;
+	const routing = {
+		locales,
+		defaultLocale,
+		localePrefix,
+		localeCookie,
+		pathnames: config.pathnames ?? {}
+	};
+	const getPathname = createGetPathname(routing);
+	return function middleware(request) {
+		const { pathname } = request.nextUrl;
+		if (shouldSkipPath(pathname)) return NextResponse.next();
+		const pathLocale = extractLocaleFromPath(pathname, locales);
+		let detectedLocale;
+		if (customDetector) detectedLocale = customDetector(request);
+		if (!detectedLocale && pathLocale) detectedLocale = pathLocale;
+		if (!detectedLocale) for (const source of detectionOrder) {
+			const detected = detectFromSource(request, source, locales, defaultLocale, cookieName, headerName, resolveAcceptLanguage);
+			if (detected) {
+				detectedLocale = detected;
+				break;
+			}
+		}
+		const locale = detectedLocale && locales.includes(detectedLocale) ? detectedLocale : defaultLocale;
+		const requestHeaders = new Headers(request.headers);
+		requestHeaders.set(LOCALE_HEADER, locale);
+		const canonicalPathname = getCanonicalPathname(stripLocalePrefix(pathname, locales), routing, locale);
+		const publicPathname = getPathname({
+			locale,
+			href: canonicalPathname
+		});
+		let response;
+		if (pathname !== publicPathname) {
+			const url = request.nextUrl.clone();
+			url.pathname = publicPathname;
+			response = NextResponse.redirect(url);
+		} else {
+			const internalPathname = getInternalPathname(locale, canonicalPathname);
+			const middlewareInit = { request: { headers: requestHeaders } };
+			if (pathname === internalPathname) response = NextResponse.next(middlewareInit);
+			else {
+				const url = request.nextUrl.clone();
+				url.pathname = internalPathname;
+				response = NextResponse.rewrite(url, middlewareInit);
+			}
+		}
+		response.headers.set(LOCALE_HEADER, locale);
+		if (request.cookies.get(cookieName)?.value !== locale) response.cookies.set(cookieName, locale, {
+			path: "/",
+			maxAge: 365 * 24 * 60 * 60,
+			sameSite: "lax",
+			secure: isDev ? false : cookieSecureConfig
+		});
+		return response;
+	};
+}
+/**
+* Detect locale from a specific source
+*/
+function detectFromSource(request, source, locales, defaultLocale, cookieName, headerName, resolveAcceptLanguage) {
+	switch (source) {
+		case "cookie": {
+			const cookieValue = request.cookies.get(cookieName)?.value;
+			if (cookieValue && locales.includes(cookieValue)) return cookieValue;
+			return;
+		}
+		case "header": {
+			if (!headerName) return void 0;
+			const headerValue = request.headers.get(headerName);
+			if (headerValue && locales.includes(headerValue)) return headerValue;
+			return;
+		}
+		case "accept-language": {
+			const acceptLanguage = request.headers.get("accept-language");
+			if (!acceptLanguage) return void 0;
+			return resolveAcceptLanguage(acceptLanguage, locales, defaultLocale);
+		}
+		default: return;
+	}
+}
+/**
+* Check if path should be skipped by middleware.
+* Static asset filtering is expected to be handled by Next.js matcher config.
+*/
+function shouldSkipPath(pathname) {
+	const isApiPath = pathname === "/api" || pathname.startsWith("/api/");
+	return pathname.startsWith("/_next") || isApiPath;
+}
+/**
+* Extract locale from URL path
+*/
+function extractLocaleFromPath(pathname, locales) {
+	const firstSegment = pathname.split("/").filter(Boolean)[0];
+	return locales.includes(firstSegment) ? firstSegment : void 0;
+}
+/**
+* Default Accept-Language resolver
+*
+* Handles common cases with a simple parser. For production apps with
+* diverse locales (CJK, regional variants), use @formatjs/intl-localematcher.
+*
+* Matching strategy:
+* 1. Try exact match (e.g., "en-US" matches "en-US")
+* 2. Try base language match (e.g., "en-US" matches "en")
+* 3. Try finding a locale that starts with the language (e.g., "en" matches "en-US")
+*/
+function defaultResolveAcceptLanguage(acceptLanguage, locales, _defaultLocale) {
+	const languages = acceptLanguage.split(",").map((lang) => {
+		const [code, q = "q=1"] = lang.trim().split(";");
+		const quality = parseFloat(q.split("=")[1] || "1");
+		return {
+			code: code.trim(),
+			quality: isNaN(quality) ? 1 : quality
+		};
+	}).filter(({ code, quality }) => code.length > 0 && quality > 0).sort((a, b) => b.quality - a.quality);
+	for (const { code } of languages) {
+		const normalizedCode = code.toLowerCase();
+		const exactMatch = locales.find((locale) => locale.toLowerCase() === normalizedCode);
+		if (exactMatch) return exactMatch;
+		const baseLang = normalizedCode.split("-")[0];
+		const baseMatch = locales.find((locale) => locale.toLowerCase() === baseLang);
+		if (baseMatch) return baseMatch;
+		const prefixMatch = locales.find((locale) => locale.toLowerCase().startsWith(baseLang + "-"));
+		if (prefixMatch) return prefixMatch;
+	}
+}
+function getInternalPathname(locale, canonicalPathname) {
+	return canonicalPathname === "/" ? `/${locale}` : `/${locale}${canonicalPathname}`;
+}
+//#endregion
+export { createMiddleware };

package/dist/middleware/types.d.ts

@@ -0,0 +1,87 @@
+import { NextRequest } from 'next/server';
+import { RoutingConfig } from '../routing/types';
+/**
+ * Locale detection source types
+ */
+export type LocaleDetectionSource = "cookie" | "header" | "accept-language";
+/**
+ * Function type for custom Accept-Language resolution
+ *
+ * @param acceptLanguage - The Accept-Language header value
+ * @param locales - Array of supported locales
+ * @param defaultLocale - The default locale to fall back to
+ * @returns The matched locale or undefined
+ *
+ * @example Using @formatjs/intl-localematcher (recommended for production)
+ * ```typescript
+ * import Negotiator from 'negotiator';
+ * import { match } from '@formatjs/intl-localematcher';
+ *
+ * const resolveAcceptLanguage = (header, locales, defaultLocale) => {
+ *   try {
+ *     const languages = new Negotiator({
+ *       headers: { 'accept-language': header }
+ *     }).languages();
+ *     return match(languages, [...locales], defaultLocale);
+ *   } catch {
+ *     return undefined;
+ *   }
+ * };
+ * ```
+ */
+export type ResolveAcceptLanguage = (acceptLanguage: string, locales: readonly string[], defaultLocale: string) => string | undefined;
+/**
+ * Configuration for locale detection
+ */
+export interface LocaleDetectionConfig {
+    /**
+     * Detection order (URL path is always checked first)
+     * @default ['cookie', 'accept-language']
+     */
+    order?: LocaleDetectionSource[];
+    /**
+     * Cookie name for storing locale preference
+     * @default 'NEXT_LOCALE'
+     */
+    cookieName?: string;
+    /**
+     * Set the Secure flag on the locale cookie.
+     * When true, the cookie is only sent over HTTPS.
+     * Automatically disabled in development (NODE_ENV=development) regardless of this setting.
+     * @default true
+     */
+    cookieSecure?: boolean;
+    /**
+     * Custom header name to read locale from
+     * Useful when you have a proxy that sets locale header
+     * @default undefined (not checked unless in order)
+     */
+    headerName?: string;
+    /**
+     * Custom Accept-Language resolution function (pluggable)
+     *
+     * By default, uses a simple parser that handles common cases.
+     * For production apps with diverse locales (especially CJK languages),
+     * consider using @formatjs/intl-localematcher for RFC-compliant matching.
+     *
+     * @default Built-in simple parser
+     */
+    resolveAcceptLanguage?: ResolveAcceptLanguage;
+}
+/**
+ * Configuration for i18n middleware
+ */
+export interface MiddlewareConfig extends RoutingConfig {
+    /**
+     * Custom locale detection logic (optional)
+     * If provided, this function is called first to detect locale
+     * Return undefined to fall back to default detection
+     */
+    detectLocale?: (request: NextRequest) => string | undefined;
+    /**
+     * Locale detection configuration
+     * Allows customizing detection sources and their order
+     */
+    localeDetection?: LocaleDetectionConfig;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/middleware/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/middleware/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,GAAG,iBAAiB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAClC,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,aAAa,EAAE,MAAM,KAClB,MAAM,GAAG,SAAS,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,KAAK,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAEhC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;OAQG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,MAAM,GAAG,SAAS,CAAC;IAE5D;;;OAGG;IACH,eAAe,CAAC,EAAE,qBAAqB,CAAC;CACzC"}

package/dist/middleware.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_createMiddleware = require("./middleware/createMiddleware.cjs");
+exports.createMiddleware = require_createMiddleware.createMiddleware;

package/dist/middleware.d.ts

@@ -0,0 +1,3 @@
+export { createMiddleware } from './middleware/createMiddleware';
+export type { MiddlewareConfig, LocaleDetectionConfig, LocaleDetectionSource, ResolveAcceptLanguage, } from './middleware/types';
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC"}

package/dist/middleware.js

@@ -0,0 +1,2 @@
+import { createMiddleware } from "./middleware/createMiddleware.js";
+export { createMiddleware };

package/dist/navigation.cjs

@@ -0,0 +1,8 @@
+"use client";
+"use client";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_Link = require("./routing/Link.cjs");
+const require_hooks = require("./routing/hooks.cjs");
+exports.Link = require_Link.Link;
+exports.useLocalizedRouter = require_hooks.useLocalizedRouter;
+exports.usePathname = require_hooks.usePathname;

package/dist/navigation.d.ts

@@ -0,0 +1,5 @@
+export { Link } from './routing/Link';
+export { usePathname, useLocalizedRouter } from './routing/hooks';
+export type { LocalizedLinkProps } from './routing/Link';
+export type { LocalizedRouter } from './routing/hooks';
+//# sourceMappingURL=navigation.d.ts.map

package/dist/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../src/navigation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAClE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/navigation.js

@@ -0,0 +1,5 @@
+"use client";
+"use client";
+import { Link } from "./routing/Link.js";
+import { useLocalizedRouter, usePathname } from "./routing/hooks.js";
+export { Link, useLocalizedRouter, usePathname };

package/dist/routing/Link.cjs

@@ -0,0 +1,42 @@
+"use client";
+"use client";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_context = require("./context.cjs");
+const require_utils = require("./utils.cjs");
+let react = require("react");
+react = require_runtime.__toESM(react);
+let _comvi_react = require("@comvi/react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let next_link = require("next/link");
+next_link = require_runtime.__toESM(next_link);
+//#region src/routing/Link.tsx
+/**
+* Localized Link component that adds locale prefix based on routing config
+*
+* This component wraps Next.js Link and prepends the current locale
+* using localePrefix/pathnames rules from the routing configuration.
+*
+* @example
+* ```tsx
+* import { Link } from '@comvi/next/navigation';
+*
+* // Uses current locale
+* <Link href="/about">About</Link>
+*
+* // Specify different locale
+* <Link href="/about" locale="de">German About</Link>
+* ```
+*/
+var Link = (0, react.forwardRef)(function Link({ href, locale: targetLocale, ...props }, ref) {
+	const { locale: currentLocale } = (0, _comvi_react.useI18n)();
+	const locale = targetLocale ?? currentLocale;
+	const routing = require_context.useRoutingConfig();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(next_link.default, {
+		ref,
+		href: typeof href === "string" ? require_utils.localizeHref(href, locale, routing ?? void 0) : require_utils.localizeUrlObject(href, locale, routing ?? void 0),
+		...props
+	});
+});
+Link.displayName = "LocalizedLink";
+//#endregion
+exports.Link = Link;

package/dist/routing/Link.d.ts

@@ -0,0 +1,25 @@
+import { default as NextLink } from 'next/link';
+import { default as React, ComponentProps } from 'react';
+export interface LocalizedLinkProps extends Omit<ComponentProps<typeof NextLink>, "locale"> {
+    /** Target locale (defaults to current locale) */
+    locale?: string;
+}
+/**
+ * Localized Link component that adds locale prefix based on routing config
+ *
+ * This component wraps Next.js Link and prepends the current locale
+ * using localePrefix/pathnames rules from the routing configuration.
+ *
+ * @example
+ * ```tsx
+ * import { Link } from '@comvi/next/navigation';
+ *
+ * // Uses current locale
+ * <Link href="/about">About</Link>
+ *
+ * // Specify different locale
+ * <Link href="/about" locale="de">German About</Link>
+ * ```
+ */
+export declare const Link: React.ForwardRefExoticComponent<Omit<LocalizedLinkProps, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+//# sourceMappingURL=Link.d.ts.map

package/dist/routing/Link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../src/routing/Link.tsx"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,WAAW,CAAC;AAEjC,OAAO,KAAqB,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAI5C,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,cAAc,CAAC,OAAO,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACzF,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,2GAef,CAAC"}

package/dist/routing/Link.js

@@ -0,0 +1,39 @@
+"use client";
+"use client";
+import { useRoutingConfig } from "./context.js";
+import { localizeHref, localizeUrlObject } from "./utils.js";
+import { forwardRef } from "react";
+import { useI18n } from "@comvi/react";
+import { jsx } from "react/jsx-runtime";
+import NextLink from "next/link";
+//#region src/routing/Link.tsx
+/**
+* Localized Link component that adds locale prefix based on routing config
+*
+* This component wraps Next.js Link and prepends the current locale
+* using localePrefix/pathnames rules from the routing configuration.
+*
+* @example
+* ```tsx
+* import { Link } from '@comvi/next/navigation';
+*
+* // Uses current locale
+* <Link href="/about">About</Link>
+*
+* // Specify different locale
+* <Link href="/about" locale="de">German About</Link>
+* ```
+*/
+var Link = forwardRef(function Link({ href, locale: targetLocale, ...props }, ref) {
+	const { locale: currentLocale } = useI18n();
+	const locale = targetLocale ?? currentLocale;
+	const routing = useRoutingConfig();
+	return /* @__PURE__ */ jsx(NextLink, {
+		ref,
+		href: typeof href === "string" ? localizeHref(href, locale, routing ?? void 0) : localizeUrlObject(href, locale, routing ?? void 0),
+		...props
+	});
+});
+Link.displayName = "LocalizedLink";
+//#endregion
+export { Link };