intor 2.3.3 → 2.3.5

package/dist/react/src/server/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.js

@@ -0,0 +1,25 @@
+/**
+ * Build URLSearchParams from an object.
+ * Supports string or string[] values. Ignores undefined/null.
+ */
+const buildSearchParams = (params) => {
+    const searchParams = new URLSearchParams();
+    const appendParam = (key, value) => {
+        if (value === undefined || value === null)
+            return;
+        if (Array.isArray(value) && value.length === 0)
+            return;
+        if (Array.isArray(value)) {
+            value.forEach((v) => v && searchParams.append(key, v));
+        }
+        else {
+            searchParams.append(key, value);
+        }
+    };
+    Object.entries(params).forEach(([key, value]) => {
+        appendParam(key, value);
+    });
+    return searchParams;
+};
+
+export { buildSearchParams };

package/dist/react/src/server/messages/load-remote-messages/load-remote-messages.js

@@ -0,0 +1,110 @@
+import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
+import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
+import { buildSearchParams } from './fetch-locale-messages/utils/build-search-params.js';
+import { getLogger } from '../../shared/logger/get-logger.js';
+import { getGlobalMessagesPool } from '../../shared/messages/global-messages-pool.js';
+import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-cache-key.js';
+
+/**
+ * Load locale messages from a remote API.
+ *
+ * This function acts as the orchestration layer for remote message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Respecting abort signals across the entire async flow
+ *
+ * Network fetching and data validation are delegated to lower-level utilities.
+ */
+const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, locale, fallbackLocales, namespaces, remoteUrl, remoteHeaders, extraOptions: { cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, } = {}, allowCacheWrite = false, signal, }) => {
+    const baseLogger = getLogger({ ...loggerOptions });
+    const logger = baseLogger.child({ scope: "load-remote-messages" });
+    // Abort early if the request has already been cancelled
+    if (signal?.aborted) {
+        logger.debug("Remote message loading aborted before fetch.");
+        return;
+    }
+    const start = performance.now();
+    logger.debug("Loading remote messages.", { remoteUrl });
+    // --- Cache key
+    const cacheKey = normalizeCacheKey([
+        loggerOptions.id,
+        "loaderType:remote",
+        rootDir,
+        locale,
+        (fallbackLocales ?? []).toSorted().join(","),
+        (namespaces ?? []).toSorted().join(","),
+    ]);
+    // --- Cache read --------------------------------------------------
+    if (cacheOptions.enabled && cacheKey) {
+        const cached = await pool?.get(cacheKey);
+        if (signal?.aborted) {
+            logger.debug("Remote message loading aborted after cache read.");
+            return;
+        }
+        if (cached) {
+            logger.debug("Messages cache hit.", { key: cacheKey });
+            return cached;
+        }
+    }
+    const candidateLocales = [locale, ...(fallbackLocales || [])];
+    let messages;
+    // Try each candidate locale in order and stop at the first successful result
+    for (let i = 0; i < candidateLocales.length; i++) {
+        const candidateLocale = candidateLocales[i];
+        const isLast = i === candidateLocales.length - 1;
+        try {
+            const fetched = await fetchLocaleMessages({
+                remoteUrl,
+                remoteHeaders,
+                locale: candidateLocale,
+                searchParams: buildSearchParams({ rootDir, namespaces }),
+                extraOptions: { loggerOptions },
+                signal,
+            });
+            // Stop at the first locale that yields non-empty messages
+            if (fetched && Object.values(fetched[candidateLocale] || {}).length > 0) {
+                messages = fetched;
+                break;
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                logger.debug("Remote message loading aborted.");
+                return;
+            }
+            if (isLast) {
+                logger.warn("Failed to load messages for all candidate locales.", {
+                    locale,
+                    fallbackLocales,
+                });
+            }
+            else {
+                logger.warn(`Failed to fetch locale messages for "${candidateLocale}", trying next fallback.`);
+            }
+            logger.trace("Remote fetch error detail.", {
+                locale: candidateLocale,
+                error,
+            });
+        }
+    }
+    // --- Cache write --------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
+        if (signal?.aborted) {
+            logger.debug("Remote message loading aborted before cache write.");
+            return;
+        }
+        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+    }
+    // Final success log with resolved locale and timing
+    if (messages) {
+        logger.trace("Finished loading remote messages.", {
+            loadedLocale: messages ? Object.keys(messages)[0] : undefined,
+            duration: `${Math.round(performance.now() - start)} ms`,
+        });
+    }
+    return messages;
+};
+
+export { loadRemoteMessages };

package/dist/react/src/server/messages/shared/utils/is-valid-messages.js

@@ -0,0 +1,36 @@
+/** Check if a value is a plain object (not null, not array) */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Check if a value is a valid **Messages** object.
+ *
+ * - Uses an iterative approach to avoid stack overflow with deeply nested objects.
+ *
+ * @example
+ * ```ts
+ * isValidMessages({ en: { hello: "Hello" } }) // true
+ * isValidMessages({ en: { count: 5 } }) // false
+ * ```
+ */
+function isValidMessages(value) {
+    if (!isPlainObject(value))
+        return false;
+    const stack = [value];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const v of Object.values(current)) {
+            if (typeof v === "string")
+                continue;
+            if (isPlainObject(v)) {
+                stack.push(v);
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+export { isPlainObject, isValidMessages };

package/dist/react/src/server/shared/logger/get-logger.js

@@ -0,0 +1,39 @@
+import { logry } from 'logry';
+import { getGlobalLoggerPool } from './global-logger-pool.js';
+
+const DEFAULT_FORMAT_CONFIG = {
+    timestamp: { withDate: false },
+};
+const DEFAULT_RENDER_CONFIG = {
+    timestamp: {},
+    id: { visible: true, prefix: "<", suffix: ">" },
+    meta: { lineBreaksAfter: 1 },
+};
+/**
+ * Get a shared logger instance by id.
+ * - Safe across hot reloads
+ * - Prevents unbounded memory usage via soft LRU
+ */
+function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
+    const pool = getGlobalLoggerPool();
+    let logger = pool.get(id);
+    if (!logger) {
+        logger = logry({
+            id,
+            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
+            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
+            preset,
+            ...options,
+        });
+        pool.set(id, logger);
+        // Soft LRU: keep pool size under control
+        if (pool.size > 1000) {
+            const keys = [...pool.keys()];
+            for (const key of keys.slice(0, 200))
+                pool.delete(key);
+        }
+    }
+    return logger;
+}
+
+export { getLogger };

package/dist/react/src/server/shared/logger/global-logger-pool.js

@@ -0,0 +1,8 @@
+function getGlobalLoggerPool() {
+    if (!globalThis.__INTOR_LOGGER_POOL__) {
+        globalThis.__INTOR_LOGGER_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_LOGGER_POOL__;
+}
+
+export { getGlobalLoggerPool };

package/dist/react/src/server/shared/messages/global-messages-pool.js

@@ -0,0 +1,10 @@
+import Keyv from 'keyv';
+
+function getGlobalMessagesPool() {
+    if (!globalThis.__INTOR_MESSAGES_POOL__) {
+        globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+    }
+    return globalThis.__INTOR_MESSAGES_POOL__;
+}
+
+export { getGlobalMessagesPool };

package/dist/react/src/shared/utils/deep-merge.js

@@ -0,0 +1,36 @@
+/**
+ * Deeply merges two objects.
+ * - Nested objects → merged recursively
+ * - Array / primitive → b overwrites a
+ */
+const deepMerge = (a, b) => {
+    if (!a && !b)
+        return undefined;
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    const result = { ...a };
+    for (const key in b) {
+        if (Object.prototype.hasOwnProperty.call(b, key)) {
+            const av = a[key];
+            const bv = b[key];
+            if (av &&
+                bv &&
+                typeof av === "object" &&
+                typeof bv === "object" &&
+                !Array.isArray(av) &&
+                !Array.isArray(bv)) {
+                // recursive merge
+                result[key] = deepMerge(av, bv);
+            }
+            else {
+                // overwrite with primitive or array
+                result[key] = bv;
+            }
+        }
+    }
+    return result;
+};
+
+export { deepMerge };

package/dist/react/src/shared/utils/normalizers/normalize-cache-key.js

@@ -0,0 +1,45 @@
+const CACHE_KEY_DELIMITER = "|";
+const sanitize = (k) => k
+    .replaceAll(/[\u200B-\u200D\uFEFF]/g, "")
+    .replaceAll(/[\r\n]/g, "")
+    .trim();
+/**
+ * Normalizes a value into a stable cache key string.
+ *
+ * - Supports primitive values and structured array keys.
+ * - Produces deterministic output suitable for cache identifiers.
+ *
+ * Notes:
+ * - `null`, `undefined`, or empty arrays return `null`.
+ * - Special tokens are used for boolean, null, and undefined values
+ *   to preserve semantic differences.
+ */
+const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+    // Treat nullish values as "no cache key"
+    if (key === null || key === undefined)
+        return null;
+    if (Array.isArray(key)) {
+        // Empty array produces no meaningful cache key
+        if (key.length === 0)
+            return null;
+        const normalized = key.map((k) => {
+            // Preserve semantic differences for special values
+            if (k === null)
+                return "__null";
+            if (k === undefined)
+                return "__undefined";
+            if (typeof k === "boolean")
+                return k ? "__true" : "__false";
+            return sanitize(String(k));
+        });
+        // Join segments into a single deterministic cache key
+        return normalized.join(delimiter);
+    }
+    // Normalize boolean primitives explicitly
+    if (typeof key === "boolean")
+        return key ? "__true" : "__false";
+    // Fallback: stringify primitive values
+    return String(key);
+};
+
+export { normalizeCacheKey };

package/dist/react/src/shared/utils/normalizers/normalize-locale.js

@@ -0,0 +1,59 @@
+const toCanonical = (input) => {
+    try {
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+};
+/**
+ * Normalizes a locale string and resolves the best match
+ * from a list of supported locales.
+ *
+ * Resolution strategy:
+ *
+ * 1. Exact canonical match (BCP 47)
+ * 2. Base language fallback
+ *    - Falls back by base language when no exact match is found
+ *      (e.g. `"en"` → `"en-US"`).
+ *    - Script and region subtags are ignored during this step
+ *      (e.g. `"zh-Hans"` → `"zh-Hant-TW"`)
+ *    - Preference is determined by the order of `supportedLocales`.
+ *
+ * Returns `undefined` if no suitable match is found.
+ *
+ * Notes:
+ * - Invalid locale inputs are ignored gracefully.
+ * - Always returns an original entry from `supportedLocales`.
+ * - Requires `Intl` locale support in the runtime.
+ */
+const normalizeLocale = (locale, supportedLocales = []) => {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalLocale = toCanonical(locale);
+    if (!canonicalLocale)
+        return;
+    const supportedCanonicalMap = new Map();
+    for (const l of supportedLocales) {
+        const normalized = toCanonical(l);
+        if (normalized) {
+            supportedCanonicalMap.set(normalized, l);
+        }
+    }
+    // 1. Exact match
+    if (supportedCanonicalMap.has(canonicalLocale)) {
+        return supportedCanonicalMap.get(canonicalLocale);
+    }
+    const baseLang = canonicalLocale.split("-")[0];
+    // 2. Match by same base language (e.g., "en" matches "en-US" or "en-GB")
+    for (const [key, original] of supportedCanonicalMap) {
+        const supportedBase = key.split("-")[0];
+        if (supportedBase === baseLang) {
+            return original;
+        }
+    }
+    // 3. No match
+    return;
+};
+
+export { normalizeLocale };

package/dist/types/export/config/index.d.ts

@@ -0,0 +1 @@
+export { defineIntorConfig, type IntorRawConfig, type IntorResolvedConfig, } from "../../src/config";

package/dist/types/export/index.d.ts

@@ -0,0 +1,4 @@
+export { PREFIX_PLACEHOLDER } from "../src/shared/constants";
+export { localizePathname, } from "../src/shared/utils";
+export { IntorError, IntorErrorCode } from "../src/shared/error";
+export { type TranslatorPlugin, type TranslateHandlers, type FormatHandler, type LoadingHandler, type MissingHandler, type HandlerContext, type TranslateContext, type TranslateHook, type LocaleMessages, } from "intor-translator";

package/dist/types/export/internal/index.d.ts

@@ -0,0 +1 @@
+export type { INTOR_GENERATED_KEY, GenConfigKeys, GenConfig, GenMessages, GenLocale, MessageKey, TranslatorInstance, } from "../../src/shared/types";

package/dist/types/export/next/index.d.ts

@@ -0,0 +1 @@
+export { Link, usePathname, useRouter, redirect, } from "../../src/adapters/next/navigation";

package/dist/types/export/next/proxy/index.d.ts

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

package/dist/types/export/next/server/index.d.ts

@@ -0,0 +1 @@
+export { getLocale, getTranslator } from "../../../src/adapters/next/server";

package/dist/types/export/react/index.d.ts

@@ -0,0 +1 @@
+export { IntorProvider, type IntorProviderProps, TranslatorRuntimeProvider, type TranslatorRuntimeProviderProps, useConfig, useLocale, useTranslator, T, getClientLocale, } from "../../src/client/react";

package/dist/types/export/server/index.d.ts

@@ -0,0 +1 @@
+export { intor, type IntorResult, loadMessages, isValidMessages, type Messages, type MessagesReader, getTranslator, clearLoggerPool, clearMessagesPool, setGlobalMessagesPool, loadLocalMessagesFromUrl, } from "../../src/server";

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

@@ -0,0 +1,26 @@
+import type { GenConfigKeys, GenLocale } from "../../../shared/types/generated";
+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<CK extends GenConfigKeys = "__default__"> extends Omit<NextLinkProps, "href">, Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    href?: Url;
+    /**
+     * Locale to navigate with.
+     *
+     * If `href` is omitted, the current route is used as the navigation target.
+     */
+    locale?: GenLocale<CK>;
+}
+/**
+ * Locale-aware Link component.
+ *
+ * Wraps Next.js `Link`
+ *
+ * - Resolves a locale-aware navigation destination
+ * - Preserves external navigation behavior
+ * - Switches locale via client state or full reload when required
+ *
+ * This component is responsible only for executing the resolved target.
+ */
+export declare const Link: <CK extends GenConfigKeys = "__default__">({ href, locale, children, onClick, ...props }: LinkProps<CK>) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { GenConfigKeys, GenLocale } from "../../../shared/types/generated";
+import type { RedirectType } from "next/navigation";
+/**
+ * Locale-aware redirect helper (server-only).
+ *
+ * Wraps Next.js `redirect`
+ *
+ * - Resolves the effective locale before redirecting
+ * - Applies locale prefix for internal destinations
+ * - Bypasses localization for external destinations
+ */
+export declare const redirect: <CK extends GenConfigKeys = "__default__">({ config, locale, url, type, }: {
+    config: IntorResolvedConfig;
+    locale?: GenLocale<CK>;
+    url: string;
+    type?: RedirectType | undefined;
+}) => Promise<undefined>;

package/dist/{src → types/src}/adapters/next/navigation/use-pathname.d.ts

@@ -6,12 +6,12 @@
  *
  * @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"
+ * // localizedPathname => "/en-US/about"
+ * // standardizedPathname => "/{locale}/about"
+ * // unprefixedPathname => "/about"
  */
 export declare const usePathname: () => {
-    localizedPathname: string;
-    standardizedPathname: string;
     unprefixedPathname: string;
+    standardizedPathname: string;
+    localizedPathname: string;
 };

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

@@ -0,0 +1,25 @@
+import type { GenConfigKeys, GenLocale } from "../../../shared/types/generated";
+import type { NavigateOptions, PrefetchOptions } from "next/dist/shared/lib/app-router-context.shared-runtime";
+/**
+ * Locale-aware router hook.
+ *
+ * Wraps Next.js `useRouter`
+ *
+ * - Resolve locale-aware navigation targets
+ * - Decide execution strategy (client-side vs full reload)
+ * - Preserve correct behavior across navigation types
+ */
+export declare const useRouter: () => {
+    back(): void;
+    forward(): void;
+    refresh(): void;
+    push: <CK extends GenConfigKeys = "__default__">(href: string, options?: NavigateOptions & {
+        locale?: GenLocale<CK>;
+    }) => void;
+    replace: <CK extends GenConfigKeys = "__default__">(href: string, options?: NavigateOptions & {
+        locale?: GenLocale<CK>;
+    }) => void;
+    prefetch: <CK extends GenConfigKeys = "__default__">(href: string, options?: PrefetchOptions & {
+        locale?: GenLocale<CK>;
+    }) => void;
+};

package/dist/types/src/adapters/next/proxy/index.d.ts

@@ -0,0 +1 @@
+export { intorProxy } from "./intor-proxy";

package/dist/types/src/adapters/next/proxy/intor-proxy.d.ts

@@ -0,0 +1,13 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { NextRequest } from "next/server";
+/**
+ * Next.js routing adapter for Intor.
+ *
+ * Responsibilities:
+ * - Collect locale candidates from request-related sources
+ * - Delegate routing decisions to the routing core
+ * - Apply redirect behavior when required
+ * - Materialize routing decisions into persistent state (cookie)
+ *   with configurable first-visit behavior
+ */
+export declare const intorProxy: (config: IntorResolvedConfig, request: NextRequest) => Promise<Response>;

package/dist/{src → types/src}/adapters/next/proxy/utils/set-locale-cookie-edge.d.ts

@@ -1,15 +1,13 @@
 import type { CookieResolvedOptions } from "../../../../config/types/cookie.types";
-import type { NextRequest, NextResponse } from "next/server";
+import type { 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 declare function setLocaleCookieEdge({ response, cookie, locale, }: SetLocaleCookieParams): void;
 export {};

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

@@ -0,0 +1,6 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+import type { GenConfigKeys, GenLocale } from "../../../shared/types/generated";
+/**
+ * Get the locale for the current Next.js request.
+ */
+export declare const getLocale: <CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig) => Promise<GenLocale<CK>>;

package/dist/{src → types/src}/adapters/next/server/get-translator.d.ts

@@ -1,19 +1,17 @@
 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";
+import type { GenConfigKeys, GenMessages, IfGen } from "../../../shared/types/generated";
+import type { TranslatorInstance } from "../../../shared/types/translator-instance";
+import type { LocalizedNodeKeys, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 /**
- * Create a translator instance ready for the current Next.js SSR environment.
+ * Create a translator instance 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.
+ * - Automatically resolves the current locale using the Next.js adapter.
  */
 export declare function getTranslator<CK extends GenConfigKeys = "__default__">(options: {
     config: IntorResolvedConfig;
     handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;
@@ -22,6 +20,7 @@ export declare function getTranslator<CK extends GenConfigKeys = "__default__">(
 export declare function getTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(options: {
     config: IntorResolvedConfig;
     handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;

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

@@ -0,0 +1,2 @@
+export { getLocale } from "./get-locale";
+export { getTranslator } from "./get-translator";

package/dist/types/src/client/helpers/get-client-locale.d.ts

@@ -0,0 +1,11 @@
+import type { IntorResolvedConfig } from "../../config";
+/**
+ * Resolve the locale in a client-only environment.
+ *
+ * This helper is intended for pure CSR setups (e.g. Vite).
+ *
+ * For framework-based apps, prefer `useTranslator()`.
+ *
+ * - Client-side only
+ */
+export declare function getClientLocale(config: IntorResolvedConfig): string;

package/dist/types/src/client/helpers/index.d.ts

@@ -0,0 +1 @@
+export { getClientLocale } from "./get-client-locale";

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

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

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

@@ -1,10 +1,11 @@
 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;
+    value: {
+        config: IntorResolvedConfig;
+    };
     children: React.ReactNode;
 };
+export type ConfigContextValue = {
+    config: IntorResolvedConfig;
+};

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

@@ -0,0 +1,6 @@
+export { IntorProvider, type IntorProviderProps } from "./intor-provider";
+export { ConfigProvider, useConfig } from "./config";
+export { LocaleProvider, useLocale } from "./locale";
+export { MessagesProvider, useMessages } from "./messages";
+export { TranslatorProvider, useTranslator } from "./translator";
+export { TranslatorRuntimeProvider, type TranslatorRuntimeProviderProps, useTranslatorRuntime, } from "./translator-runtime";

package/dist/types/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, initialLocale, messages, onLocaleChange, isLoading, }, children, }: IntorProviderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,11 +1,10 @@
 import type { IntorResolvedConfig } from "../../../../config/types/intor-config.types";
+import type { Locale, LocaleMessages } from "intor-translator";
 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;