intor 2.2.13 → 2.2.15

package/dist/exports/config/index.d.ts

@@ -0,0 +1,2 @@
+/** intor — config */
+export { defineIntorConfig, DEFAULT_CACHE_OPTIONS, DEFAULT_COOKIE_OPTIONS, DEFAULT_ROUTING_OPTIONS, type IntorRawConfig, type IntorResolvedConfig, } from "../../src/config";

package/dist/exports/config/index.js

@@ -0,0 +1,4 @@
+export { defineIntorConfig } from '../../src/config/define-intor-config.js';
+export { DEFAULT_CACHE_OPTIONS } from '../../src/config/constants/cache.constants.js';
+export { DEFAULT_COOKIE_OPTIONS } from '../../src/config/constants/cookie.constants.js';
+export { DEFAULT_ROUTING_OPTIONS } from '../../src/config/constants/routing.constants.js';

package/dist/exports/index.d.ts

@@ -0,0 +1,5 @@
+/** intor — main */
+export { PREFIX_PLACEHOLDER } from "../src/shared/constants/prefix-placeholder";
+export { mergeMessages, normalizeCacheKey, resolveNamespaces, normalizeLocale, resolvePreferredLocale, extractPathname, normalizePathname, standardizePathname, } from "../src/shared/utils";
+export { IntorError, IntorErrorCode } from "../src/shared/error";
+export { Translator, type TranslateHandlers, type FormatHandler, type LoadingHandler, type MissingHandler, type TranslateHandlerContext, type Locale, type FallbackLocalesMap, type NestedMessage, type LocaleMessages, type LocalizedMessagesUnion, type Replacement, type NodeKeys, type LeafKeys, type LocalizedLeafKeys, type ScopedLeafKeys, } from "intor-translator";

package/dist/exports/index.js

@@ -0,0 +1,11 @@
+export { PREFIX_PLACEHOLDER } from '../src/shared/constants/prefix-placeholder.js';
+export { mergeMessages } from '../src/shared/utils/merge-messages.js';
+export { normalizeCacheKey } from '../src/shared/utils/normalize-cache-key.js';
+export { resolveNamespaces } from '../src/shared/utils/resolve-namespaces.js';
+export { normalizeLocale } from '../src/shared/utils/locale/normalize-locale.js';
+export { resolvePreferredLocale } from '../src/shared/utils/locale/resolve-preferred-locale.js';
+export { extractPathname } from '../src/shared/utils/pathname/extract-pathname.js';
+export { normalizePathname } from '../src/shared/utils/pathname/normalize-pathname.js';
+export { standardizePathname } from '../src/shared/utils/pathname/standardize-pathname.js';
+export { IntorError, IntorErrorCode } from '../src/shared/error/intor-error.js';
+export { Translator } from 'intor-translator';

package/dist/exports/next/index.d.ts

@@ -0,0 +1,3 @@
+/** intor — next / main (client) */
+export { Link, usePathname, useRouter, redirect, } from "../../src/adapters/next/navigation";
+export { IntorProvider, type IntorProviderProps, TranslateHandlersProvider, type TranslateHandlersProviderProps, useTranslator, } from "../../src/client/react";

package/dist/exports/next/index.js

@@ -0,0 +1,9 @@
+export { Link } from '../../src/adapters/next/navigation/link.js';
+export { usePathname } from '../../src/adapters/next/navigation/use-pathname.js';
+export { useRouter } from '../../src/adapters/next/navigation/use-router.js';
+export { redirect } from '../../src/adapters/next/navigation/redirect.js';
+export { IntorProvider } from '../../src/client/react/contexts/intor-provider/intor-provider.js';
+export { TranslateHandlersProvider } from '../../src/client/react/contexts/translate-handlers/provider.js';
+import 'react';
+import '../../src/client/react/contexts/translate-handlers/context.js';
+export { useTranslator } from '../../src/client/react/hooks/use-translator.js';

package/dist/exports/next/middleware/index.d.ts

@@ -0,0 +1,2 @@
+/** intor — next / middleware */
+export { intorMiddleware, PATHNAME_HEADER_NAME, } from "../../../src/adapters/next/middleware";

package/dist/exports/next/middleware/index.js

@@ -0,0 +1,2 @@
+export { intorMiddleware } from '../../../src/adapters/next/middleware/intor-middleware.js';
+export { PATHNAME_HEADER_NAME } from '../../../src/adapters/next/shared/constants/pathname-header-name.js';

package/dist/exports/next/server/index.d.ts

@@ -0,0 +1,2 @@
+/** intor — next / server */
+export { getI18nContext, getTranslator, } from "../../../src/adapters/next/server";

package/dist/exports/next/server/index.js

@@ -0,0 +1,2 @@
+export { getI18nContext } from '../../../src/adapters/next/server/get-i18n-context.js';
+export { getTranslator } from '../../../src/adapters/next/server/get-translator.js';

package/dist/exports/react/index.d.ts

@@ -0,0 +1,2 @@
+/** intor — react */
+export { IntorProvider, type IntorProviderProps, TranslateHandlersProvider, type TranslateHandlersProviderProps, useTranslator, getInitialLocale, } from "../../src/client/react";

package/dist/exports/react/index.js

@@ -0,0 +1,6 @@
+export { IntorProvider } from '../../src/client/react/contexts/intor-provider/intor-provider.js';
+export { TranslateHandlersProvider } from '../../src/client/react/contexts/translate-handlers/provider.js';
+import 'react';
+import '../../src/client/react/contexts/translate-handlers/context.js';
+export { useTranslator } from '../../src/client/react/hooks/use-translator.js';
+export { getInitialLocale } from '../../src/client/shared/utils/get-initial-locale.js';

package/dist/exports/server/index.d.ts

@@ -0,0 +1,2 @@
+/** intor — server */
+export { intor, type I18nContext, type IntorResult, loadMessages, loadLocalMessages, type LoadLocalMessagesOptions, loadRemoteMessages, type LoadRemoteMessagesOptions, type Messages, type MessagesReader, clearMessagesPool, getTranslator, clearLoggerPool, } from "../../src/server";

package/dist/exports/server/index.js

@@ -0,0 +1,7 @@
+export { intor } from '../../src/server/intor/intor.js';
+export { loadMessages } from '../../src/server/messages/load-messages.js';
+export { loadLocalMessages } from '../../src/server/messages/load-local-messages/load-local-messages.js';
+export { loadRemoteMessages } from '../../src/server/messages/load-remote-messages/load-remote-messages.js';
+export { clearMessagesPool } from '../../src/server/messages/shared/global-messages-pool.js';
+export { getTranslator } from '../../src/server/translator/get-translator.js';
+export { clearLoggerPool } from '../../src/server/shared/logger/global-logger-pool.js';

package/dist/src/adapters/next/middleware/handle-prefix/handle-prefix-all.d.ts

@@ -0,0 +1,12 @@
+import type { IntorResolvedConfig } from "../../../../config";
+import type { NextRequest } from "next/server";
+/**
+ * Handle routing for "all" prefix.
+ *
+ * - If URL has locale prefix → use it and override cookie.
+ * - If no prefix and no cookie:
+ *   - If redirect disabled → respond directly.
+ *   - If redirect enabled → detect initial locale and redirect.
+ * - If no prefix but cookie exists → redirect using cookie locale.
+ */
+export declare const handlePrefixAll: <Req extends NextRequest = NextRequest>(config: IntorResolvedConfig, request: Req) => Promise<Response>;

package/dist/src/adapters/next/middleware/handle-prefix/handle-prefix-all.js

@@ -0,0 +1,60 @@
+import { createResponse } from '../utils/create-response.js';
+import { determineInitialLocale } from '../utils/determine-initial-locale.js';
+import 'lodash.merge';
+import { extractPathname } from '../../../../shared/utils/pathname/extract-pathname.js';
+
+/**
+ * Handle routing for "all" prefix.
+ *
+ * - If URL has locale prefix → use it and override cookie.
+ * - If no prefix and no cookie:
+ *   - If redirect disabled → respond directly.
+ *   - If redirect enabled → detect initial locale and redirect.
+ * - If no prefix but cookie exists → redirect using cookie locale.
+ */
+const handlePrefixAll = async (config, request) => {
+    const { cookie, routing } = config;
+    const { maybeLocale, isLocalePrefixed } = extractPathname({
+        config,
+        pathname: request.nextUrl.pathname,
+    });
+    const localeFromCookie = request.cookies.get(cookie.name)?.value;
+    // ▼ URL has a locale prefix, (e.g. https://example.com/en)
+    if (isLocalePrefixed) {
+        // ▶ Go directly and override cookie
+        return createResponse({
+            request,
+            config,
+            locale: maybeLocale,
+            setCookieOptions: { override: true },
+        });
+    }
+    // ▼ URL doesn't have a locale prefix, (e.g. https://example.com/)
+    // No cookie, so is first visit
+    if (!localeFromCookie) {
+        // Not using redirect (Do not set cookie)
+        if (!routing.firstVisit.redirect) {
+            // ▶ Go directly
+            return createResponse({ request, config });
+        }
+        // Decide to use locale from browser or defaultLocale
+        const initialLocale = await determineInitialLocale(config);
+        // Using redirect for the first visit
+        // ▶ Redirect to URL (set cookie for the first visit)
+        return createResponse({
+            request,
+            config,
+            locale: initialLocale, // Use locale from 'browser' | 'default'
+            responseType: "redirect",
+        });
+    }
+    // ▶ Redirect to URL
+    return createResponse({
+        request,
+        config,
+        locale: localeFromCookie, // Use locale from cookie
+        responseType: "redirect",
+    });
+};
+
+export { handlePrefixAll };

package/dist/src/adapters/next/middleware/handle-prefix/handle-prefix-except-default.d.ts

@@ -0,0 +1,16 @@
+import type { IntorResolvedConfig } from "../../../../config";
+import type { NextRequest } from "next/server";
+/**
+ * Handle routing for "except-default" prefix.
+ *
+ * - If URL has a non-default locale prefix → use it and override cookie.
+ * - If no prefix and no cookie:
+ *   - If redirect disabled → respond directly.
+ *   - If redirect enabled:
+ *     - If resolved locale is default → respond directly.
+ *     - Else → redirect to locale URL.
+ * - If no prefix but cookie exists:
+ *   - If cookie locale is default → respond directly.
+ *   - Else → redirect to locale URL.
+ */
+export declare const handlePrefixExceptDefault: <Req extends NextRequest = NextRequest>(config: IntorResolvedConfig, request: Req) => Promise<Response>;

package/dist/src/adapters/next/middleware/handle-prefix/handle-prefix-except-default.js

@@ -0,0 +1,81 @@
+import { createResponse } from '../utils/create-response.js';
+import { determineInitialLocale } from '../utils/determine-initial-locale.js';
+import 'lodash.merge';
+import { extractPathname } from '../../../../shared/utils/pathname/extract-pathname.js';
+
+/**
+ * Handle routing for "except-default" prefix.
+ *
+ * - If URL has a non-default locale prefix → use it and override cookie.
+ * - If no prefix and no cookie:
+ *   - If redirect disabled → respond directly.
+ *   - If redirect enabled:
+ *     - If resolved locale is default → respond directly.
+ *     - Else → redirect to locale URL.
+ * - If no prefix but cookie exists:
+ *   - If cookie locale is default → respond directly.
+ *   - Else → redirect to locale URL.
+ */
+const handlePrefixExceptDefault = async (config, request) => {
+    const { defaultLocale, cookie, routing } = config;
+    const { maybeLocale, isLocalePrefixed } = extractPathname({
+        config,
+        pathname: request.nextUrl.pathname,
+    });
+    const localeFromCookie = request.cookies.get(cookie.name)?.value;
+    // ▼ URL has a locale prefix, and it's not defaultLocale (e.g. https://example.com/zh)
+    if (isLocalePrefixed && maybeLocale !== defaultLocale) {
+        // ▶ Go directly and override cookie
+        return createResponse({
+            request,
+            config,
+            locale: maybeLocale,
+            setCookieOptions: { override: true },
+        });
+    }
+    // ▼ URL doesn't have a locale prefix, (e.g. https://example.com/)
+    // No cookie, so is first visit
+    if (!localeFromCookie) {
+        // Not using redirect (Do not set cookie)
+        if (!routing.firstVisit.redirect) {
+            // ▶ Go directly
+            return createResponse({ request, config });
+        }
+        // Using redirect for the first visit
+        // Decide to use locale from browser or defaultLocale
+        const initialLocale = await determineInitialLocale(config);
+        const isDefaultLocale = initialLocale === defaultLocale;
+        // Is defaultLocale
+        if (isDefaultLocale) {
+            // ▶ Go directly, no prefix (set cookie for the first visit)
+            return createResponse({
+                request,
+                config,
+                locale: defaultLocale,
+            });
+        }
+        // Not defaultLocale
+        // ▶ Redirect to URL (set cookie for the first visit)
+        return createResponse({
+            request,
+            config,
+            locale: initialLocale, // Use locale from 'browser' | 'default'
+            responseType: "redirect",
+        });
+    }
+    // Cookie found (No need to set cookie)
+    const isDefaultLocale = localeFromCookie === defaultLocale;
+    if (isDefaultLocale) {
+        // ▶ Go directly
+        return createResponse({ request, config, locale: localeFromCookie });
+    }
+    // ▶ Redirect to URL
+    return createResponse({
+        request,
+        config,
+        locale: localeFromCookie, // Use locale from cookie
+        responseType: "redirect",
+    });
+};
+
+export { handlePrefixExceptDefault };

package/dist/src/adapters/next/middleware/handle-prefix/handle-prefix-none.d.ts

@@ -0,0 +1,10 @@
+import type { IntorResolvedConfig } from "../../../../config";
+import type { NextRequest } from "next/server";
+/**
+ * Handle routing for "none" prefix.
+ *
+ * Checks cookie for locale. If absent,
+ * determines initial locale via config.
+ * Returns response with locale.
+ */
+export declare const handlePrefixNone: <Req extends NextRequest = NextRequest>(config: IntorResolvedConfig, request: Req) => Promise<Response>;

package/dist/src/adapters/next/middleware/handle-prefix/handle-prefix-none.js

@@ -0,0 +1,22 @@
+import { createResponse } from '../utils/create-response.js';
+import { determineInitialLocale } from '../utils/determine-initial-locale.js';
+
+/**
+ * Handle routing for "none" prefix.
+ *
+ * Checks cookie for locale. If absent,
+ * determines initial locale via config.
+ * Returns response with locale.
+ */
+const handlePrefixNone = async (config, request) => {
+    let locale = request.cookies.get(config.cookie.name)?.value;
+    // No cookie, so is first visit
+    if (!locale) {
+        // Decide to use locale from browser or defaultLocale
+        locale = await determineInitialLocale(config);
+    }
+    // ▶ Go directly (set cookie only for the first time, no override)
+    return createResponse({ request, config, locale });
+};
+
+export { handlePrefixNone };

package/dist/src/adapters/next/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export { intorMiddleware } from "./intor-middleware";
+export { PATHNAME_HEADER_NAME } from "../../../adapters/next/shared/constants/pathname-header-name";

package/dist/src/adapters/next/middleware/intor-middleware.d.ts

@@ -0,0 +1,6 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+import type { NextRequest } from "next/server";
+/**
+ * Handle locale routing based on prefix config
+ */
+export declare function intorMiddleware<Req extends NextRequest = NextRequest>(config: IntorResolvedConfig, request: Req): Promise<Response>;

package/dist/src/adapters/next/middleware/intor-middleware.js

@@ -0,0 +1,22 @@
+import { handlePrefixAll } from './handle-prefix/handle-prefix-all.js';
+import { handlePrefixExceptDefault } from './handle-prefix/handle-prefix-except-default.js';
+import { handlePrefixNone } from './handle-prefix/handle-prefix-none.js';
+
+/**
+ * Handle locale routing based on prefix config
+ */
+async function intorMiddleware(config, request) {
+    const { prefix } = config.routing;
+    // ===== Prefix: none =====
+    if (prefix === "none") {
+        return handlePrefixNone(config, request);
+    }
+    // ===== Prefix: except-default =====
+    if (prefix === "except-default") {
+        return await handlePrefixExceptDefault(config, request);
+    }
+    // ===== Prefix: all =====
+    return await handlePrefixAll(config, request);
+}
+
+export { intorMiddleware };

package/dist/src/adapters/next/middleware/utils/create-response.d.ts

@@ -0,0 +1,17 @@
+import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+interface CreateResponseOptions<Req extends NextRequest = NextRequest> {
+    request: Req;
+    config: IntorResolvedConfig;
+    locale?: string;
+    responseType?: "next" | "redirect";
+    setCookieOptions?: {
+        override?: boolean;
+    };
+}
+/**
+ * Create a Next.js response with locale handling.
+ */
+export declare const createResponse: <Req extends NextRequest = NextRequest, Res extends NextResponse = NextResponse>({ request, config, locale, responseType, setCookieOptions, }: CreateResponseOptions<Req>) => Response;
+export {};

package/dist/src/adapters/next/middleware/utils/create-response.js

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server';
+import { setLocaleCookieEdge } from './set-locale-cookie-edge.js';
+import { setPathnameHeader } from './set-pathname-header.js';
+import { localizePathname } from '../../shared/utils/localize-pathname.js';
+
+/**
+ * Create a Next.js response with locale handling.
+ */
+const createResponse = ({ request, config, locale, responseType = "next", setCookieOptions = { override: false }, }) => {
+    const { cookie } = config;
+    const { override } = setCookieOptions;
+    const url = request.nextUrl.clone(); // Clone URL to avoid mutating original
+    // Generate locale-prefixed pathname
+    const { localePrefixedPathname } = localizePathname({
+        config,
+        pathname: url.pathname,
+        locale,
+    });
+    url.pathname = localePrefixedPathname;
+    // Create response based on the responseType
+    const response = responseType === "redirect"
+        ? NextResponse.redirect(url)
+        : NextResponse.next();
+    // Set locale cookie if locale is provided
+    if (locale) {
+        setLocaleCookieEdge({
+            request,
+            response,
+            locale,
+            cookie,
+            override,
+        });
+    }
+    // Set pathname header
+    const finalResponse = setPathnameHeader({
+        request,
+        response: response,
+    });
+    return finalResponse;
+};
+
+export { createResponse };

package/dist/src/adapters/next/middleware/utils/determine-initial-locale.d.ts

@@ -0,0 +1,8 @@
+import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+/**
+ * Determine the initial locale for the user.
+ *
+ * @param config - The resolved configuration object.
+ * @returns The initial locale string.
+ */
+export declare const determineInitialLocale: (config: IntorResolvedConfig) => Promise<string>;

package/dist/src/adapters/next/middleware/utils/determine-initial-locale.js

@@ -0,0 +1,28 @@
+import { headers } from 'next/headers';
+import 'lodash.merge';
+import { normalizeLocale } from '../../../../shared/utils/locale/normalize-locale.js';
+import { resolvePreferredLocale } from '../../../../shared/utils/locale/resolve-preferred-locale.js';
+
+/**
+ * Determine the initial locale for the user.
+ *
+ * @param config - The resolved configuration object.
+ * @returns The initial locale string.
+ */
+const determineInitialLocale = async (config) => {
+    const { defaultLocale, supportedLocales, routing } = config;
+    let initialLocale = defaultLocale;
+    // If locale should be determined from browser on first visit
+    if (routing.firstVisit.localeSource === "browser") {
+        const headersStore = await headers();
+        const acceptLanguageHeader = headersStore.get("accept-language") || undefined;
+        // Find the best matching locale from the supported locales
+        const preferredLocale = resolvePreferredLocale(acceptLanguageHeader, supportedLocales);
+        // Normalize the preferred locale or fallback to default
+        initialLocale =
+            normalizeLocale(preferredLocale, supportedLocales) || defaultLocale;
+    }
+    return initialLocale;
+};
+
+export { determineInitialLocale };

package/dist/src/adapters/next/middleware/utils/set-locale-cookie-edge.d.ts

@@ -0,0 +1,15 @@
+import type { CookieResolvedOptions } from "../../../../config/types/cookie.types";
+import type { NextRequest, NextResponse } from "next/server";
+interface SetLocaleCookieParams {
+    request: NextRequest;
+    response: NextResponse;
+    cookie: CookieResolvedOptions;
+    locale: string;
+    override?: boolean;
+}
+/**
+ * Set a locale cookie on the response.
+ * - For Next.js edge middleware.
+ */
+export declare function setLocaleCookieEdge({ request, response, cookie, locale, override, }: SetLocaleCookieParams): void;
+export {};

package/dist/src/adapters/next/middleware/utils/set-locale-cookie-edge.js

@@ -0,0 +1,24 @@
+/**
+ * Set a locale cookie on the response.
+ * - For Next.js edge middleware.
+ */
+function setLocaleCookieEdge({ request, response, cookie, locale, override = false, // Default to not override existed cookie
+ }) {
+    if (!cookie.enabled || !cookie.autoSetCookie)
+        return;
+    const isCookieExists = request.cookies.has(cookie.name);
+    // Cookie already exists and cannot override
+    if (isCookieExists && !override)
+        return;
+    // Set cookie to response
+    response.cookies.set(cookie.name, locale, {
+        maxAge: cookie.maxAge,
+        path: cookie.path,
+        ...(cookie.domain ? { domain: cookie.domain } : {}),
+        secure: cookie.secure,
+        httpOnly: cookie.httpOnly,
+        sameSite: cookie.sameSite,
+    });
+}
+
+export { setLocaleCookieEdge };

package/dist/src/adapters/next/middleware/utils/set-pathname-header.d.ts

@@ -0,0 +1,12 @@
+import type { NextRequest, NextResponse } from "next/server";
+interface SetPathnameHeaderOptions<Req extends NextRequest = NextRequest, Res extends NextResponse = NextResponse> {
+    request: Req;
+    response: Res;
+    key?: string;
+}
+/**
+ * Set the pathname in the response header.
+ * - For Next.js edge middleware.
+ */
+export declare const setPathnameHeader: <Req extends NextRequest = NextRequest, Res extends NextResponse = NextResponse>({ request, response, key, }: SetPathnameHeaderOptions<Req, Res>) => Response;
+export {};

package/dist/src/adapters/next/middleware/utils/set-pathname-header.js

@@ -0,0 +1,13 @@
+import { PATHNAME_HEADER_NAME } from '../../shared/constants/pathname-header-name.js';
+
+/**
+ * Set the pathname in the response header.
+ * - For Next.js edge middleware.
+ */
+const setPathnameHeader = ({ request, response, key = PATHNAME_HEADER_NAME, }) => {
+    const pathname = request.nextUrl.pathname;
+    response.headers.set(key, pathname);
+    return response;
+};
+
+export { setPathnameHeader };

package/dist/src/adapters/next/navigation/index.d.ts

@@ -0,0 +1,4 @@
+export { Link } from "./link";
+export { usePathname } from "./use-pathname";
+export { useRouter } from "./use-router";
+export { redirect } from "./redirect";

package/dist/src/adapters/next/navigation/link.d.ts

@@ -0,0 +1,16 @@
+import type { GenLocale } from "../../../shared/types/generated.types";
+import type { Url } from "next/dist/shared/lib/router/router";
+import type { LinkProps as NextLinkProps } from "next/link";
+import * as React from "react";
+interface LinkProps extends Omit<NextLinkProps, "href">, Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    href?: Url;
+    locale?: GenLocale;
+}
+/**
+ * Localized Link component
+ *
+ * - Wraps Next.js Link and handles locale switching.
+ * - Full reload occurs only if the locale changes and requires it; otherwise updates context.
+ */
+export declare const Link: ({ href, locale, children, onClick, ...props }: LinkProps) => React.JSX.Element;
+export {};

package/dist/src/adapters/next/navigation/link.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
+import NextLink from 'next/link';
+import 'react';
+import { useLocaleSwitch } from './utils/use-locale-switch.js';
+
+/**
+ * Localized Link component
+ *
+ * - Wraps Next.js Link and handles locale switching.
+ * - Full reload occurs only if the locale changes and requires it; otherwise updates context.
+ */
+const Link = ({ href, locale, children, onClick, ...props }) => {
+    const formatted = typeof href === "string" ? href : href ? formatUrl(href) : undefined;
+    const { resolveHref, switchLocale } = useLocaleSwitch();
+    const { resolvedHref } = resolveHref({ href: formatted, locale });
+    const handleClick = (e) => {
+        onClick?.(e);
+        switchLocale({ href: formatted, locale });
+    };
+    return (jsx(NextLink, { href: resolvedHref, onClick: handleClick, ...props, children: children }));
+};
+
+export { Link };

package/dist/src/adapters/next/navigation/redirect.d.ts

@@ -0,0 +1,16 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { GenLocale } from "../../../shared/types/generated.types";
+import type { RedirectType } from "next/navigation";
+/**
+ * redirect utility.
+ *
+ * - Wraps Next.js redirect and applies locale-aware navigation.
+ * - Automatically prefixes the pathname with the correct locale.
+ * - External URLs are redirected directly without modification.
+ */
+export declare const redirect: ({ config, locale, url, type, }: {
+    config: IntorResolvedConfig;
+    locale?: GenLocale;
+    url: string;
+    type?: RedirectType | undefined;
+}) => Promise<never>;

package/dist/src/adapters/next/navigation/redirect.js

@@ -0,0 +1,36 @@
+import { redirect as redirect$1 } from 'next/navigation';
+import { getI18nContext } from '../server/get-i18n-context.js';
+import 'intor-translator';
+
+
+
+import '../../../config/constants/cache.constants.js';
+
+
+
+
+import { localizePathname } from '../shared/utils/localize-pathname.js';
+
+/**
+ * redirect utility.
+ *
+ * - Wraps Next.js redirect and applies locale-aware navigation.
+ * - Automatically prefixes the pathname with the correct locale.
+ * - External URLs are redirected directly without modification.
+ */
+const redirect = async ({ config, locale, url, type, }) => {
+    if (url.startsWith("http")) {
+        redirect$1(url);
+    }
+    const isLocaleValid = locale && config.supportedLocales?.includes(locale);
+    const { locale: detectedLocale } = await getI18nContext(config);
+    // Generate the locale-prefixed pathname
+    const { localePrefixedPathname } = localizePathname({
+        config,
+        pathname: url,
+        locale: isLocaleValid ? locale : detectedLocale,
+    });
+    redirect$1(localePrefixedPathname, type);
+};
+
+export { redirect };

package/dist/src/adapters/next/navigation/use-pathname.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Custom hook to get the current pathname in different forms based on the active locale.
+ *
+ * This hook wraps Next.js `usePathname` and processes the pathname according to the app's
+ * locale configuration.
+ *
+ * @example
+ * const { localizedPathname, standardizedPathname, unprefixedPathname } = usePathname();
+ * console.log(localizedPathname); // e.g. "/en/about"
+ * console.log(standardizedPathname); // e.g. "/{locale}/about"
+ * console.log(unprefixedPathname); // e.g. "/about"
+ */
+export declare const usePathname: () => {
+    localizedPathname: string;
+    standardizedPathname: string;
+    unprefixedPathname: string;
+};