intor 2.2.14 → 2.3.0

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/proxy/index.d.ts

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

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

@@ -0,0 +1,2 @@
+export { intorProxy as intorMiddleware, intorProxy } from '../../../src/adapters/next/proxy/intor-proxy.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/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;
+};

package/dist/src/adapters/next/navigation/use-pathname.js

@@ -0,0 +1,49 @@
+import { usePathname as usePathname$1 } from 'next/navigation';
+import { localizePathname } from '../shared/utils/localize-pathname.js';
+import 'react/jsx-runtime';
+import 'react';
+import '../../../client/react/contexts/config/context.js';
+import { useConfig } from '../../../client/react/contexts/config/hook.js';
+
+
+
+import '../../../config/constants/cache.constants.js';
+
+
+
+
+import '../../../client/react/contexts/messages/context.js';
+import '../../../client/react/contexts/locale/context.js';
+import { useLocale } from '../../../client/react/contexts/locale/hook.js';
+
+/**
+ * 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"
+ */
+const usePathname = () => {
+    const { config } = useConfig();
+    const { locale } = useLocale();
+    // Get the raw pathname from the Next.js usePathname hook
+    const rawPathname = usePathname$1();
+    // Generate the locale-prefixed pathname
+    const { localePrefixedPathname, standardizedPathname, unprefixedPathname } = localizePathname({
+        config,
+        pathname: rawPathname,
+        locale,
+    });
+    return {
+        localizedPathname: localePrefixedPathname,
+        standardizedPathname,
+        unprefixedPathname,
+    };
+};
+
+export { usePathname };

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

@@ -0,0 +1,20 @@
+import type { GenLocale } from "../../../shared/types/generated.types";
+import type { Locale } from "intor-translator";
+import type { NavigateOptions } from "next/dist/shared/lib/app-router-context.shared-runtime";
+/**
+ * useRouter hook.
+ *
+ * Wraps Next.js useRouter and provides push/replace methods that automatically switch locale.
+ */
+export declare const useRouter: () => {
+    back(): void;
+    forward(): void;
+    refresh(): void;
+    prefetch(href: string, options?: import("next/dist/shared/lib/app-router-context.shared-runtime").PrefetchOptions): void;
+    push: (href: string, options?: NavigateOptions & {
+        locale?: GenLocale;
+    }) => void;
+    replace: (href: string, options?: NavigateOptions & {
+        locale?: Locale;
+    }) => void;
+};

package/dist/src/adapters/next/navigation/use-router.js

@@ -0,0 +1,31 @@
+import { useRouter as useRouter$1 } from 'next/navigation';
+import { useLocaleSwitch } from './utils/use-locale-switch.js';
+
+/**
+ * useRouter hook.
+ *
+ * Wraps Next.js useRouter and provides push/replace methods that automatically switch locale.
+ */
+const useRouter = () => {
+    const { push, replace, ...rest } = useRouter$1();
+    const { switchLocale } = useLocaleSwitch();
+    // Push with locale
+    const pushWithLocale = (href, options) => {
+        const resolvedHref = switchLocale({ href, locale: options?.locale });
+        if (resolvedHref)
+            push(resolvedHref, options);
+    };
+    // Replace with locale
+    const replaceWithLocale = (href, options) => {
+        const resolvedHref = switchLocale({ href, locale: options?.locale });
+        if (resolvedHref)
+            replace(resolvedHref, options);
+    };
+    return {
+        push: pushWithLocale,
+        replace: replaceWithLocale,
+        ...rest,
+    };
+};
+
+export { useRouter };

package/dist/src/adapters/next/navigation/utils/should-full-reload.d.ts

@@ -0,0 +1,7 @@
+import type { IntorResolvedConfig } from "../../../../config";
+export declare const shouldFullReload: ({ config, targetPathname, locale, currentLocale, }: {
+    config: IntorResolvedConfig;
+    targetPathname: string;
+    locale?: string;
+    currentLocale: string;
+}) => boolean;

package/dist/src/adapters/next/navigation/utils/should-full-reload.js

@@ -0,0 +1,19 @@
+
+import { extractPathname } from '../../../../shared/utils/pathname/extract-pathname.js';
+
+const shouldFullReload = ({ config, targetPathname, locale, currentLocale, }) => {
+    const loader = config.loader;
+    if (!loader || !loader.type)
+        return false;
+    if (loader.type === "remote" && !loader.fullReload)
+        return false;
+    const { maybeLocale, isLocalePrefixed } = extractPathname({
+        config,
+        pathname: targetPathname,
+    });
+    const isDifferentLocale = (locale && locale !== currentLocale) ||
+        (isLocalePrefixed && maybeLocale !== currentLocale);
+    return isDifferentLocale ? true : false;
+};
+
+export { shouldFullReload };

package/dist/src/adapters/next/navigation/utils/use-locale-switch.d.ts

@@ -0,0 +1,16 @@
+import type { Locale } from "intor-translator";
+export declare const useLocaleSwitch: () => {
+    resolveHref: ({ href, locale, }: {
+        href?: string;
+        locale?: Locale;
+    }) => {
+        resolvedHref: string;
+        isExternal: boolean;
+        targetLocale: string;
+        targetPathname: string;
+    };
+    switchLocale: ({ href, locale, }: {
+        href?: string;
+        locale?: Locale;
+    }) => string | undefined;
+};

package/dist/src/adapters/next/navigation/utils/use-locale-switch.js

@@ -0,0 +1,58 @@
+import { usePathname } from '../use-pathname.js';
+import { shouldFullReload } from './should-full-reload.js';
+import { localizePathname } from '../../shared/utils/localize-pathname.js';
+import 'react/jsx-runtime';
+import 'react';
+import '../../../../client/react/contexts/config/context.js';
+import { useConfig } from '../../../../client/react/contexts/config/hook.js';
+import { setLocaleCookieBrowser } from '../../../../shared/utils/client/set-locale-cookie-browser.js';
+
+
+
+import '../../../../config/constants/cache.constants.js';
+
+
+
+
+import '../../../../client/react/contexts/messages/context.js';
+import '../../../../client/react/contexts/locale/context.js';
+import { useLocale } from '../../../../client/react/contexts/locale/hook.js';
+
+const useLocaleSwitch = () => {
+    const { config } = useConfig();
+    const { locale: currentLocale, setLocale } = useLocale();
+    const { localizedPathname } = usePathname();
+    // Resolve href
+    const resolveHref = ({ href, locale, }) => {
+        const isLocaleValid = locale && config.supportedLocales?.includes(locale);
+        const targetLocale = isLocaleValid ? locale : currentLocale;
+        const targetPathname = href ?? localizedPathname;
+        const isExternal = targetPathname.startsWith("http");
+        const resolvedHref = !isExternal
+            ? localizePathname({
+                config,
+                pathname: targetPathname,
+                locale: targetLocale,
+            }).localePrefixedPathname
+            : targetPathname;
+        return { resolvedHref, isExternal, targetLocale, targetPathname };
+    };
+    // Switch locale
+    const switchLocale = ({ href, locale, }) => {
+        const { resolvedHref, isExternal, targetLocale, targetPathname } = resolveHref({ href, locale });
+        if (isExternal)
+            return;
+        if (shouldFullReload({ config, targetPathname, locale, currentLocale })) {
+            setLocaleCookieBrowser({ cookie: config.cookie, locale: targetLocale });
+            globalThis.location.href = resolvedHref; // Full reload navigation
+            return;
+        }
+        else {
+            setLocale(targetLocale);
+        }
+        return resolvedHref;
+    };
+    return { resolveHref, switchLocale };
+};
+
+export { useLocaleSwitch };

package/dist/src/adapters/next/proxy/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/proxy/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/proxy/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/proxy/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/proxy/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/proxy/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/proxy/index.d.ts

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

package/dist/src/adapters/next/proxy/intor-proxy.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 intorProxy<Req extends NextRequest = NextRequest>(config: IntorResolvedConfig, request: Req): Promise<Response>;