intor 2.2.14 → 2.2.15

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/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 };