intor 2.3.13 → 2.3.15

package/dist/express/src/server/messages/load-messages.js

@@ -2,7 +2,6 @@ import '../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import { getLogger } from '../../core/logger/get-logger.js';
 import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
-import 'keyv';
 import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
 
 /**
@@ -18,7 +17,7 @@ import { loadLocalMessages } from './load-local-messages/load-local-messages.js'
  * Message traversal, parsing, fallback resolution, and caching logic
  * are delegated to the selected loader.
  */
-const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = false, }) => {
+const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, }) => {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "load-messages" });
     // ---------------------------------------------------------------------------
@@ -29,15 +28,15 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces } = loader;
+    const { type, namespaces, rootDir } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
         loaderType: type,
+        rootDir,
         locale,
-        fallbackLocales,
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : ["*"],
-        cache: config.cache,
+        fallbackLocales: fallbackLocales.join(", "),
+        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
     });
     // ---------------------------------------------------------------------------
     // Dispatch to loader implementation
@@ -49,24 +48,21 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
             locale,
             fallbackLocales,
             namespaces,
-            rootDir: loader.rootDir,
+            rootDir,
             concurrency: loader.concurrency,
-            readOptions,
+            readers,
             allowCacheWrite,
             loggerOptions: config.logger,
         });
     }
     else if (type === "remote") {
         loadedMessages = await loadRemoteMessages({
-            id: config.id,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir: loader.rootDir,
+            rootDir,
             url: loader.url,
             headers: loader.headers,
-            allowCacheWrite,
-            cacheOptions: config.cache,
             loggerOptions: config.logger,
         });
     }

package/dist/express/src/server/runtime/create-intor-runtime.js

@@ -1,6 +1,6 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import 'logry';
-import 'keyv';
 import { loadMessages } from '../messages/load-messages.js';
 import { createTranslator } from '../translator/create-translator.js';
 
@@ -14,20 +14,24 @@ import { createTranslator } from '../translator/create-translator.js';
  * before a translator snapshot can be created.
  */
 function createIntorRuntime(config, options) {
+    const loader = resolveLoaderOptions(config);
     // Locale that has completed the ensureMessages() phase
     let ensuredLocale;
     // Messages prepared during ensureMessages(); may be empty
     let ensuredMessages;
     return {
         async ensureMessages(locale) {
-            const messages = await loadMessages({
-                config,
-                locale,
-                readOptions: options?.readOptions,
-                allowCacheWrite: options?.allowCacheWrite ?? false,
-            });
+            let messages;
+            if (loader) {
+                messages = await loadMessages({
+                    config,
+                    locale,
+                    readers: options?.readers,
+                    allowCacheWrite: options?.allowCacheWrite || false,
+                });
+            }
             ensuredLocale = locale;
-            ensuredMessages = messages;
+            ensuredMessages = messages || {};
         },
         translator(locale, options) {
             // Guard: translator requires ensureMessages() to be completed for this locale

package/dist/express/src/server/translator/create-translator.js

@@ -34,6 +34,7 @@ function createTranslator(params) {
         locale,
         hasKey: scoped ? scoped.hasKey : translator.hasKey,
         t: scoped ? scoped.t : translator.t,
+        tRaw: scoped ? scoped.tRaw : translator.tRaw,
     };
 }
 

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

@@ -1,7 +1,6 @@
 import { redirect as redirect$1 } from 'next/navigation';
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
 import { getLocale } from '../server/get-locale.js';
 

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

@@ -2,7 +2,6 @@ import { usePathname as usePathname$1 } from 'next/navigation';
 import { useIntor } from 'intor/react';
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 import { localizePathname } from '../../../routing/pathname/localize-pathname.js';
 
 /**

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

@@ -3,7 +3,6 @@ import { INTOR_HEADERS } from '../../../core/constants/headers.js';
 import '../../../core/error/intor-error.js';
 import { normalizeQuery } from '../../../core/utils/normalizers/normalize-query.js';
 import 'logry';
-import 'keyv';
 import { resolveInbound } from '../../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-from-accept-language.js';
 
@@ -19,7 +18,7 @@ import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-
 const intorProxy = async (config, request) => {
     // locale from accept-language header
     const acceptLanguageHeader = request.headers.get("accept-language");
-    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(config, acceptLanguageHeader);
+    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguageHeader, config.supportedLocales);
     // Check whether this navigation flow has already redirected
     const hasRedirectedForLocale = request.headers.get("x-intor-redirected") === "1";
     // ----------------------------------------------------------

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

@@ -2,7 +2,6 @@ import { headers } from 'next/headers';
 import { INTOR_HEADERS } from '../../../core/constants/headers.js';
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Get the locale for the current execution context.

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

@@ -2,7 +2,6 @@ import { headers } from 'next/headers';
 import { INTOR_HEADERS } from '../../../core/constants/headers.js';
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 import { localizePathname } from '../../../routing/pathname/localize-pathname.js';
 
 /**

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

@@ -1,6 +1,5 @@
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 import 'node:path';
 import 'p-limit';
 import 'node:fs/promises';
@@ -10,14 +9,14 @@ import { getLocale } from './get-locale.js';
 
 // Implementation
 async function getTranslator(config, params) {
-    const { preKey, handlers, plugins, readOptions } = params || {};
+    const { preKey, handlers, plugins, readers, allowCacheWrite } = params || {};
     return getTranslator$1(config, {
         locale: await getLocale(config),
         preKey,
         handlers,
         plugins,
-        readOptions,
-        allowCacheWrite: false,
+        readers,
+        allowCacheWrite,
     });
 }
 

package/dist/next/src/adapters/next/server/intor.js

@@ -1,6 +1,5 @@
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 import { intor as intor$1 } from '../../../server/intor/intor.js';
 import 'node:path';
 import 'p-limit';
@@ -15,9 +14,9 @@ import { getLocale } from './get-locale.js';
  * - Acts as the bootstrap entry where cache writes are permitted.
  * @platform Next.js
  */
-async function intor(config, readOptions) {
+async function intor(config, readers) {
     return await intor$1(config, getLocale, {
-        readOptions,
+        readers,
         allowCacheWrite: true,
     });
 }

package/dist/next/src/core/messages/global-messages-pool.js

@@ -1,8 +1,14 @@
-import Keyv from 'keyv';
-
+/**
+ * Get the global messages pool.
+ *
+ * Lazily initialized to ensure:
+ * - Cross-module sharing
+ * - Dev / HMR safety
+ */
 function getGlobalMessagesPool() {
     if (!globalThis.__INTOR_MESSAGES_POOL__) {
-        globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+        const pool = new Map();
+        globalThis.__INTOR_MESSAGES_POOL__ = pool;
     }
     return globalThis.__INTOR_MESSAGES_POOL__;
 }

package/dist/next/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -1,5 +1,4 @@
 import { getLogger } from '../../logger/get-logger.js';
-import { normalizeCacheKey } from '../../utils/normalizers/normalize-cache-key.js';
 import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
 
 /**
@@ -9,12 +8,11 @@ import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messag
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - 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 ({ id, locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -25,31 +23,6 @@ const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, roo
     const start = performance.now();
     logger.debug("Loading remote messages.", { url });
     // ---------------------------------------------------------------------------
-    // Cache key resolution
-    // ---------------------------------------------------------------------------
-    const cacheKey = normalizeCacheKey([
-        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;
-        }
-    }
-    // ---------------------------------------------------------------------------
     // Resolve locale messages with ordered fallback strategy
     // ---------------------------------------------------------------------------
     const candidateLocales = [locale, ...(fallbackLocales || [])];
@@ -93,18 +66,6 @@ const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, roo
             });
         }
     }
-    // ---------------------------------------------------------------------------
-    // Cache write (explicitly permitted)
-    // ---------------------------------------------------------------------------
-    if (cacheOptions.enabled && allowCacheWrite) {
-        if (signal?.aborted) {
-            logger.debug("Remote message loading aborted before cache write.");
-            return;
-        }
-        if (cacheKey && messages) {
-            await pool?.set(cacheKey, messages, cacheOptions.ttl);
-        }
-    }
     // Final success log with resolved locale and timing
     if (messages) {
         logger.trace("Finished loading remote messages.", {

package/dist/next/src/core/messages/utils/is-valid-messages.js

@@ -3,15 +3,10 @@ function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
- * Check if a value is a valid **Messages** object.
+ * Check if a value is a valid MessageObject.
  *
- * - Uses an iterative approach to avoid stack overflow with deeply nested objects.
- *
- * @example
- * ```ts
- * isValidMessages({ en: { hello: "Hello" } }) // true
- * isValidMessages({ en: { count: 5 } }) // false
- * ```
+ * - Supports all MessageValue variants (primitive, array, object).
+ * - Uses an iterative approach to avoid stack overflow.
  */
 function isValidMessages(value) {
     if (!isPlainObject(value))
@@ -19,16 +14,29 @@ function isValidMessages(value) {
     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);
+        // primitives are always valid
+        if (current === null ||
+            typeof current === "string" ||
+            typeof current === "number" ||
+            typeof current === "boolean") {
+            continue;
+        }
+        // array → validate each item
+        if (Array.isArray(current)) {
+            for (const item of current) {
+                stack.push(item);
             }
-            else {
-                return false;
+            continue;
+        }
+        // object → validate each value
+        if (isPlainObject(current)) {
+            for (const v of Object.values(current)) {
+                stack.push(v);
             }
+            continue;
         }
+        // everything else is invalid
+        return false;
     }
     return true;
 }

package/dist/next/src/policies/shoud-full-reload.js

@@ -1,7 +1,6 @@
 import '../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../core/utils/resolve-loader-options.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Determine whether client-side navigation must be forced to reload.

package/dist/next/src/routing/inbound/resolve-inbound.js

@@ -1,6 +1,3 @@
-import '../../core/error/intor-error.js';
-import 'logry';
-import 'keyv';
 import { getLocaleFromPathname } from '../locale/get-locale-from-pathname.js';
 import { getLocaleFromHost } from '../locale/get-locale-from-host.js';
 import { getLocaleFromQuery } from '../locale/get-locale-from-query.js';
@@ -21,11 +18,13 @@ async function resolveInbound(config, rawPathname, hasRedirected, localeInputs)
     // ------------------------------------------------------
     // Resolve locale from inbound inputs
     // ------------------------------------------------------
-    const pathLocale = getLocaleFromPathname(config, rawPathname);
+    const pathLocale = getLocaleFromPathname(rawPathname, config);
     const { locale, localeSource } = resolveLocale(config, {
         path: { locale: pathLocale },
-        host: { locale: getLocaleFromHost(config, host) },
-        query: { locale: getLocaleFromQuery(config, query) },
+        host: { locale: getLocaleFromHost(host) },
+        query: {
+            locale: getLocaleFromQuery(query, config.routing.inbound.queryKey),
+        },
         cookie: { locale: cookie },
         detected: { locale: detected },
     });

package/dist/next/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,23 +1,30 @@
+import '../../../core/error/intor-error.js';
+import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import 'logry';
+
 /**
- * Resolves the active locale from inbound routing configuration.
+ * Resolve the active locale from inbound routing configuration.
  *
- * The first matching locale from the configured sources is used,
- * with the detected locale as a guaranteed fallback.
+ * Iterates through configured locale sources and returns the first
+ * normalized, supported locale. Falls back to the detected locale
+ * or the default locale if none match.
  */
 function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        if (!locale)
+        const normalized = normalizeLocale(locale, config.supportedLocales);
+        if (!normalized)
             continue;
         return {
-            locale,
+            locale: normalized,
             localeSource: source,
         };
     }
     // Fallback: detected is always available
     return {
-        locale: context.detected.locale,
+        locale: normalizeLocale(context.detected.locale, config.supportedLocales) ||
+            config.defaultLocale,
         localeSource: "detected",
     };
 }

package/dist/next/src/routing/locale/get-locale-from-accept-language.js

@@ -1,30 +1,20 @@
-import '../../core/error/intor-error.js';
-import { normalizeLocale } from '../../core/utils/normalizers/normalize-locale.js';
-import 'logry';
-import 'keyv';
-
 /**
- * Resolve locale from the `Accept-Language` header.
- *
- * - Parses language priorities (`q` values) from the header.
- * - Selects the highest-priority language supported by the application.
- * - Normalizes the matched locale against `supportedLocales`.
+ * Get locale candidate from the `Accept-Language` header.
  *
- * If no supported locale can be resolved, `undefined` is returned.
+ * Parses language priorities and returns the highest-priority
+ * language present in `supportedLocales`, without normalization.
  *
  * @example
  * ```ts
  * getLocaleFromAcceptLanguage("en-US,en;q=0.8,zh-TW;q=0.9", ["en-US", "zh-TW"])
  * // => "en-US"
+ *
  * getLocaleFromAcceptLanguage("fr,ja;q=0.9", ["en", "zh-TW"])
  * // => undefined
  * ```
  */
-const getLocaleFromAcceptLanguage = (config, acceptLanguageHeader) => {
-    const { supportedLocales } = config;
-    if (!acceptLanguageHeader ||
-        !supportedLocales ||
-        supportedLocales.length === 0) {
+const getLocaleFromAcceptLanguage = (acceptLanguageHeader, supportedLocales) => {
+    if (!acceptLanguageHeader || supportedLocales.length === 0) {
         return;
     }
     const supportedLocalesSet = new Set(supportedLocales);
@@ -42,7 +32,7 @@ const getLocaleFromAcceptLanguage = (config, acceptLanguageHeader) => {
     const sortedByPriority = parsedLanguages.toSorted((a, b) => b.q - a.q);
     // 3. Pick the first language explicitly supported
     const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
-    return normalizeLocale(preferred, supportedLocales);
+    return preferred;
 };
 
 export { getLocaleFromAcceptLanguage };

package/dist/next/src/routing/locale/get-locale-from-host.js

@@ -1,34 +1,32 @@
-import '../../core/error/intor-error.js';
-import { normalizeLocale } from '../../core/utils/normalizers/normalize-locale.js';
-import 'logry';
-import 'keyv';
-
 /**
- * Extract locale from hostname.
+ * Get locale candidate from hostname.
  *
- * Only the left-most subdomain is considered as a locale candidate, if present.
+ * Returns the left-most hostname label, without validation or normalization.
  *
  * @example
  * ```ts
- * getLocaleFromHost(config, "en.example.com")
+ * getLocaleFromHost("en.example.com")
  * // => "en"
- * getLocaleFromHost(config, "example.com")
- * // => undefined
- * getLocaleFromHost(config, "api.jp.example.com")
+ *
+ * getLocaleFromHost("example.com")
+ * // => "example"
+ *
+ * getLocaleFromHost("api.jp.example.com")
+ * // => "api"
+ *
+ * getLocaleFromHost("localhost")
  * // => undefined
  * ```
  */
-function getLocaleFromHost(config, host) {
+function getLocaleFromHost(host) {
     if (!host)
         return;
-    const { supportedLocales } = config;
     // Remove port (e.g. localhost:3000)
     const hostname = host.split(":")[0];
     const parts = hostname.split(".");
     if (parts.length < 2)
         return;
-    const candidate = parts[0];
-    return normalizeLocale(candidate, supportedLocales);
+    return parts[0];
 }
 
 export { getLocaleFromHost };

package/dist/next/src/routing/locale/get-locale-from-pathname.js

@@ -1,22 +1,12 @@
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
- * Extracts the locale from a pathname, if present.
+ * Get locale from pathname.
  *
- * - Normalizes the raw pathname.
- * - Strips the configured basePath.
- * - Inspects the first path segment to determine whether
- *   it matches a supported locale.
- *
- * If no locale segment is found, `undefined` is returned.
- *
- * Note:
- * - The pathname is treated as a canonical source.
- * - Only exact matches against `supportedLocales` are accepted.
- * - ___Locale normalization is intentionally not applied here.___
+ * Extracts the first pathname segment (after basePath) as a locale
+ * if it exactly matches one of the supported locales.
  *
  * @example
  * ```ts
@@ -32,7 +22,7 @@ import 'keyv';
  * // => "en"
  * ```
  */
-function getLocaleFromPathname(config, pathname) {
+function getLocaleFromPathname(pathname, config) {
     const { routing, supportedLocales } = config;
     const { basePath } = routing;
     // 1. Normalize pathname

package/dist/next/src/routing/locale/get-locale-from-query.js

@@ -1,36 +1,29 @@
-import '../../core/error/intor-error.js';
-import { normalizeLocale } from '../../core/utils/normalizers/normalize-locale.js';
-import 'logry';
-import 'keyv';
-
 /**
- * Extracts locale from URL query parameters.
- *
- * - Reads the configured locale query key.
- * - Normalizes the value against supported locales.
+ * Get locale candidate from URL query parameters.
  *
- * If no valid locale is found, `undefined` is returned.
+ * Extracts the value of the configured query key, without
+ * validation or normalization.
  *
  * @example
  * ```ts
- * getLocaleFromQuery(config, { locale: "en" })
+ * getLocaleFromQuery({ locale: "en" }, "locale")
  * // => "en"
- * getLocaleFromQuery(config, {})
+ *
+ * getLocaleFromQuery({}, "locale")
  * // => undefined
- * getLocaleFromQuery(config, { locale: ["zh-TW"] })
+ *
+ * getLocaleFromQuery({ locale: ["zh-TW"] }, "locale")
  * // => "zh-TW"
  * ```
  */
-function getLocaleFromQuery(config, query) {
+function getLocaleFromQuery(query, queryKey) {
     if (!query)
         return;
-    const { supportedLocales, routing } = config;
-    const { queryKey } = routing.inbound;
     const raw = query[queryKey];
     if (!raw)
         return;
     const value = Array.isArray(raw) ? raw[0] : raw;
-    return normalizeLocale(value, supportedLocales);
+    return value;
 }
 
 export { getLocaleFromQuery };

package/dist/next/src/routing/pathname/get-unprefixed-pathname.js

@@ -1,7 +1,6 @@
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Returns a canonical, locale-agnostic pathname.

package/dist/next/src/routing/pathname/locale-prefix-pathname.js

@@ -2,7 +2,6 @@ import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Applies the configured locale prefix behavior to a standardized pathname.

package/dist/next/src/routing/pathname/standardize-pathname.js

@@ -2,7 +2,6 @@ import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Standardizes a canonical pathname by applying the base path