intor 2.2.14 → 2.3.0

package/dist/src/adapters/next/proxy/intor-proxy.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 intorProxy(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 { intorProxy };

package/dist/src/adapters/next/proxy/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/proxy/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/proxy/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/proxy/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/proxy/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 proxy.
+ */
+export declare function setLocaleCookieEdge({ request, response, cookie, locale, override, }: SetLocaleCookieParams): void;
+export {};

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

@@ -0,0 +1,24 @@
+/**
+ * Set a locale cookie on the response.
+ * - For Next.js proxy.
+ */
+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/proxy/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 proxy.
+ */
+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/proxy/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 proxy.
+ */
+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/server/get-i18n-context.d.ts

@@ -0,0 +1,9 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+import type { I18nContext } from "../../../server/intor/types";
+import type { GenConfigKeys } from "../../../shared/types/generated.types";
+/**
+ * Retrieves the i18n context for the current request.
+ *
+ * Next.js adapter implementation: uses `next/headers` and `next/cookies`.
+ */
+export declare const getI18nContext: <CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig) => Promise<I18nContext>;

package/dist/src/adapters/next/server/get-i18n-context.js

@@ -0,0 +1,47 @@
+import { cookies, headers } from 'next/headers';
+import { PATHNAME_HEADER_NAME } from '../shared/constants/pathname-header-name.js';
+import { getLogger } from '../../../server/shared/logger/get-logger.js';
+import 'lodash.merge';
+import { normalizeLocale } from '../../../shared/utils/locale/normalize-locale.js';
+import { resolvePreferredLocale } from '../../../shared/utils/locale/resolve-preferred-locale.js';
+
+/**
+ * Retrieves the i18n context for the current request.
+ *
+ * Next.js adapter implementation: uses `next/headers` and `next/cookies`.
+ */
+const getI18nContext = async (config) => {
+    const baseLogger = getLogger({ id: config.id, ...config.logger });
+    const logger = baseLogger.child({ scope: "next-adapter" });
+    const cookiesStore = await cookies();
+    const headersStore = await headers();
+    const { defaultLocale, supportedLocales = [], cookie, routing } = config;
+    let locale;
+    // Locale from cookie (if cookie is enabled)
+    if (cookie.enabled) {
+        const localeFromCookie = cookiesStore.get(cookie.name)?.value;
+        locale = normalizeLocale(localeFromCookie, supportedLocales);
+        if (locale) {
+            logger.trace("Locale retrieved from cookie.", { locale });
+        }
+    }
+    //====== ▼ Locale from cookie not found ======
+    // Locale source set to "browser", retrieve from Accept-Language header
+    if (!locale && routing.firstVisit.localeSource === "browser") {
+        const aLHeader = headersStore.get("accept-language") || undefined;
+        const preferredLocale = resolvePreferredLocale(aLHeader, supportedLocales);
+        locale = normalizeLocale(preferredLocale, supportedLocales);
+        logger.trace("Locale retrieved from header.", { locale });
+    }
+    // Retrieve pathname from headers (next/headers)
+    const pathname = headersStore.get(PATHNAME_HEADER_NAME);
+    if (pathname) {
+        logger.trace("Pathname retrieved from header.", { pathname });
+    }
+    return {
+        locale: (locale || defaultLocale),
+        pathname: pathname || "",
+    };
+};
+
+export { getI18nContext };

package/dist/src/adapters/next/server/get-translator.d.ts

@@ -0,0 +1,30 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+import type { MessagesReader } from "../../../server";
+import type { GenConfigKeys, GenMessages, IfGen } from "../../../shared/types/generated.types";
+import type { TranslatorInstance } from "../../../shared/types/translator-instance.types";
+import type { LocalizedNodeKeys, TranslateHandlers } from "intor-translator";
+/**
+ * Create a translator instance ready for the current Next.js SSR environment.
+ *
+ * - **Automatically resolves the current locale and pathname using the Next.js adapter.**
+ * - Loads messages using the provided config, locale, and pathname.
+ * - Initializes a translator with `t`, `hasKey`, and optional scoped methods.
+ * - Supports optional `preKey` to create a scoped translator for nested keys.
+ */
+export declare function getTranslator<CK extends GenConfigKeys = "__default__">(options: {
+    config: IntorResolvedConfig;
+    handlers?: TranslateHandlers;
+    extraOptions?: {
+        exts?: string[];
+        messagesReader?: MessagesReader;
+    };
+}): Promise<TranslatorInstance<GenMessages<CK>>>;
+export declare function getTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(options: {
+    config: IntorResolvedConfig;
+    handlers?: TranslateHandlers;
+    extraOptions?: {
+        exts?: string[];
+        messagesReader?: MessagesReader;
+    };
+    preKey: IfGen<PK, string>;
+}): Promise<TranslatorInstance<GenMessages<CK>, PK>>;

package/dist/src/adapters/next/server/get-translator.js

@@ -0,0 +1,19 @@
+import { getI18nContext } from './get-i18n-context.js';
+import { getTranslator as getTranslator$1 } from '../../../server/translator/get-translator.js';
+
+// Implementation
+async function getTranslator(options) {
+    const { config, preKey, handlers, extraOptions } = options;
+    const { locale, pathname } = await getI18nContext(config);
+    const translatorInstance = getTranslator$1({
+        config,
+        locale,
+        pathname,
+        handlers,
+        extraOptions,
+        preKey,
+    });
+    return translatorInstance;
+}
+
+export { getTranslator };

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

@@ -0,0 +1,2 @@
+export { getI18nContext } from "./get-i18n-context";
+export { getTranslator } from "./get-translator";

package/dist/src/adapters/next/shared/constants/pathname-header-name.d.ts

@@ -0,0 +1 @@
+export declare const PATHNAME_HEADER_NAME = "x-intor-pathname";

package/dist/src/adapters/next/shared/constants/pathname-header-name.js

@@ -0,0 +1,4 @@
+// Default pathname header name
+const PATHNAME_HEADER_NAME = "x-intor-pathname";
+
+export { PATHNAME_HEADER_NAME };

package/dist/src/adapters/next/shared/utils/locale-prefix-pathname.d.ts

@@ -0,0 +1,16 @@
+import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+interface LocalePrefixPathnameOptions {
+    pathname: string;
+    config: IntorResolvedConfig;
+    locale?: string;
+}
+/**
+ * Converts a standardized pathname by applying the locale prefix according to the configured strategy.
+ *
+ * Based on the `routing.prefix` setting in the config:
+ * - "all": Always add the locale prefix.
+ * - "except-default": Add the locale prefix unless the locale is the default.
+ * - "none": Remove the locale prefix entirely.
+ */
+export declare const localePrefixPathname: ({ config, pathname: standardizedPathname, locale, }: LocalePrefixPathnameOptions) => string;
+export {};

package/dist/src/adapters/next/shared/utils/locale-prefix-pathname.js

@@ -0,0 +1,33 @@
+import { PREFIX_PLACEHOLDER } from '../../../../shared/constants/prefix-placeholder.js';
+import 'lodash.merge';
+import { normalizePathname } from '../../../../shared/utils/pathname/normalize-pathname.js';
+
+/**
+ * Converts a standardized pathname by applying the locale prefix according to the configured strategy.
+ *
+ * Based on the `routing.prefix` setting in the config:
+ * - "all": Always add the locale prefix.
+ * - "except-default": Add the locale prefix unless the locale is the default.
+ * - "none": Remove the locale prefix entirely.
+ */
+const localePrefixPathname = ({ config, pathname: standardizedPathname, locale, }) => {
+    const { routing } = config;
+    const { prefix } = routing;
+    if (prefix !== "none" && !locale) {
+        throw new Error('No locale when using prefix "all", "except-default"');
+    }
+    // context: "all"
+    if (prefix === "all") {
+        return normalizePathname(standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale));
+    }
+    // context: "except-default"
+    if (prefix === "except-default") {
+        return locale === config.defaultLocale
+            ? normalizePathname(standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, ""))
+            : normalizePathname(standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale));
+    }
+    // context: "none"
+    return normalizePathname(standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, ""));
+};
+
+export { localePrefixPathname };

package/dist/src/adapters/next/shared/utils/localize-pathname.d.ts

@@ -0,0 +1,18 @@
+import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+interface LocalizePathnameOptions {
+    config: IntorResolvedConfig;
+    pathname: string;
+    locale?: string;
+}
+/**
+ * Localizes a given pathname by:
+ * 1. Removing the basePath and locale prefix (if necessary) using `extractPathname`.
+ * 2. Standardizing the pathname by appending basePath and the prefixPlaceholder using `standardizedPathname`.
+ * 3. Adding the correct locale prefix back to the standardized pathname using `localePrefixPathname`.
+ */
+export declare const localizePathname: ({ config, pathname: rawPathname, locale, }: LocalizePathnameOptions) => {
+    unprefixedPathname: string;
+    standardizedPathname: string;
+    localePrefixedPathname: string;
+};
+export {};

package/dist/src/adapters/next/shared/utils/localize-pathname.js

@@ -0,0 +1,36 @@
+import { localePrefixPathname } from './locale-prefix-pathname.js';
+import 'lodash.merge';
+import { standardizePathname } from '../../../../shared/utils/pathname/standardize-pathname.js';
+import { extractPathname } from '../../../../shared/utils/pathname/extract-pathname.js';
+
+/**
+ * Localizes a given pathname by:
+ * 1. Removing the basePath and locale prefix (if necessary) using `extractPathname`.
+ * 2. Standardizing the pathname by appending basePath and the prefixPlaceholder using `standardizedPathname`.
+ * 3. Adding the correct locale prefix back to the standardized pathname using `localePrefixPathname`.
+ */
+const localizePathname = ({ config, pathname: rawPathname, locale, }) => {
+    // Remove the locale prefix if necessary
+    const { unprefixedPathname } = extractPathname({
+        config,
+        pathname: rawPathname,
+    });
+    // Standardize pathname
+    const standardizedPathname = standardizePathname({
+        config,
+        pathname: unprefixedPathname,
+    });
+    // Add locale prefix to pathname
+    const localePrefixedPathname = localePrefixPathname({
+        config,
+        pathname: standardizedPathname,
+        locale,
+    });
+    return {
+        unprefixedPathname,
+        standardizedPathname,
+        localePrefixedPathname,
+    };
+};
+
+export { localizePathname };

package/dist/src/client/react/contexts/config/context.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigContextValue } from "./types";
+import * as React from "react";
+export declare const ConfigContext: React.Context<ConfigContextValue | undefined>;

package/dist/src/client/react/contexts/config/context.js

@@ -0,0 +1,6 @@
+import * as React from 'react';
+
+// context
+const ConfigContext = React.createContext(undefined);
+
+export { ConfigContext };

package/dist/src/client/react/contexts/config/hook.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigContextValue } from "./types";
+export declare function useConfig(): ConfigContextValue;

package/dist/src/client/react/contexts/config/hook.js

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { ConfigContext } from './context.js';
+
+// hook
+function useConfig() {
+    const context = React.useContext(ConfigContext);
+    if (!context)
+        throw new Error("useConfig must be used within ConfigProvider");
+    return context;
+}
+
+export { useConfig };

package/dist/src/client/react/contexts/config/index.d.ts

@@ -0,0 +1,2 @@
+export { ConfigProvider } from "./provider";
+export { useConfig } from "./hook";

package/dist/src/client/react/contexts/config/provider.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigProviderProps } from "./types";
+export declare function ConfigProvider({ value: { config, pathname }, children, }: ConfigProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/client/react/contexts/config/provider.js

@@ -0,0 +1,11 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import * as React from 'react';
+import { ConfigContext } from './context.js';
+
+function ConfigProvider({ value: { config, pathname }, children, }) {
+    const value = React.useMemo(() => ({ config, pathname }), [config, pathname]);
+    return (jsx(ConfigContext.Provider, { value: value, children: children }));
+}
+
+export { ConfigProvider };

package/dist/src/client/react/contexts/config/types.d.ts

@@ -0,0 +1,10 @@
+import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+import type * as React from "react";
+export type ConfigContextValue = {
+    config: IntorResolvedConfig;
+    pathname: string;
+};
+export type ConfigProviderProps = {
+    value: ConfigContextValue;
+    children: React.ReactNode;
+};

package/dist/src/client/react/contexts/intor-provider/index.d.ts

@@ -0,0 +1,2 @@
+export { IntorProvider } from "./intor-provider";
+export type { IntorProviderProps } from "./types";

package/dist/src/client/react/contexts/intor-provider/intor-provider.d.ts

@@ -0,0 +1,2 @@
+import type { IntorProviderProps } from "./types";
+export declare const IntorProvider: ({ value: { config, pathname, initialLocale, messages, onLocaleChange, isLoading, }, children, }: IntorProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/client/react/contexts/intor-provider/intor-provider.js

@@ -0,0 +1,17 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import 'react';
+import { ConfigProvider } from '../config/provider.js';
+import '../config/context.js';
+import { LocaleProvider } from '../locale/provider.js';
+import '../locale/context.js';
+import { MessagesProvider } from '../messages/provider.js';
+import '../messages/context.js';
+import { TranslatorProvider } from '../translator/provider.js';
+import '../translator/context.js';
+
+const IntorProvider = ({ value: { config, pathname = "", initialLocale, messages = config.messages, onLocaleChange, isLoading, }, children, }) => {
+    return (jsx(ConfigProvider, { value: { config, pathname }, children: jsx(MessagesProvider, { value: { messages }, children: jsx(LocaleProvider, { value: { initialLocale, onLocaleChange }, children: jsx(TranslatorProvider, { value: { isLoading }, children: children }) }) }) }));
+};
+
+export { IntorProvider };

package/dist/src/client/react/contexts/intor-provider/types.d.ts

@@ -0,0 +1,14 @@
+import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+import type * as React from "react";
+import { type Locale, type LocaleMessages } from "intor-translator";
+export interface IntorProviderProps {
+    value: {
+        config: IntorResolvedConfig;
+        initialLocale: Locale;
+        pathname?: string;
+        messages?: Readonly<LocaleMessages>;
+        onLocaleChange?: (newLocale: string) => Promise<void> | void;
+        isLoading?: boolean;
+    };
+    children: React.ReactNode;
+}

package/dist/src/client/react/contexts/locale/context.d.ts

@@ -0,0 +1,3 @@
+import type { LocaleContextValue } from "./types";
+import * as React from "react";
+export declare const LocaleContext: React.Context<LocaleContextValue | undefined>;

package/dist/src/client/react/contexts/locale/context.js

@@ -0,0 +1,6 @@
+import * as React from 'react';
+
+// context
+const LocaleContext = React.createContext(undefined);
+
+export { LocaleContext };

package/dist/src/client/react/contexts/locale/hook.d.ts

@@ -0,0 +1 @@
+export declare function useLocale(): import("./types").LocaleContextValue;

package/dist/src/client/react/contexts/locale/hook.js

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { LocaleContext } from './context.js';
+
+// hook
+function useLocale() {
+    const context = React.useContext(LocaleContext);
+    if (!context)
+        throw new Error("useLocale must be used within a LocaleProvider");
+    return context;
+}
+
+export { useLocale };

package/dist/src/client/react/contexts/locale/index.d.ts

@@ -0,0 +1,2 @@
+export { LocaleProvider } from "./provider";
+export { useLocale } from "./hook";

package/dist/src/client/react/contexts/locale/provider.d.ts

@@ -0,0 +1,3 @@
+import type { LocaleProviderProps } from "./types";
+import * as React from "react";
+export declare function LocaleProvider({ value: { initialLocale, onLocaleChange }, children, }: LocaleProviderProps): React.JSX.Element;

package/dist/src/client/react/contexts/locale/provider.js

@@ -0,0 +1,48 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import * as React from 'react';
+import '../config/context.js';
+import { useConfig } from '../config/hook.js';
+import { useInitLocaleCookie } from './utils/use-init-locale-cookie.js';
+
+
+
+import '../../../../config/constants/cache.constants.js';
+
+
+
+
+import '../messages/context.js';
+import { useMessages } from '../messages/hook.js';
+import { LocaleContext } from './context.js';
+import { changeLocale } from './utils/change-locale.js';
+
+// provider
+function LocaleProvider({ value: { initialLocale, onLocaleChange }, children, }) {
+    const { config } = useConfig();
+    const { refetchMessages } = useMessages();
+    const { loader, cookie } = config;
+    // Current locale
+    const [currentLocale, setCurrentLocale] = React.useState(initialLocale);
+    useInitLocaleCookie({ config, locale: initialLocale }); // Hook: Initialize cookie (If cookie not exist yet)
+    // Change locale and set cookie (If using dynamic api: refetch messages)
+    const setLocale = React.useCallback(async (newLocale) => {
+        changeLocale({
+            currentLocale,
+            newLocale,
+            loader,
+            cookie,
+            setLocale: setCurrentLocale,
+            refetchMessages,
+        });
+        onLocaleChange?.(newLocale);
+    }, [currentLocale, loader, cookie, refetchMessages, onLocaleChange]);
+    // context value
+    const value = React.useMemo(() => ({
+        locale: currentLocale,
+        setLocale,
+    }), [currentLocale, setLocale]);
+    return (jsx(LocaleContext.Provider, { value: value, children: children }));
+}
+
+export { LocaleProvider };

package/dist/src/client/react/contexts/locale/types.d.ts

@@ -0,0 +1,13 @@
+import type { Locale } from "intor-translator";
+import type * as React from "react";
+export type LocaleContextValue = {
+    locale: Locale;
+    setLocale: (locale: Locale) => void;
+};
+export type LocaleProviderProps = {
+    value: {
+        initialLocale: string;
+        onLocaleChange?: (newLocale: string) => Promise<void> | void;
+    };
+    children: React.ReactNode;
+};