intor 2.3.4 → 2.3.6

package/README.md

@@ -22,12 +22,81 @@ Fast to start, easy to extend, and free from the usual i18n heaviness.
 
 </div>
 
-#### load-messages
+---
 
-```plain
-
-[load-messages]
- |-> load-local-messages -> read-locale-messages -> collect-file-entries & parse-file-entries
- |-> load-remote-messages -> fetchLocaleMessages
+Intor separates language translation from semantic rendering.  
+ICU operates at the text-translation layer, while semantic tags  
+are parsed and rendered in a dedicated AST-based rendering phase.
 
 ```
+┌──────────────────────────────────────────────┐
+│                Application                   │
+│                                              │
+│  t() / tRich() / <T />                       │
+└───────────────────────────┬──────────────────┘
+                            │
+                            ▼
+┌──────────────────────────────────────────────┐
+│        Translator (Language / Semantic)      │
+│              intor-translator                │
+│                                              │
+│  Responsibilities:                           │
+│  - Resolve message key                       │
+│  - Locale resolution & fallback              │
+│  - Message loading                           │
+│  - Text-level interpolation                  │
+│    • {name}, {count}                         │
+│    • plural / select                         │
+│    • ICU MessageFormat (optional)            │
+│      (ignoreTag: true)                       │
+│                                              │
+│  Output:                                     │
+│  - Translated string                         │
+│  - May still contain <semantic tags>         │
+└───────────────────────────┬──────────────────┘
+                            │
+                            ▼
+┌──────────────────────────────────────────────┐
+│      Semantic Parsing & AST Construction     │
+│                                              │
+│  Responsibilities:                           │
+│  - Tokenize semantic tags                    │
+│    • <b>, <link>, <Component>                │
+│  - Build semantic AST                        │
+│    • TextNode                                │
+│    • TagNode                                 │
+│                                              │
+│  Note:                                       │
+│  - Independent from ICU / formatter          │
+│  - Pure semantic structure                   │
+└───────────────────────────┬──────────────────┘
+                            │
+                            ▼
+┌──────────────────────────────────────────────┐
+│        Semantic Rendering (Renderer)         │
+│                                              │
+│  Responsibilities:                           │
+│  - Traverse semantic AST                     │
+│  - Render TextNode                           │
+│  - Render TagNode                            │
+│                                              │
+│  Renderer decides output type:               │
+│  - string                                    │
+│  - ReactNode                                 │
+│  - Vue / Svelte nodes                        │
+│  - Markdown / CLI output                     │
+│                                              │
+│  Optional extensions:                        │
+│  - Custom tag renderers                      │
+│  - Rich components                           │
+└───────────────────────────┬──────────────────┘
+                            │
+                            ▼
+┌──────────────────────────────────────────────┐
+│                 Final Output                 │
+│                                              │
+│  - Rendered rich content                     │
+│  - Framework-specific result                 │
+│                                              │
+└──────────────────────────────────────────────┘
+```

package/dist/{export → core/export}/index.js

@@ -1,4 +1,5 @@
 export { PREFIX_PLACEHOLDER } from '../src/shared/constants/prefix-placeholder.js';
+export { deepMerge } from '../src/shared/utils/deep-merge.js';
 export { localizePathname } from '../src/shared/utils/pathname/localize-pathname.js';
 export { IntorError, IntorErrorCode } from '../src/shared/error/intor-error.js';
 import 'intor-translator';

package/dist/{export → core/export}/server/index.js

@@ -3,5 +3,5 @@ export { loadMessages } from '../../src/server/messages/load-messages.js';
 export { isValidMessages } from '../../src/server/messages/shared/utils/is-valid-messages.js';
 export { getTranslator } from '../../src/server/translator/get-translator.js';
 export { clearLoggerPool } from '../../src/server/shared/logger/global-logger-pool.js';
-export { clearMessagesPool } from '../../src/server/shared/messages/global-messages-pool.js';
+export { clearMessagesPool, setGlobalMessagesPool } from '../../src/server/shared/messages/global-messages-pool.js';
 export { loadLocalMessagesFromUrl } from '../../src/server/helpers/local-messages-from-url.js';

package/dist/{src → core/src}/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.js

@@ -73,13 +73,10 @@ async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesRe
     for (const { namespace, messages } of parsedFileEntries) {
         // Handle root-level namespace (i.e., [rootDir]/index.json)
         if (namespace === "index") {
-            const merged = deepMerge(result, messages);
-            if (merged)
-                Object.assign(result, merged);
+            Object.assign(result, deepMerge(result, messages));
         }
         else {
-            result[namespace] =
-                deepMerge(result[namespace] ?? {}, messages) || {};
+            result[namespace] = deepMerge(result[namespace], messages);
         }
     }
     return result;

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

@@ -0,0 +1,16 @@
+function getGlobalLoggerPool() {
+    if (!globalThis.__INTOR_LOGGER_POOL__) {
+        globalThis.__INTOR_LOGGER_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_LOGGER_POOL__;
+}
+/**
+ * Optional: clear all cache
+ * Useful in tests or dynamic reloads.
+ */
+function clearLoggerPool() {
+    const pool = getGlobalLoggerPool();
+    pool.clear();
+}
+
+export { clearLoggerPool, getGlobalLoggerPool };

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

@@ -0,0 +1,27 @@
+import Keyv from 'keyv';
+
+function getGlobalMessagesPool() {
+    if (!globalThis.__INTOR_MESSAGES_POOL__) {
+        globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+    }
+    return globalThis.__INTOR_MESSAGES_POOL__;
+}
+/**
+ * Replace the global messages pool.
+ *
+ * - Intended for advanced usage (e.g. Redis, custom cache backends).
+ * - Must be called during application bootstrap.
+ */
+function setGlobalMessagesPool(pool) {
+    globalThis.__INTOR_MESSAGES_POOL__ = pool;
+}
+/**
+ * Optional: clear all cache
+ * - Useful in tests or dynamic reloads.
+ */
+function clearMessagesPool() {
+    const pool = getGlobalMessagesPool();
+    pool.clear();
+}
+
+export { clearMessagesPool, getGlobalMessagesPool, setGlobalMessagesPool };

package/dist/{src → core/src}/shared/utils/deep-merge.js

@@ -1,15 +1,12 @@
 /**
  * Deeply merges two objects.
+ *
  * - Nested objects → merged recursively
  * - Array / primitive → b overwrites a
+ *
+ * This function always returns a plain object.
  */
-const deepMerge = (a, b) => {
-    if (!a && !b)
-        return undefined;
-    if (!a)
-        return b;
-    if (!b)
-        return a;
+const deepMerge = (a = {}, b = {}) => {
     const result = { ...a };
     for (const key in b) {
         if (Object.prototype.hasOwnProperty.call(b, key)) {
@@ -21,11 +18,9 @@ const deepMerge = (a, b) => {
                 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;
             }
         }

package/dist/{src → next/src}/adapters/next/navigation/link.js

@@ -3,11 +3,13 @@ import { jsx } from 'react/jsx-runtime';
 import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
 import NextLink from 'next/link';
 import 'react';
+import { usePathname } from './use-pathname.js';
 import '../../../client/react/contexts/config/context.js';
+import 'intor/react';
 import '../../../client/react/contexts/locale/context.js';
 import '../../../config/constants/cache.constants.js';
-
-
+import 'logry';
+import 'keyv';
 import '../../../client/react/contexts/messages/context.js';
 import 'intor-translator';
 import '../../../client/react/contexts/translator-runtime/context.js';
@@ -27,7 +29,8 @@ import { useNavigationStrategy } from '../../../client/react/navigation/use-navi
  * This component is responsible only for executing the resolved target.
  */
 const Link = ({ href, locale, children, onClick, ...props }) => {
-    const { resolveNavigation } = useNavigationTarget();
+    const { localizedPathname } = usePathname();
+    const { resolveNavigation } = useNavigationTarget(localizedPathname);
     const { decideNavigation } = useNavigationStrategy();
     // Normalize Next.js href input into a string destination
     const rawDestination = typeof href === "string" ? href : href ? formatUrl(href) : undefined;

package/dist/{src → next/src}/adapters/next/navigation/redirect.js

@@ -1,13 +1,13 @@
 import { redirect as redirect$1 } from 'next/navigation';
 import { getLocale } from '../server/get-locale.js';
 import 'intor-translator';
-
-
+import 'node:path';
+import 'p-limit';
 import '../../../config/constants/cache.constants.js';
-
-
+import 'node:fs/promises';
+import 'logry';
 import { localizePathname } from '../../../shared/utils/pathname/localize-pathname.js';
-
+import 'keyv';
 import { isExternalDestination } from '../../../shared/utils/is-external-destination.js';
 
 /**

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

@@ -1,10 +1,5 @@
 import { usePathname as usePathname$1 } from 'next/navigation';
-import 'react/jsx-runtime';
-import 'react';
-import '../../../client/react/contexts/config/context.js';
-import { useConfig } from '../../../client/react/contexts/config/hook.js';
-import '../../../client/react/contexts/locale/context.js';
-import { useLocale } from '../../../client/react/contexts/locale/hook.js';
+import { useConfig, useLocale } from 'intor/react';
 import { localizePathname } from '../../../shared/utils/pathname/localize-pathname.js';
 
 /**

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

@@ -1,11 +1,13 @@
 import { useRouter as useRouter$1 } from 'next/navigation';
+import { usePathname } from './use-pathname.js';
 import 'react/jsx-runtime';
 import 'react';
 import '../../../client/react/contexts/config/context.js';
+import 'intor/react';
 import '../../../client/react/contexts/locale/context.js';
 import '../../../config/constants/cache.constants.js';
-
-
+import 'logry';
+import 'keyv';
 import '../../../client/react/contexts/messages/context.js';
 import 'intor-translator';
 import '../../../client/react/contexts/translator-runtime/context.js';
@@ -24,7 +26,8 @@ import { useNavigationStrategy } from '../../../client/react/navigation/use-navi
  */
 const useRouter = () => {
     const { push: nextRouterPush, replace: nextRouterReplace, prefetch: nextRouterPrefetch, ...rest } = useRouter$1();
-    const { resolveNavigation } = useNavigationTarget();
+    const { localizedPathname } = usePathname();
+    const { resolveNavigation } = useNavigationTarget(localizedPathname);
     const { decideNavigation } = useNavigationStrategy();
     const push = (href, options) => {
         const { locale } = options || {};

package/dist/next/src/client/react/contexts/translator/context.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+
+React.createContext(undefined);

package/dist/next/src/client/react/contexts/translator-runtime/context.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+
+React.createContext(undefined);

package/dist/{src → next/src}/client/react/navigation/use-navigation-strategy.js

@@ -1,10 +1,5 @@
-import 'react/jsx-runtime';
-import 'react';
-import '../contexts/config/context.js';
-import { useConfig } from '../contexts/config/hook.js';
+import { useConfig, useLocale } from 'intor/react';
 import { setLocaleCookieBrowser } from '../../shared/utils/locale/set-locale-cookie-browser.js';
-import '../contexts/locale/context.js';
-import { useLocale } from '../contexts/locale/hook.js';
 
 /**
  * Determines the navigation strategy for a resolved navigation target.

package/dist/next/src/client/react/navigation/use-navigation-target.js

@@ -0,0 +1,20 @@
+import { useConfig, useLocale } from 'intor/react';
+import { resolveNavigationTarget } from '../../../routing/resolve-navigation-target.js';
+
+/**
+ * Hook for resolving locale-aware navigation targets.
+ *
+ * This hook bridges Next.js navigation context with Intor's routing decision logic.
+ */
+const useNavigationTarget = (localizedPathname) => {
+    const { config } = useConfig();
+    const { locale: currentLocale } = useLocale();
+    const resolveNavigation = (input) => {
+        return resolveNavigationTarget(config, currentLocale, localizedPathname, {
+            ...input,
+        });
+    };
+    return { resolveNavigation };
+};
+
+export { useNavigationTarget };

package/dist/next/src/config/constants/cache.constants.js

@@ -0,0 +1,7 @@
+// Default cache options
+const DEFAULT_CACHE_OPTIONS = {
+    enabled: process.env.NODE_ENV === "production",
+    ttl: 60 * 60 * 1000, // 1 hour
+};
+
+export { DEFAULT_CACHE_OPTIONS };

package/dist/next/src/server/messages/load-local-messages/load-local-messages.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import pLimit from 'p-limit';
+import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
+import { readLocaleMessages } from './read-locale-messages/read-locale-messages.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 the local file system.
+ *
+ * This function acts as the orchestration layer for local message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Limiting concurrent file reads for performance
+ *
+ * File system traversal, parsing, and message validation are delegated to lower-level utilities.
+ */
+const loadLocalMessages = async ({ pool = getGlobalMessagesPool(), rootDir = "messages", locale, fallbackLocales, namespaces, extraOptions: { concurrency = 10, cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, exts, messagesReader, } = {}, allowCacheWrite = false, }) => {
+    const baseLogger = getLogger({ ...loggerOptions });
+    const logger = baseLogger.child({ scope: "load-local-messages" });
+    const start = performance.now();
+    logger.debug("Loading local messages.", {
+        rootDir,
+        resolvedRootDir: path.resolve(process.cwd(), rootDir),
+    });
+    // --- Cache key
+    const cacheKey = normalizeCacheKey([
+        loggerOptions.id,
+        "loaderType:local",
+        rootDir,
+        locale,
+        (fallbackLocales || []).toSorted().join(","),
+        (namespaces || []).toSorted().join(","),
+    ]);
+    // --- Cache read --------------------------------------------------
+    if (cacheOptions.enabled && cacheKey) {
+        const cached = await pool?.get(cacheKey);
+        if (cached) {
+            logger.debug("Messages cache hit.", { key: cacheKey });
+            return cached;
+        }
+    }
+    const limit = pLimit(concurrency);
+    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 readed = await readLocaleMessages({
+                limit,
+                rootDir,
+                locale: candidateLocale,
+                namespaces,
+                extraOptions: { loggerOptions, exts, messagesReader },
+            });
+            // Stop at the first locale that yields non-empty messages
+            if (Object.values(readed[candidateLocale] || {}).length > 0) {
+                messages = readed;
+                break;
+            }
+        }
+        catch {
+            if (isLast) {
+                logger.warn("Failed to load messages for all candidate locales.", {
+                    locale,
+                    fallbackLocales,
+                });
+            }
+            else {
+                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
+            }
+        }
+    }
+    // --- Cache write --------------------------------------------------
+    if (allowCacheWrite && cacheOptions.enabled && cacheKey && messages) {
+        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+    }
+    // Final success log with resolved locale and timing
+    if (messages) {
+        logger.trace("Finished loading local messages.", {
+            loadedLocale: Object.keys(messages)[0],
+            duration: `${Math.round(performance.now() - start)} ms`,
+        });
+    }
+    return messages;
+};
+
+export { loadLocalMessages };

package/dist/next/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getLogger } from '../../../../shared/logger/get-logger.js';
+
+/**
+ * Recursively collects all message files under a given root directory.
+ *
+ * - Supports filtering by allowed file extensions and optional namespaces.
+ * - Processes directories concurrently using the provided `limit` function.
+ *
+ * @example
+ * ```ts
+ * [{
+ *     namespace: "auth", // If messages under locale root (no namespace) -> "index"
+ *     fullPath: "/Users/john/my-app/messages/en-US/auth/login.json",
+ *     relativePath: "auth/login.json",
+ *     segments: ["auth", "login"],
+ *     basename: "login",
+ * }, ... ];
+ * ```
+ */
+async function collectFileEntries({ readdir = fs.readdir, limit, rootDir, namespaces, extraOptions: { exts = [".json"], loggerOptions } = {}, }) {
+    const baseLogger = getLogger({ ...loggerOptions });
+    const logger = baseLogger.child({ scope: "collect-file-entries" });
+    const fileEntries = [];
+    const walk = async (currentDir) => {
+        // Read current directory entries
+        let entries = [];
+        try {
+            entries = await readdir(currentDir, { withFileTypes: true });
+        }
+        catch {
+            logger.debug("Locale directory not found, skipping locale.", {
+                localeDir: currentDir,
+            });
+            return;
+        }
+        // Process each directory entry and collect valid files
+        const tasks = entries.map((entry) => limit(async () => {
+            const fullPath = path.join(currentDir, entry.name);
+            // If entry is a directory, recurse into it
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+                return;
+            }
+            // Only include files with extensions in exts[]
+            if (!exts.some((ext) => entry.name.endsWith(ext)))
+                return;
+            const relativePath = path.relative(rootDir, fullPath);
+            const ext = path.extname(relativePath);
+            const withoutExt = relativePath.slice(0, -ext.length);
+            const segments = withoutExt.split(path.sep).filter(Boolean);
+            const namespace = segments.at(0);
+            if (!namespace)
+                return;
+            // Filter namespaces if a list is provided (always include "index")
+            if (namespaces && namespace !== "index") {
+                if (!namespaces.includes(namespace))
+                    return;
+            }
+            fileEntries.push({
+                namespace,
+                fullPath,
+                relativePath,
+                segments,
+                basename: path.basename(entry.name, ext),
+            });
+        }));
+        await Promise.all(tasks);
+    };
+    await walk(rootDir);
+    if (fileEntries.length > 0) {
+        logger.trace(`Collected ${fileEntries.length} local message files for locale "${path.basename(rootDir)}".`);
+    }
+    return fileEntries;
+}
+
+export { collectFileEntries };

package/dist/next/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { isValidMessages } from '../../../shared/utils/is-valid-messages.js';
+import { getLogger } from '../../../../shared/logger/get-logger.js';
+import { deepMerge } from '../../../../../shared/utils/deep-merge.js';
+import { jsonReader } from './utils/json-reader.js';
+import { nestObjectFromPath } from './utils/nest-object-from-path.js';
+
+/**
+ * Parse locale message files (JSON or custom formats) into a unified LocaleMessages object.
+ *
+ * - Supports JSON and custom formats (via `customReader`)
+ * - Uses optional concurrency control (`limit`)
+ * - Builds nested objects based on file path segments
+ * - Deep-merges entries that belong to the same namespace
+ *
+ * @example
+ * ```plain
+ * File paths:
+ *   - en/index.json        = { a: "A" }
+ *   - en/ui.json           = { b: "B" }
+ *   - en/auth/index.json   = { c: "C" }
+ *   - en/auth/verify.json  = { d: "D" }
+ *```
+
+ * The final return value is a LocaleMessages object:
+ * ```ts
+ * {
+ *   en: {
+ *     a: "A",
+ *     ui: { b: "B" },
+ *     auth: {
+ *       c: "C",
+ *       verify: { d: "D" },
+ *     },
+ *   },
+ * }
+ * ```
+ */
+async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesReader, loggerOptions } = {}, }) {
+    const baseLogger = getLogger({ ...loggerOptions });
+    const logger = baseLogger.child({ scope: "parse-file-entries" });
+    // Read and parse all file entries
+    const parsedFileEntries = [];
+    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath, relativePath }) => limit(async () => {
+        try {
+            const segsWithoutNs = segments.slice(1);
+            const ext = path.extname(fullPath);
+            // Use a custom reader if provided (e.g., for YAML)
+            const json = ext !== ".json" && messagesReader
+                ? await messagesReader(fullPath)
+                : await jsonReader(fullPath);
+            // Validate messages structure
+            if (!isValidMessages(json)) {
+                throw new Error("JSON file does not match NamespaceMessages structure");
+            }
+            const isIndex = basename === "index";
+            const keyPath = isIndex ? segsWithoutNs.slice(0, -1) : segsWithoutNs;
+            // Nest the parsed content based on the path segments
+            const nested = nestObjectFromPath(keyPath, json);
+            parsedFileEntries.push({ namespace, messages: nested });
+            logger.trace(`Parsed message file: ${relativePath}`);
+        }
+        catch (error) {
+            logger.error("Failed to read or parse file.", {
+                path: fullPath,
+                error,
+            });
+        }
+    }));
+    await Promise.all(tasks);
+    // Merge all entries belonging to the same namespace
+    const result = {};
+    for (const { namespace, messages } of parsedFileEntries) {
+        // Handle root-level namespace (i.e., [rootDir]/index.json)
+        if (namespace === "index") {
+            Object.assign(result, deepMerge(result, messages));
+        }
+        else {
+            result[namespace] = deepMerge(result[namespace], messages);
+        }
+    }
+    return result;
+}
+
+export { parseFileEntries };

package/dist/next/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/json-reader.js

@@ -0,0 +1,12 @@
+import fs from 'node:fs/promises';
+
+/**
+ *  Read & parse a JSON file
+ */
+async function jsonReader(filePath, readFile = fs.readFile) {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+}
+
+export { jsonReader };

package/dist/next/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/nest-object-from-path.js

@@ -0,0 +1,21 @@
+/**
+ * Wraps a value inside nested objects according to a given path.
+ *
+ * @example
+ * ```ts
+ * const value = { a: "A" };
+ *
+ * nestObjectFromPath(["auth", "verify"], value); // → { auth: { verify: { a: "A" } } }
+ *
+ * nestObjectFromPath([], value); // →  { a: "A" }
+ * ```
+ */
+function nestObjectFromPath(path, value) {
+    let obj = value;
+    for (let i = path.length - 1; i >= 0; i--) {
+        obj = { [path[i]]: obj };
+    }
+    return obj;
+}
+
+export { nestObjectFromPath };

package/dist/next/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { collectFileEntries } from './collect-file-entries/collect-file-entries.js';
+import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
+
+/**
+ * Read messages for a specific locale from the file system.
+ *
+ * 1. Collects file entries under the specified locale directory.
+ * 2. Parses each file into a messages object.
+ * 3. Wraps the parsed messages under the locale key.
+ */
+const readLocaleMessages = async ({ limit, rootDir = "messages", locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions } = {}, }) => {
+    // 1. Collect file entries
+    const fileEntries = await collectFileEntries({
+        rootDir: path.resolve(process.cwd(), rootDir, locale),
+        namespaces,
+        limit,
+        extraOptions: { exts, loggerOptions },
+    });
+    // 2. Parse file entries
+    const messages = await parseFileEntries({
+        fileEntries,
+        limit,
+        extraOptions: { messagesReader, loggerOptions },
+    });
+    // 3. Wrap the parsed messages under the locale key
+    const localeMessages = { [locale]: messages };
+    return localeMessages;
+};
+
+export { readLocaleMessages };