intor 2.2.0 → 2.2.2

package/dist/index.cjs

@@ -5,6 +5,7 @@ var perf_hooks = require('perf_hooks');
 var pLimit = require('p-limit');
 var fs = require('fs/promises');
 var logry = require('logry');
+var merge = require('lodash.merge');
 var Keyv = require('keyv');
 var intorTranslator = require('intor-translator');
 
@@ -13,13 +14,14 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var path__default = /*#__PURE__*/_interopDefault(path);
 var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
 var Keyv__default = /*#__PURE__*/_interopDefault(Keyv);
 
 // src/modules/intor/utils/should-load-messages.ts
 var shouldLoadMessages = (loader) => {
   if (!loader) return false;
   const { type, lazyLoad } = loader;
-  if (type === "import") return true;
+  if (type === "local") return true;
   if (lazyLoad) return false;
   return true;
 };
@@ -48,17 +50,18 @@ var DEFAULT_FORMATTER_CONFIG = {
   node: { meta: { compact: true }, lineBreaksAfter: 1 }
 };
 function getLogger({
-  id,
+  id = "default",
   formatterConfig,
   preset,
   ...options
 }) {
   const pool = getGlobalLoggerPool();
   let logger = pool.get(id);
+  const useDefault = !formatterConfig && !preset;
   if (!logger) {
     logger = logry.logry({
       id,
-      formatterConfig: !formatterConfig && !preset ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
       preset,
       ...options
     });
@@ -71,306 +74,172 @@ function getLogger({
   return logger;
 }
 
-// src/shared/error/intor-error.ts
-var IntorError = class extends Error {
-  constructor({ message, code, id }) {
-    const fullMessage = id ? `[${id}] ${message}` : message;
-    super(fullMessage);
-    this.name = "IntorError";
-    this.id = id;
-    this.code = code;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-// src/modules/messages/load-local-messages/load-namespace-group/parse-message-file.ts
-var MAX_PATH_LENGTH = 260;
-var parseMessageFile = async (filePath, loggerOptions) => {
+// src/modules/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.ts
+async function collectFileEntries({
+  readdir = fs__default.default.readdir,
+  limit,
+  rootDir,
+  namespaces,
+  extraOptions: { exts = [".json"], loggerOptions } = {}
+}) {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "parse-message-file" });
-  const trimmedPath = filePath.trim();
-  if (!trimmedPath) {
-    logger.warn("File path is empty.", { filePath: trimmedPath });
-    return null;
-  }
-  if (trimmedPath.length > MAX_PATH_LENGTH) {
-    logger.warn("File path exceeds maximum length.", { filePath: trimmedPath });
-    return null;
-  }
-  const fileName = path__default.default.basename(trimmedPath);
-  if (!fileName.toLowerCase().endsWith(".json")) {
-    logger.trace("Skipped non-JSON file.", { filePath: trimmedPath });
-    return null;
-  }
-  try {
-    const content = await fs__default.default.readFile(trimmedPath, "utf8");
-    const parsed = JSON.parse(content);
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new IntorError({
-        id: loggerOptions.id,
-        code: "INTOR_INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
-        message: "Invalid message format"
-      });
+  const logger = baseLogger.child({ scope: "collect-file-entries" });
+  const results = [];
+  const walk = async (currentDir) => {
+    let entries = [];
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch (error) {
+      logger.error(`Error reading directory: ${currentDir}`, { error });
+      return;
     }
-    logger.trace("Message file loaded.", { filePath: trimmedPath });
-    return parsed;
-  } catch (error) {
-    logger.warn("Failed to parse message file.", {
-      filePath: trimmedPath,
-      error
+    const tasks = entries.map(
+      (entry) => limit(async () => {
+        const fullPath = path__default.default.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+          return;
+        }
+        if (!exts.some((ext2) => entry.name.endsWith(ext2))) return;
+        const relativePath = path__default.default.relative(rootDir, fullPath);
+        const ext = path__default.default.extname(relativePath);
+        const withoutExt = relativePath.slice(0, -ext.length);
+        const segments = withoutExt.split(path__default.default.sep).filter(Boolean);
+        const namespace = segments.at(0);
+        if (!namespace) return;
+        if (namespaces && namespace !== "index") {
+          if (!namespaces.includes(namespace)) return;
+        }
+        results.push({
+          namespace,
+          fullPath,
+          relativePath,
+          segments,
+          basename: path__default.default.basename(entry.name, ext)
+        });
+      })
+    );
+    await Promise.all(tasks);
+  };
+  await walk(rootDir);
+  if (logger.core.level === "debug") {
+    logger.debug("Local message files collected.", {
+      count: results.length
     });
-    return null;
   }
-};
+  logger.trace("Local message files collected.", {
+    count: results.length,
+    fileEntries: results.map(({ namespace, relativePath }) => ({
+      namespace: namespace === "index" ? null : namespace,
+      relativePath
+    }))
+  });
+  return results;
+}
 
-// src/modules/messages/load-local-messages/load-namespace-group/merge-namespace-messages.ts
-var mergeNamespaceMessages = async (filePaths, isAtRoot, loggerOptions) => {
-  const baseContent = {};
-  const subEntries = {};
-  await Promise.all(
-    filePaths.map(async (filePath) => {
-      const fileName = path__default.default.basename(filePath);
-      const content = await parseMessageFile(filePath, loggerOptions);
-      if (!content) {
-        return;
-      }
-      if (fileName === "index.json" || isAtRoot) {
-        Object.assign(baseContent, content);
+// src/modules/messages/shared/utils/is-namespace-messages.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNamespaceMessages(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 {
-        const name = fileName.replace(/\.json$/, "");
-        subEntries[name] = content;
+        return false;
       }
-    })
-  );
-  return { base: baseContent, sub: subEntries };
-};
-
-// src/modules/messages/load-local-messages/load-namespace-group/load-namespace-group.ts
-var loadNamespaceGroup = async ({
-  locale,
-  namespace,
-  messages,
-  namespaceGroupValue,
-  limit,
-  logger: loggerOptions = { id: "default" }
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-namespace-group" });
-  const { isAtRoot, filePaths } = namespaceGroupValue;
-  if (filePaths.length === 0) {
-    logger.trace(
-      `Skipped merging ${locale}/${namespace} because filePaths is empty`
-    );
-    return;
-  }
-  return limit(async () => {
-    const { base, sub } = await mergeNamespaceMessages(
-      filePaths,
-      isAtRoot,
-      loggerOptions
-    );
-    if (!messages[locale]) {
-      messages[locale] = {};
-    }
-    if (isAtRoot && filePaths.length === 1 && path__default.default.basename(filePaths[0]) === "index.json") {
-      messages[locale] = { ...messages[locale], ...base };
-      return;
     }
-    const finalContent = isAtRoot ? base : { ...base, ...sub };
-    messages[locale][namespace] = finalContent;
-    if (!isAtRoot && Object.keys(finalContent).length > 0) {
-      logger.trace(
-        `Merged ${locale}/${namespace} from ${filePaths.length} file(s)`,
-        { namespace }
-      );
-    }
-  });
-};
-var addToNamespaceGroup = ({
-  options: { namespaces },
-  filePath,
-  namespaceGroups,
-  namespacePathSegments
-}) => {
-  if (!filePath) {
-    return;
   }
-  const isAtRoot = namespacePathSegments.length === 0;
-  const nsKey = isAtRoot ? path__default.default.basename(filePath, ".json") : namespacePathSegments.join(".");
-  if (namespaces && namespaces.size > 0 && !namespaces.has(nsKey)) {
-    return;
+  return true;
+}
+
+// src/modules/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/json-reader.ts
+async function jsonReader(filePath, readFile = fs__default.default.readFile) {
+  const raw = await readFile(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!isNamespaceMessages(parsed)) {
+    throw new Error("JSON file does not match NamespaceMessages structure");
   }
-  const group = namespaceGroups.get(nsKey) || {
-    isAtRoot,
-    filePaths: []
-  };
-  const filePathsSet = new Set(group.filePaths);
-  if (!filePathsSet.has(filePath)) {
-    filePathsSet.add(filePath);
-    group.filePaths = [...filePathsSet];
-    namespaceGroups.set(nsKey, group);
+  return parsed;
+}
+
+// src/modules/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/nest-object-from-path.ts
+function nestObjectFromPath(path4, value) {
+  let obj = value;
+  for (let i = path4.length - 1; i >= 0; i--) {
+    obj = { [path4[i]]: obj };
   }
-};
+  return obj;
+}
 
-// src/modules/messages/load-local-messages/prepare-namespace-groups/traverse-directory.ts
-var traverseDirectory = async ({
-  options,
-  currentDirPath,
-  namespaceGroups,
-  namespacePathSegments,
-  readdir = fs__default.default.readdir
-}) => {
-  const { limit } = options;
-  const loggerOptions = options.logger || { id: "default" };
+// src/modules/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.ts
+async function parseFileEntries({
+  fileEntries,
+  limit,
+  extraOptions: { messageFileReader, loggerOptions } = {}
+}) {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "traverse-directory" });
-  try {
-    const dirents = await readdir(currentDirPath, { withFileTypes: true });
-    const dirPromises = dirents.map(
-      (dirent) => limit(async () => {
-        const filePath = path__default.default.join(currentDirPath, dirent.name);
-        if (dirent.isFile() && dirent.name.endsWith(".json")) {
-          addToNamespaceGroup({
-            namespaceGroups,
-            filePath,
-            namespacePathSegments,
-            options
-          });
-        } else if (dirent.isDirectory()) {
-          await traverseDirectory({
-            namespaceGroups,
-            currentDirPath: filePath,
-            namespacePathSegments: [...namespacePathSegments, dirent.name],
-            options,
-            readdir
-          });
-        }
-      }).catch((error) => {
-        logger.warn("Failed to process a locale file or directory.", {
-          name: dirent.name,
-          type: dirent.isFile() ? "file" : "directory",
-          path: currentDirPath,
+  const logger = baseLogger.child({ scope: "parse-file-entries" });
+  const parsedFileEntries = [];
+  const tasks = fileEntries.map(
+    ({ namespace, segments, basename, fullPath }) => limit(async () => {
+      try {
+        const segsWithoutNs = segments.slice(1);
+        const json = await (messageFileReader ? messageFileReader(fullPath) : jsonReader(fullPath));
+        const isIndex = basename === "index";
+        const keyPath = isIndex ? segsWithoutNs.slice(0, -1) : segsWithoutNs;
+        const namespaceMessages = nestObjectFromPath(keyPath, json);
+        parsedFileEntries.push({ namespace, namespaceMessages });
+        logger.trace("Parsed file.", { path: fullPath });
+      } catch (error) {
+        logger.error("Failed to read or parse file.", {
+          path: fullPath,
           error
         });
-      })
-    );
-    await Promise.all(dirPromises);
-  } catch (error) {
-    logger.warn(`Error reading directory: ${currentDirPath}`, { error });
+      }
+    })
+  );
+  await Promise.all(tasks);
+  const result = {};
+  for (const { namespace, namespaceMessages } of parsedFileEntries) {
+    if (namespace === "index") {
+      merge__default.default(result, namespaceMessages);
+    } else {
+      result[namespace] = merge__default.default(
+        result[namespace] ?? {},
+        namespaceMessages
+      );
+    }
   }
-};
-
-// src/modules/messages/load-local-messages/prepare-namespace-groups/prepare-namespace-groups.ts
-var prepareNamespaceGroups = async (options) => {
-  const { basePath } = options;
-  const namespaceGroups = /* @__PURE__ */ new Map();
-  await traverseDirectory({
-    options,
-    currentDirPath: basePath,
-    namespaceGroups,
-    namespacePathSegments: []
-  });
-  return namespaceGroups;
-};
+  return result;
+}
 
-// src/modules/messages/load-local-messages/load-single-locale/load-single-locale.ts
-var loadSingleLocale = async ({
-  basePath,
+// src/modules/messages/load-local-messages/read-locale-messages/read-locale-messages.ts
+var readLocaleMessages = async ({
+  limit,
+  rootDir = "messages",
   locale,
   namespaces,
-  messages,
-  limit,
-  logger: loggerOptions = { id: "default" }
+  extraOptions: { exts, messageFileReader, loggerOptions } = {}
 }) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-single-locale" });
-  const localePath = path__default.default.join(basePath, locale);
-  const validNamespaces = [];
-  try {
-    const stat = await fs__default.default.stat(localePath);
-    if (!stat.isDirectory()) {
-      logger.warn("Locale path is not a directory.", {
-        locale,
-        path: localePath
-      });
-      return;
-    }
-  } catch (error) {
-    logger.warn("Error checking locale path.", { locale, error });
-    return;
-  }
-  const namespaceGroups = await prepareNamespaceGroups({
-    basePath: localePath,
+  const fileEntries = await collectFileEntries({
+    rootDir: path__default.default.resolve(process.cwd(), rootDir, locale),
+    namespaces,
     limit,
-    namespaces: new Set(namespaces || []),
-    logger: loggerOptions
+    extraOptions: { exts, loggerOptions }
   });
-  if (namespaceGroups.size === 0) {
-    logger.warn("No namespace groups found.", {
-      locale,
-      basePath,
-      namespaces
-    });
-    return;
-  }
-  logger.trace("Prepared namespace groups from scanning local files.", {
-    namespaceGroups: [...namespaceGroups.entries()].map(([ns, val]) => ({
-      namespace: ns,
-      isAtRoot: val.isAtRoot,
-      fileCount: val.filePaths.length
-    }))
-  });
-  const namespaceGroupTasks = [...namespaceGroups.entries()].filter(
-    ([ns]) => !namespaces || namespaces.length === 0 || namespaces.includes(ns)
-  ).map(
-    ([namespace, namespaceGroupValue]) => loadNamespaceGroup({
-      locale,
-      namespace,
-      messages,
-      namespaceGroupValue,
-      limit,
-      logger: loggerOptions
-    }).then(() => validNamespaces.push(namespace))
-  );
-  await Promise.all(namespaceGroupTasks);
-  return validNamespaces;
-};
-
-// src/modules/messages/load-local-messages/load-locale-with-fallback/load-locale-with-fallback.ts
-var loadLocaleWithFallback = async ({
-  basePath,
-  locale: targetLocale,
-  fallbackLocales = [],
-  namespaces,
-  messages,
-  limit,
-  logger: loggerOptions = { id: "default" }
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-locale-with-fallback" });
-  const candidateLocales = [targetLocale, ...fallbackLocales];
-  for (const locale of candidateLocales) {
-    try {
-      const validNamespaces = await loadSingleLocale({
-        basePath,
-        locale,
-        namespaces,
-        messages,
-        limit,
-        logger: loggerOptions
-      });
-      return validNamespaces;
-    } catch (error) {
-      logger.warn("Error occurred while processing the locale.", {
-        locale,
-        error
-      });
-    }
-  }
-  logger.warn("All fallback locales failed.", {
-    attemptedLocales: candidateLocales
+  const namespaceMessages = await parseFileEntries({
+    fileEntries,
+    limit,
+    extraOptions: { messageFileReader, loggerOptions }
   });
-  return;
+  const localeMessages = { [locale]: namespaceMessages };
+  return localeMessages;
 };
 function getGlobalMessagesPool() {
   if (!globalThis.__INTOR_MESSAGES_POOL__) {
@@ -382,22 +251,9 @@ function clearMessagesPool() {
   const pool = getGlobalMessagesPool();
   pool.clear();
 }
-
-// src/shared/utils/merge-messages.ts
 var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  const result = Object.keys(staticMessages).length > 0 ? { ...staticMessages } : {};
-  for (const locale in loadedMessages) {
-    const loaded = loadedMessages[locale];
-    if (!result[locale]) {
-      result[locale] = loaded;
-      continue;
-    }
-    result[locale] = {
-      ...result[locale],
-      ...loaded
-    };
-  }
-  return result;
+  if (!loadedMessages) return { ...staticMessages };
+  return merge__default.default({}, staticMessages, loadedMessages);
 };
 
 // src/shared/utils/normalize-cache-key.ts
@@ -429,6 +285,8 @@ var resolveNamespaces = ({
 }) => {
   const { loader } = config;
   const { routeNamespaces = {}, namespaces } = loader || {};
+  if (Object.keys(routeNamespaces).length === 0 && !namespaces)
+    return void 0;
   const standardizedPathname = standardizePathname({ config, pathname });
   const placeholderRemovedPathname = standardizedPathname.replace(
     `/${PREFIX_PLACEHOLDER}`,
@@ -586,43 +444,35 @@ var standardizePathname = ({
 
 // src/modules/messages/load-local-messages/load-local-messages.ts
 var loadLocalMessages = async ({
-  basePath,
+  pool = getGlobalMessagesPool(),
+  rootDir = "messages",
   locale,
   fallbackLocales,
   namespaces,
-  concurrency = 10,
-  cache = DEFAULT_CACHE_OPTIONS,
-  logger: loggerOptions = { id: "default" }
+  extraOptions: {
+    concurrency = 10,
+    cacheOptions = DEFAULT_CACHE_OPTIONS,
+    loggerOptions = { id: "default" },
+    exts,
+    messageFileReader
+  } = {}
 }) => {
-  basePath = basePath ?? "messages";
-  if (!locale || locale.trim() === "") return {};
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-locale-messages" });
-  const messages = {};
-  const resolvedBasePath = path__default.default.resolve(
-    process.cwd(),
-    normalizePathname(basePath, { removeLeadingSlash: true })
-  );
+  const logger = baseLogger.child({ scope: "load-local-messages" });
   const start = perf_hooks.performance.now();
-  logger.trace("Starting to load local messages with configuration.", {
-    path: { basePath, resolvedBasePath },
-    locale,
-    fallbackLocales,
-    namespaces: namespaces && namespaces.length > 0 ? { count: namespaces?.length, list: [...namespaces] } : "All Namespaces",
-    concurrency
+  logger.debug("Loading local messages from directory.", {
+    rootDir,
+    resolvedRootDir: path__default.default.resolve(process.cwd(), rootDir)
   });
-  let pool;
-  if (cache.enabled) {
-    pool = getGlobalMessagesPool();
-  }
   const key = normalizeCacheKey([
     loggerOptions.id,
-    resolvedBasePath,
+    "loaderType:local",
+    rootDir,
     locale,
-    (fallbackLocales ?? []).toSorted().join(","),
-    (namespaces ?? []).toSorted().join(",")
+    (fallbackLocales || []).toSorted().join(","),
+    (namespaces || []).toSorted().join(",")
   ]);
-  if (cache.enabled && key) {
+  if (cacheOptions.enabled && key) {
     const cached = await pool?.get(key);
     if (cached) {
       logger.debug("Messages cache hit.", { key });
@@ -630,50 +480,57 @@ var loadLocalMessages = async ({
     }
   }
   const limit = pLimit__default.default(concurrency);
-  const validNamespaces = await loadLocaleWithFallback({
-    basePath: resolvedBasePath,
-    locale,
-    fallbackLocales,
-    namespaces,
-    messages,
-    limit,
-    logger: loggerOptions
-  });
-  if (cache.enabled && key) {
-    await pool?.set(key, messages, cache.ttl);
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    try {
+      const result = await readLocaleMessages({
+        limit,
+        rootDir,
+        locale: candidateLocale,
+        namespaces,
+        extraOptions: { loggerOptions, exts, messageFileReader }
+      });
+      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
+        messages = result;
+        break;
+      }
+    } catch (error) {
+      logger.error("Failed to read locale messages", {
+        locale: candidateLocale,
+        error
+      });
+    }
+  }
+  if (cacheOptions.enabled && key && messages) {
+    await pool?.set(key, messages, cacheOptions.ttl);
   }
   const end = perf_hooks.performance.now();
   const duration = Math.round(end - start);
   logger.trace("Finished loading local messages.", {
-    locale,
-    validNamespaces,
+    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
     duration: `${duration} ms`
   });
   return messages;
 };
 
-// src/modules/messages/create-load-local-messages.ts
-var createLoadLocalMessages = (basePath) => {
-  return (options) => loadLocalMessages({ basePath, ...options });
-};
-
-// src/modules/messages/load-api-messages/fetch-messages.ts
-var fetchMessages = async ({
-  apiUrl,
-  apiHeaders,
-  locale,
+// src/modules/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
+var fetchLocaleMessages = async ({
+  remoteUrl,
+  remoteHeaders,
   searchParams,
-  logger: loggerOptions = { id: "default" }
+  locale,
+  extraOptions: { loggerOptions } = {}
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "fetch-messages" });
+  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
   try {
     const params = new URLSearchParams(searchParams);
     params.append("locale", locale);
-    const url = `${apiUrl}?${params.toString()}`;
+    const url = `${remoteUrl}?${params.toString()}`;
     const headers = {
       "Content-Type": "application/json",
-      ...apiHeaders
+      ...remoteHeaders
     };
     const response = await fetch(url, {
       method: "GET",
@@ -681,17 +538,17 @@ var fetchMessages = async ({
       cache: "no-store"
     });
     if (!response.ok) {
-      throw new Error(`Fetch failed: ${locale} (${response.status})`);
+      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
     }
     const data = await response.json();
-    if (data == null || typeof data === "object" && Object.keys(data).length === 0) {
-      throw new Error(`Invalid messages: ${locale}`);
+    if (!isNamespaceMessages(data[locale])) {
+      throw new Error("JSON file does not match NamespaceMessages structure");
     }
     return data;
   } catch (error) {
-    logger.warn(`Failed to fetch messages for locale "${locale}".`, {
+    logger.warn("Fetching locale messages failed.", {
       locale,
-      apiUrl,
+      remoteUrl,
       searchParams: decodeURIComponent(searchParams.toString()),
       error
     });
@@ -699,30 +556,7 @@ var fetchMessages = async ({
   }
 };
 
-// src/modules/messages/load-api-messages/fetch-fallback-messages.ts
-var fetchFallbackMessages = async ({
-  apiUrl,
-  apiHeaders,
-  searchParams,
-  fallbackLocales,
-  logger
-}) => {
-  for (const fallbackLocale of fallbackLocales) {
-    const result = await fetchMessages({
-      apiUrl,
-      searchParams,
-      locale: fallbackLocale,
-      apiHeaders,
-      logger
-    });
-    if (result) {
-      return { locale: fallbackLocale, messages: result };
-    }
-  }
-  return;
-};
-
-// src/modules/messages/load-api-messages/utils/build-search-params.ts
+// src/modules/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.ts
 var buildSearchParams = (params) => {
   const searchParams = new URLSearchParams();
   const appendParam = (key, value) => {
@@ -740,119 +574,130 @@ var buildSearchParams = (params) => {
   return searchParams;
 };
 
-// src/modules/messages/load-api-messages/load-api-messages.ts
-var loadApiMessages = async ({
-  apiUrl,
-  apiHeaders,
-  basePath,
+// src/modules/messages/load-remote-messages/load-remote-messages.ts
+var loadRemoteMessages = async ({
+  pool = getGlobalMessagesPool(),
+  rootDir,
+  remoteUrl,
+  remoteHeaders,
   locale,
   fallbackLocales = [],
   namespaces = [],
-  cache = DEFAULT_CACHE_OPTIONS,
-  logger: loggerOptions = { id: "default" }
+  extraOptions: {
+    cacheOptions = DEFAULT_CACHE_OPTIONS,
+    loggerOptions = { id: "default" }
+  } = {}
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-api-messages" });
-  if (!apiUrl) {
-    logger.warn("No apiUrl provided. Skipping fetch.");
-    return;
-  }
-  let pool;
-  if (cache.enabled) {
-    pool = getGlobalMessagesPool();
-  }
+  const logger = baseLogger.child({ scope: "load-remote-messages" });
+  const start = performance.now();
+  logger.debug("Loading remote messages from api.", { remoteUrl });
   const key = normalizeCacheKey([
     loggerOptions.id,
-    basePath,
+    "loaderType:remote",
+    rootDir,
     locale,
     (fallbackLocales ?? []).toSorted().join(","),
     (namespaces ?? []).toSorted().join(",")
   ]);
-  if (cache.enabled && key) {
+  if (cacheOptions.enabled && key) {
     const cached = await pool?.get(key);
     if (cached) {
       logger.debug("Messages cache hit.", { key });
       return cached;
     }
   }
-  const searchParams = buildSearchParams({ basePath, namespaces });
-  const messages = await fetchMessages({
-    apiUrl,
-    apiHeaders,
-    searchParams,
-    locale,
-    logger: loggerOptions
-  });
-  if (messages) {
-    if (cache.enabled && key) {
-      await pool?.set(key, messages, cache.ttl);
+  const searchParams = buildSearchParams({ rootDir, namespaces });
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    try {
+      const result = await fetchLocaleMessages({
+        remoteUrl,
+        remoteHeaders,
+        searchParams,
+        locale: candidateLocale,
+        extraOptions: { loggerOptions }
+      });
+      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
+        messages = result;
+        break;
+      }
+    } catch (error) {
+      logger.error("Failed to fetch locale messages.", {
+        locale: candidateLocale,
+        error
+      });
     }
-    return messages;
   }
-  const fallbackResult = await fetchFallbackMessages({
-    apiUrl,
-    apiHeaders,
-    searchParams,
-    fallbackLocales,
-    logger: loggerOptions
-  });
-  if (fallbackResult) {
-    logger.info("Fallback locale succeeded.", {
-      usedLocale: fallbackResult.locale,
-      apiUrl,
-      searchParams: decodeURIComponent(searchParams.toString())
-    });
-    if (cache.enabled && key) {
-      await pool?.set(key, fallbackResult.messages, cache.ttl);
-    }
-    return fallbackResult.messages;
+  if (cacheOptions.enabled && key && messages) {
+    await pool?.set(key, messages, cacheOptions.ttl);
   }
-  logger.warn("Failed to fetch messages for all locales.", {
-    locale,
-    fallbackLocales
+  const end = performance.now();
+  const duration = Math.round(end - start);
+  logger.trace("Finished loading remote messages.", {
+    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
+    duration: `${duration} ms`
   });
-  return;
+  return messages;
 };
 
 // src/modules/messages/load-messages.ts
 var loadMessages = async ({
   config,
   locale,
-  pathname
+  pathname = "",
+  extraOptions: { exts, messageFileReader } = {}
 }) => {
   const baseLogger = getLogger({ id: config.id, ...config.logger });
-  const logger = baseLogger.child({ scope: "messages-loader" });
+  const logger = baseLogger.child({ scope: "load-messages" });
   if (!config.loader) {
     logger.warn(
       "No loader options have been configured in the current config."
     );
     return;
   }
-  const { id, loader, cache } = config;
+  const { type, concurrency, rootDir } = config.loader;
   const fallbackLocales = config.fallbackLocales[locale] || [];
   const namespaces = resolveNamespaces({ config, pathname });
-  logger.debug("Namespaces ready for loading.", {
-    namespaces: namespaces.length > 0 ? { count: namespaces.length, list: [...namespaces] } : "All Namespaces"
+  if (logger.core.level === "debug") {
+    logger.debug("Starting to load messages.", { locale });
+  }
+  logger.trace("Starting to load messages with runtime context.", {
+    loaderType: type,
+    locale,
+    fallbackLocales,
+    namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "[ALL]",
+    cache: config.cache,
+    concurrency: concurrency ?? 10
   });
-  logger.debug("Loader type selected.", { loaderType: loader.type });
   let loadedMessages;
-  if (loader.type === "import") {
-    const loadLocalMessages2 = createLoadLocalMessages(loader.basePath);
-    loadedMessages = await loadLocalMessages2({
-      ...loader,
+  if (type === "local") {
+    loadedMessages = await loadLocalMessages({
+      rootDir,
       locale,
       fallbackLocales,
       namespaces,
-      cache,
-      logger: { id }
+      extraOptions: {
+        concurrency,
+        cacheOptions: config.cache,
+        loggerOptions: { id: config.id, ...config.logger },
+        exts,
+        messageFileReader
+      }
     });
-  } else if (loader.type === "api") {
-    loadedMessages = await loadApiMessages({
-      ...loader,
+  } else if (type === "remote") {
+    loadedMessages = await loadRemoteMessages({
+      rootDir,
+      remoteUrl: config.loader.remoteUrl,
+      remoteHeaders: config.loader.remoteHeaders,
       locale,
       fallbackLocales,
       namespaces,
-      logger: { id }
+      extraOptions: {
+        cacheOptions: config.cache,
+        loggerOptions: { id: config.id, ...config.logger }
+      }
     });
   }
   if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
@@ -862,7 +707,7 @@ var loadMessages = async ({
 };
 
 // src/modules/intor/intor.ts
-var intor = async (config, i18nContext) => {
+var intor = async (config, i18nContext, loadMessagesOptions = {}) => {
   const baseLogger = getLogger({ id: config.id, ...config.logger });
   const logger = baseLogger.child({ scope: "intor" });
   logger.info("Start Intor initialization.");
@@ -873,20 +718,28 @@ var intor = async (config, i18nContext) => {
     pathname: i18nContext?.pathname || ""
   };
   const { locale, pathname } = context;
-  const source = isI18nContextFunction ? "[function]" : "[static object]";
-  logger.debug(`Context resolved via ${source}.`, context);
+  const source = isI18nContextFunction ? i18nContext.name : "static fallback";
+  logger.debug(`I18n context resolved via ${source}.`, context);
   let loadedMessages;
   if (shouldLoadMessages(loader)) {
-    loadedMessages = await loadMessages({ config, locale, pathname });
+    loadedMessages = await loadMessages({
+      config,
+      locale,
+      pathname,
+      extraOptions: {
+        exts: loadMessagesOptions.exts,
+        messageFileReader: loadMessagesOptions.messageFileReader
+      }
+    });
   }
   const mergedMessages = mergeMessages(messages, loadedMessages);
-  logger.info("Messages initialized.", {
-    staticMessages: { enabled: !!messages },
-    loadedMessages: {
+  logger.info("Messages successfully initialized.", {
+    static: { enabled: !!messages },
+    loaded: {
       enabled: !!loadedMessages,
       ...loader ? { loaderType: loader.type, lazyLoad: !!loader.lazyLoad } : null
     },
-    mergedMessages
+    merged: mergedMessages
   });
   return {
     config,
@@ -925,9 +778,9 @@ exports.clearMessagesPool = clearMessagesPool;
 exports.extractPathname = extractPathname;
 exports.getTranslator = getTranslator;
 exports.intor = intor;
-exports.loadApiMessages = loadApiMessages;
 exports.loadLocalMessages = loadLocalMessages;
 exports.loadMessages = loadMessages;
+exports.loadRemoteMessages = loadRemoteMessages;
 exports.mergeMessages = mergeMessages;
 exports.normalizeCacheKey = normalizeCacheKey;
 exports.normalizeLocale = normalizeLocale;