intor 1.0.39 → 2.0.0

package/dist/index.js

@@ -1,15 +1,28 @@
-import { logry } from 'logry';
-import { cookies, headers } from 'next/headers';
 import path from 'path';
 import { performance } from 'perf_hooks';
 import pLimit from 'p-limit';
 import fs from 'fs/promises';
-import { Translator } from 'intor-translator';
+import { logry } from 'logry';
+import Keyv from 'keyv';
 export { Translator } from 'intor-translator';
 
-// src/modules/intor/intor.ts
+// 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 (lazyLoad) return false;
+  return true;
+};
 
-// src/modules/intor-error/intor-error.ts
+// src/modules/config/constants/cache.constants.ts
+var DEFAULT_CACHE_OPTIONS = {
+  enabled: process.env.NODE_ENV === "production",
+  ttl: 60 * 60 * 1e3
+  // 1 hour
+};
+
+// src/shared/error/intor-error.ts
 var IntorError = class extends Error {
   constructor({ message, code, id }) {
     const fullMessage = id ? `[${id}] ${message}` : message;
@@ -21,218 +34,95 @@ var IntorError = class extends Error {
   }
 };
 
-// src/modules/intor-error/intor-error-types.ts
-var IntorErrorCode = /* @__PURE__ */ ((IntorErrorCode2) => {
-  IntorErrorCode2["MISSING_DEFAULT_LOCALE"] = "INTOR_MISSING_DEFAULT_LOCALE";
-  IntorErrorCode2["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
-  IntorErrorCode2["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
-  IntorErrorCode2["UNSUPPORTED_ADAPTER"] = "INTOR_UNSUPPORTED_ADAPTER";
-  IntorErrorCode2["ADAPTER_RUNTIME_LOAD_FAILED"] = "INTOR_ADAPTER_RUNTIME_LOAD_FAILED";
-  IntorErrorCode2["UNKNOWN_LOADER_TYPE"] = "INTOR_UNKNOWN_LOADER_TYPE";
-  return IntorErrorCode2;
-})(IntorErrorCode || {});
-
-// src/adapters/next-client/constants/header-key-constants.ts
-var DEFAULT_PATHNAME_HEADER_NAME = "x-intor-pathname";
-
-// src/shared/utils/locale/normalize-locale.ts
-var normalizeLocale = (locale = "", supportedLocales = []) => {
-  if (!locale || supportedLocales.length === 0) return void 0;
-  const toCanonical = (input) => {
-    try {
-      return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
-    } catch {
-      return void 0;
-    }
-  };
-  const canonicalLocale = toCanonical(locale);
-  if (!canonicalLocale) return void 0;
-  const supportedCanonicalMap = /* @__PURE__ */ new Map();
-  for (const l of supportedLocales) {
-    const normalized = toCanonical(l);
-    if (normalized) {
-      supportedCanonicalMap.set(normalized, l);
-    }
-  }
-  if (supportedCanonicalMap.has(canonicalLocale)) {
-    return supportedCanonicalMap.get(canonicalLocale);
-  }
-  const baseLang = canonicalLocale.split("-")[0];
-  for (const [key, original] of supportedCanonicalMap) {
-    const supportedBase = key.split("-")[0];
-    if (supportedBase === baseLang) {
-      return original;
-    }
-  }
-  return void 0;
-};
-
-// src/shared/utils/locale/resolve-preferred-locale.ts
-var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
-  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
-    return;
-  }
-  const supportedLocalesSet = new Set(supportedLocales);
-  const preferred = acceptLanguageHeader.split(",").map((part) => {
-    const [lang, qValue] = part.split(";");
-    const q = qValue ? parseFloat(qValue.split("=")[1]) : 1;
-    if (isNaN(q)) {
-      return { lang: lang.trim(), q: 0 };
-    }
-    return { lang: lang.trim(), q };
-  }).sort((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
-  return preferred;
-};
-
-// src/adapters/next-client/next-client-runtime/next-client-runtime.ts
-var nextClientRuntime = async ({
-  config
-}) => {
-  const cookiesStore = await cookies();
-  const headersStore = await headers();
-  const logger = logry({ id: config.id, scope: "nextClientRuntime" });
-  const { defaultLocale, supportedLocales = [], cookie, routing } = config;
-  let locale;
-  if (!cookie.disabled) {
-    const localeFromCookie = cookiesStore.get(cookie.name)?.value;
-    locale = normalizeLocale(localeFromCookie, supportedLocales);
-    if (locale) {
-      logger.debug("Get locale from cookie:", { locale });
-    }
-  }
-  if (!locale && routing.firstVisit.localeSource === "browser") {
-    const aLHeader = headersStore.get("accept-language") || void 0;
-    const preferredLocale = resolvePreferredLocale(aLHeader, supportedLocales);
-    locale = normalizeLocale(preferredLocale, supportedLocales);
-    logger.debug("Get locale from browser:", { locale });
-  }
-  const pathname = headersStore.get(DEFAULT_PATHNAME_HEADER_NAME);
-  if (pathname) {
-    logger.debug("Get pathname from next headers:", { pathname });
-  }
-  return {
-    locale: locale || defaultLocale,
-    pathname: pathname || ""
-  };
-};
-var nextServerRuntime = async ({
-  config,
-  request
-}) => {
-  const cookiesStore = await cookies();
-  const headersStore = await headers();
-  const logger = logry({ id: config.id, scope: "nextServerRuntime" });
-  const { defaultLocale, supportedLocales = [], cookie, routing } = config;
-  let locale;
-  if (!cookie.disabled) {
-    const localeFromCookie = cookiesStore.get(cookie.name)?.value;
-    locale = normalizeLocale(localeFromCookie, supportedLocales);
-    if (locale) {
-      logger.debug("Get locale from cookie:", { locale });
-    }
-  }
-  if (!locale && routing.firstVisit.localeSource === "browser") {
-    const aLHeader = headersStore.get("accept-language") || void 0;
-    const preferredLocale = resolvePreferredLocale(aLHeader, supportedLocales);
-    locale = normalizeLocale(preferredLocale, supportedLocales);
-    logger.debug("Get locale from browser:", { locale });
-  }
-  let pathname = "";
-  if (request && typeof request === "object" && "nextUrl" in request) {
-    pathname = request.nextUrl.pathname;
-    if (pathname) {
-      logger.debug("Get pathname from next request:", { pathname });
-    }
-  }
-  if (!pathname) {
-    pathname = headersStore.get(DEFAULT_PATHNAME_HEADER_NAME);
-    if (pathname) {
-      logger.debug("Get pathname from next headers:", { pathname });
-    }
-  }
-  if (!cookie.disabled && cookie.autoSetCookie) {
-    cookiesStore.set({
-      name: cookie.name,
-      value: locale || defaultLocale,
-      ...cookie.domain ? { domain: cookie.domain } : {},
-      path: cookie.path,
-      maxAge: cookie.maxAge,
-      httpOnly: cookie.httpOnly,
-      secure: cookie.secure,
-      sameSite: cookie.sameSite
-    });
-    logger.debug("Set locale to cookie:", {
-      cookie: { name: cookie.name, value: locale || defaultLocale }
-    });
-  }
-  return {
-    locale: locale || defaultLocale,
-    pathname: pathname || ""
-  };
-};
-
-// src/modules/intor-adapter/resolve-adapter-runtime-loader.ts
-var resolceAdapterRuntimeLoader = async ({
-  config
-}) => {
-  const { adapter } = config;
-  let loadedRuntime;
-  if (adapter === "next-client") {
-    loadedRuntime = nextClientRuntime;
-  } else if (adapter === "next-server") {
-    loadedRuntime = nextServerRuntime;
-  }
-  return loadedRuntime;
-};
-
-// src/modules/intor-config/types/intor-adapter-types.ts
-var intorAdapters = ["next-client", "next-server"];
-var readMessageRecordFile = async (filePath) => {
+// src/modules/messages/load-local-messages/utils/read-message-record-file.ts
+var readMessageRecordFile = async (filePath, loggerOptions) => {
   const fileName = path.basename(filePath, ".json");
   const content = await fs.readFile(filePath, "utf-8");
   const parsed = JSON.parse(content);
   if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`Invalid message format`);
+    throw new IntorError({
+      id: loggerOptions.id,
+      code: "INTOR_INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
+      message: "Invalid message format"
+    });
   }
   return { fileName, content: parsed };
 };
 
-// src/modules/intor-messages-loader/load-local-messages/load-namespace-group/parse-message-file.ts
+// src/shared/logger/global-logger-pool.ts
+function getGlobalLoggerPool() {
+  if (!globalThis.__INTOR_LOGGER_POOL__) {
+    globalThis.__INTOR_LOGGER_POOL__ = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__INTOR_LOGGER_POOL__;
+}
+function clearLoggerPool() {
+  const pool = getGlobalLoggerPool();
+  pool.clear();
+}
+
+// src/shared/logger/get-logger.ts
+var DEFAULT_FORMATTER_CONFIG = {
+  node: { meta: { compact: true }, lineBreaksAfter: 1 }
+};
+function getLogger({
+  id,
+  formatterConfig = DEFAULT_FORMATTER_CONFIG,
+  ...options
+}) {
+  const pool = getGlobalLoggerPool();
+  let logger = pool.get(id);
+  if (!logger) {
+    logger = logry({ id, formatterConfig, ...options });
+    pool.set(id, logger);
+    if (pool.size > 1e3) {
+      const keys = Array.from(pool.keys());
+      for (const key of keys.slice(0, 200)) pool.delete(key);
+    }
+  }
+  return logger;
+}
+
+// src/modules/messages/load-local-messages/load-namespace-group/parse-message-file.ts
 var MAX_PATH_LENGTH = 260;
-var parseMessageFile = async (filePath, loggerId) => {
-  const logger = logry({ id: loggerId, scope: "parseMessageFile" });
+var parseMessageFile = async (filePath, loggerOptions) => {
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "parse-message-file" });
   const trimmedPath = filePath.trim();
   if (!trimmedPath) {
-    logger?.warn("Invalid file path provided.", { filePath: trimmedPath });
+    logger.warn("File path is empty.", { filePath: trimmedPath });
     return null;
   }
   if (trimmedPath.length > MAX_PATH_LENGTH) {
-    logger?.warn("Invalid file path provided.", { filePath: trimmedPath });
+    logger.warn("File path exceeds maximum length.", { filePath: trimmedPath });
     return null;
   }
   const fileName = path.basename(trimmedPath);
   if (!fileName.toLowerCase().endsWith(".json")) {
-    logger?.debug(`Skipped non-JSON file.`, { filePath: trimmedPath });
+    logger.trace("Skipped non-JSON file.", { filePath: trimmedPath });
     return null;
   }
   try {
-    const { content } = await readMessageRecordFile(trimmedPath);
-    logger?.debug(`Loaded a file.`, { filePath: trimmedPath });
+    const { content } = await readMessageRecordFile(trimmedPath, loggerOptions);
+    logger.trace(`Message file loaded.`, { filePath: trimmedPath });
     return content;
   } catch (error) {
-    logger?.warn(`Failed to load file.`, { filePath: trimmedPath, error });
+    logger.warn("Failed to parse message file.", {
+      filePath: trimmedPath,
+      error
+    });
     return null;
   }
 };
 
-// src/modules/intor-messages-loader/load-local-messages/load-namespace-group/merge-namespace-messages.ts
-var mergeNamespaceMessages = async (filePaths, isAtRoot, loggerId) => {
+// 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.basename(filePath);
-      const content = await parseMessageFile(filePath, loggerId);
+      const content = await parseMessageFile(filePath, loggerOptions);
       if (!content) {
         return;
       }
@@ -247,20 +137,21 @@ var mergeNamespaceMessages = async (filePaths, isAtRoot, loggerId) => {
   return { base: baseContent, sub: subEntries };
 };
 
-// src/modules/intor-messages-loader/load-local-messages/load-namespace-group/load-namespace-group.ts
+// src/modules/messages/load-local-messages/load-namespace-group/load-namespace-group.ts
 var loadNamespaceGroup = async ({
   locale,
   namespace,
   messages,
   namespaceGroupValue,
   limit,
-  loggerId
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry({ id: loggerId, scope: "loadNamespaceGroup" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-namespace-group" });
   const { isAtRoot, filePaths } = namespaceGroupValue;
   if (filePaths.length === 0) {
-    logger?.debug?.(
-      `Skipped merging [${locale}][${namespace}] because filePaths is empty`
+    logger.trace(
+      `Skipped merging ${locale}/${namespace} because filePaths is empty`
     );
     return;
   }
@@ -268,15 +159,19 @@ var loadNamespaceGroup = async ({
     const { base, sub } = await mergeNamespaceMessages(
       filePaths,
       isAtRoot,
-      loggerId
+      loggerOptions
     );
     if (!messages[locale]) {
       messages[locale] = {};
     }
+    if (isAtRoot && filePaths.length === 1 && path.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?.debug(
+      logger.trace(
         `Merged ${locale}/${namespace} from ${filePaths.length} file(s)`,
         { namespace }
       );
@@ -309,15 +204,17 @@ var addToNamespaceGroup = ({
   }
 };
 
-// src/modules/intor-messages-loader/load-local-messages/prepare-namespace-groups/traverse-directory.ts
+// src/modules/messages/load-local-messages/prepare-namespace-groups/traverse-directory.ts
 var traverseDirectory = async ({
   options,
   currentDirPath,
   namespaceGroups,
   namespacePathSegments
 }) => {
-  const { limit, loggerId } = options;
-  const logger = logry({ id: loggerId, scope: "traverseDirectory" });
+  const { limit } = options;
+  const loggerOptions = options.logger || { id: "default" };
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "traverse-directory" });
   try {
     const dirents = await fs.readdir(currentDirPath, { withFileTypes: true });
     const dirPromises = dirents.map(
@@ -353,7 +250,7 @@ var traverseDirectory = async ({
   }
 };
 
-// src/modules/intor-messages-loader/load-local-messages/prepare-namespace-groups/prepare-namespace-groups.ts
+// 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();
@@ -366,16 +263,17 @@ var prepareNamespaceGroups = async (options) => {
   return namespaceGroups;
 };
 
-// src/modules/intor-messages-loader/load-local-messages/load-single-locale/load-single-locale.ts
+// src/modules/messages/load-local-messages/load-single-locale/load-single-locale.ts
 var loadSingleLocale = async ({
   basePath,
   locale,
   namespaces,
   messages,
   limit,
-  loggerId
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry({ id: loggerId, scope: "loadSingleLocale" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-single-locale" });
   const localePath = path.join(basePath, locale);
   const validNamespaces = [];
   try {
@@ -388,14 +286,14 @@ var loadSingleLocale = async ({
       return;
     }
   } catch (error) {
-    logger.warn("Error checking locale path:", { locale, error });
+    logger.warn("Error checking locale path.", { locale, error });
     return;
   }
   const namespaceGroups = await prepareNamespaceGroups({
     basePath: localePath,
     limit,
     namespaces: new Set(namespaces || []),
-    loggerId
+    logger: loggerOptions
   });
   if (namespaceGroups.size === 0) {
     logger.warn("No namespace groups found.", {
@@ -405,7 +303,7 @@ var loadSingleLocale = async ({
     });
     return;
   }
-  logger.debug("Prepared namespace groups from scanning local files:", {
+  logger.trace("Prepared namespace groups from scanning local files.", {
     namespaceGroups: [...namespaceGroups.entries()].map(([ns, val]) => ({
       namespace: ns,
       isAtRoot: val.isAtRoot,
@@ -421,14 +319,14 @@ var loadSingleLocale = async ({
       messages,
       namespaceGroupValue,
       limit,
-      loggerId
+      logger: loggerOptions
     }).then(() => validNamespaces.push(namespace))
   );
   await Promise.all(namespaceGroupTasks);
   return validNamespaces;
 };
 
-// src/modules/intor-messages-loader/load-local-messages/load-locale-with-fallback/load-locale-with-fallback.ts
+// src/modules/messages/load-local-messages/load-locale-with-fallback/load-locale-with-fallback.ts
 var loadLocaleWithFallback = async ({
   basePath,
   locale: targetLocale,
@@ -436,9 +334,10 @@ var loadLocaleWithFallback = async ({
   namespaces,
   messages,
   limit,
-  loggerId
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry({ id: loggerId, scope: "loadLocaleWithFallback" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-locale-with-fallback" });
   const localesToTry = [targetLocale, ...fallbackLocales];
   for (const locale of localesToTry) {
     try {
@@ -448,7 +347,7 @@ var loadLocaleWithFallback = async ({
         namespaces,
         messages,
         limit,
-        loggerId
+        logger: loggerOptions
       });
       return validNamespaces;
     } catch (error) {
@@ -461,14 +360,155 @@ var loadLocaleWithFallback = async ({
   logger.warn("All fallback locales failed.", {
     attemptedLocales: localesToTry
   });
-  return void 0;
+  return;
+};
+function getGlobalMessagesPool() {
+  if (!globalThis.__INTOR_MESSAGES_POOL__) {
+    globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+  }
+  return globalThis.__INTOR_MESSAGES_POOL__;
+}
+function clearMessagesPool() {
+  const pool = getGlobalMessagesPool();
+  pool.clear();
+}
+
+// src/shared/utils/merge-messages.ts
+var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
+  const result = Object.keys(staticMessages).length ? { ...staticMessages } : {};
+  for (const locale in loadedMessages) {
+    const loaded = loadedMessages[locale];
+    if (!result[locale]) {
+      result[locale] = loaded;
+      continue;
+    }
+    result[locale] = {
+      ...result[locale],
+      ...loaded
+    };
+  }
+  return result;
+};
+
+// src/shared/utils/normalize-cache-key.ts
+var CACHE_KEY_DELIMITER = "|";
+var sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
+var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+  if (!key) return null;
+  if (Array.isArray(key)) {
+    if (key.length === 0) return null;
+    const normalized = key.map((k) => {
+      if (k === null) return "__null";
+      if (k === void 0) return "__undefined";
+      if (typeof k === "boolean") return k ? "__true" : "__false";
+      return sanitize(String(k));
+    });
+    return normalized.join(delimiter);
+  }
+  if (typeof key === "boolean") return key ? "__true" : "__false";
+  return String(key);
+};
+
+// src/shared/constants/prefix-placeholder.ts
+var PREFIX_PLACEHOLDER = "{locale}";
+
+// src/shared/utils/resolve-namespaces.ts
+var resolveNamespaces = ({
+  config,
+  pathname
+}) => {
+  const { loader } = config;
+  const {
+    routeNamespaces = {},
+    namespaces: fallbackNamespaces
+  } = loader;
+  const { unprefixedPathname } = extractPathname({ config, pathname });
+  const standardizedPathname = standardizePathname({
+    config,
+    pathname: unprefixedPathname
+  });
+  const placeholderRemovedPathname = standardizedPathname.replace(
+    `/${PREFIX_PLACEHOLDER}`,
+    ""
+  );
+  const defaultNamespaces = routeNamespaces.default ?? [];
+  const exactMatchNamespaces = routeNamespaces[standardizedPathname] ?? routeNamespaces[placeholderRemovedPathname];
+  if (exactMatchNamespaces) {
+    return [...defaultNamespaces, ...exactMatchNamespaces];
+  }
+  let bestMatch = "";
+  let bestNamespaces;
+  const prefixPatterns = Object.keys(routeNamespaces).filter(
+    (pattern) => pattern.endsWith("/*")
+  );
+  for (const pattern of prefixPatterns) {
+    const basePath = pattern.replace(/\/\*$/, "");
+    if (standardizedPathname.startsWith(basePath)) {
+      if (basePath.length > bestMatch.length) {
+        bestMatch = basePath;
+        bestNamespaces = routeNamespaces[pattern];
+      }
+    }
+  }
+  const matchedNamespaces = bestNamespaces ?? routeNamespaces["/*"] ?? fallbackNamespaces ?? [];
+  if (matchedNamespaces.length > 0) {
+    return [...defaultNamespaces, ...matchedNamespaces];
+  } else {
+    return [...defaultNamespaces];
+  }
+};
+
+// src/shared/utils/locale/normalize-locale.ts
+var normalizeLocale = (locale = "", supportedLocales = []) => {
+  if (!locale || supportedLocales.length === 0) return;
+  const toCanonical = (input) => {
+    try {
+      return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
+    } catch {
+      return;
+    }
+  };
+  const canonicalLocale = toCanonical(locale);
+  if (!canonicalLocale) return;
+  const supportedCanonicalMap = /* @__PURE__ */ new Map();
+  for (const l of supportedLocales) {
+    const normalized = toCanonical(l);
+    if (normalized) {
+      supportedCanonicalMap.set(normalized, l);
+    }
+  }
+  if (supportedCanonicalMap.has(canonicalLocale)) {
+    return supportedCanonicalMap.get(canonicalLocale);
+  }
+  const baseLang = canonicalLocale.split("-")[0];
+  for (const [key, original] of supportedCanonicalMap) {
+    const supportedBase = key.split("-")[0];
+    if (supportedBase === baseLang) {
+      return original;
+    }
+  }
+  return;
+};
+
+// src/shared/utils/locale/resolve-preferred-locale.ts
+var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
+  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
+    return;
+  }
+  const supportedLocalesSet = new Set(supportedLocales);
+  const preferred = acceptLanguageHeader.split(",").map((part) => {
+    const [lang, qValue] = part.split(";");
+    const q = qValue ? parseFloat(qValue.split("=")[1]) : 1;
+    if (isNaN(q)) {
+      return { lang: lang.trim(), q: 0 };
+    }
+    return { lang: lang.trim(), q };
+  }).sort((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+  return preferred;
 };
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
-  if (typeof rawPathname !== "string") {
-    throw new TypeError("Expected rawPathname to be a string");
-  }
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
@@ -498,33 +538,101 @@ var normalizePathname = (rawPathname, options = {}) => {
   return result || "/";
 };
 
-// src/modules/intor-messages-loader/load-local-messages/load-local-messages.ts
+// src/shared/utils/pathname/extract-pathname.ts
+var extractPathname = ({
+  config,
+  pathname: rawPathname
+}) => {
+  const { routing, defaultLocale } = config;
+  const { basePath, prefix } = routing;
+  const normalizedPathname = normalizePathname(rawPathname);
+  let prefixedPathname = normalizedPathname;
+  if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+    prefixedPathname = normalizedPathname.slice(basePath.length) || "/";
+  } else if (basePath && normalizedPathname === basePath) {
+    prefixedPathname = "/";
+  }
+  const pathParts = prefixedPathname.split("/").filter(Boolean);
+  const maybeLocale = pathParts[0] || "";
+  const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
+  let unprefixedPathname = prefixedPathname;
+  if (prefix === "all") {
+    if (isLocalePrefixed) {
+      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
+    }
+  } else if (prefix === "except-default") {
+    if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
+      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
+    }
+  }
+  return {
+    basePath,
+    prefixedPathname,
+    unprefixedPathname,
+    maybeLocale,
+    isLocalePrefixed: Boolean(isLocalePrefixed)
+  };
+};
+
+// src/shared/utils/pathname/standardize-pathname.ts
+var standardizePathname = ({
+  config,
+  pathname
+}) => {
+  const { routing } = config;
+  const { basePath } = routing;
+  const parts = [
+    normalizePathname(basePath),
+    PREFIX_PLACEHOLDER,
+    normalizePathname(pathname)
+  ];
+  const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
+  return normalizePathname(standardizedPathname);
+};
+
+// src/modules/messages/load-local-messages/load-local-messages.ts
 var loadLocalMessages = async ({
-  basePath = "messages",
+  basePath,
   locale,
   fallbackLocales,
   namespaces,
   concurrency = 10,
-  loggerId
+  cache = DEFAULT_CACHE_OPTIONS,
+  logger: loggerOptions = { id: "default" }
 }) => {
-  if (!locale || locale.trim() === "") {
-    return {};
-  }
-  const logger = logry({ id: loggerId, scope: "loadLocalMessages" });
+  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.resolve(
     process.cwd(),
     normalizePathname(basePath, { removeLeadingSlash: true })
   );
-  const messages = {};
-  const limit = pLimit(concurrency);
   const start = performance.now();
-  logger.debug("Starting to load local messages with configuration:", {
+  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: namespaces && namespaces.length > 0 ? { count: namespaces?.length, list: [...namespaces] } : "All Namespaces",
     concurrency
   });
+  const pool = getGlobalMessagesPool();
+  const key = normalizeCacheKey([
+    loggerOptions.id,
+    resolvedBasePath,
+    locale,
+    [...fallbackLocales ?? []].sort().join(","),
+    [...namespaces ?? []].sort().join(",")
+  ]);
+  if (cache.enabled && key) {
+    const cached = await pool.get(key);
+    if (cached) {
+      logger.debug("Messages cache hit.", { key });
+      return cached;
+    }
+  }
+  const limit = pLimit(concurrency);
   const validNamespaces = await loadLocaleWithFallback({
     basePath: resolvedBasePath,
     locale,
@@ -532,431 +640,261 @@ var loadLocalMessages = async ({
     namespaces,
     messages,
     limit,
-    loggerId
+    logger: loggerOptions
   });
+  if (cache.enabled && key) {
+    await pool.set(key, messages, cache.ttl);
+  }
   const end = performance.now();
   const duration = Math.round(end - start);
-  if (validNamespaces && validNamespaces?.length > 0) {
-    logger.info("Finished loading local messages.", {
-      locale,
-      namespaces: validNamespaces,
-      duration: `${duration} ms`
-    });
-  } else {
-    logger.warn("No valid namespaces found for the locale.", {
-      locale,
-      namespaces: validNamespaces,
-      duration: `${duration} ms`
-    });
-  }
+  logger.trace("Finished loading local messages.", {
+    locale,
+    validNamespaces,
+    duration: `${duration} ms`
+  });
   return messages;
 };
 
-// src/modules/intor-messages-loader/create-local-messages-loader/create-local-messages-loader.ts
-var createLocalMessagesLoader = (basePath) => {
+// src/modules/messages/create-load-local-messages.ts
+var createLoadLocalMessages = (basePath) => {
   return (options) => loadLocalMessages({ basePath, ...options });
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/build-search-params.ts
-var buildSearchParams = (params) => {
-  const searchParams = new URLSearchParams();
-  const appendParam = (key, value) => {
-    if (value === void 0 || value === null) {
-      return;
-    }
-    if (Array.isArray(value) && value.length > 0) {
-      value.forEach((v) => v && searchParams.append(key, v));
-    } else {
-      searchParams.append(key, value);
-    }
-  };
-  Object.entries(params).forEach(([key, value]) => {
-    appendParam(key, value);
-  });
-  return searchParams;
-};
-var fetcher = async ({
+// src/modules/messages/load-api-messages/fetch-messages.ts
+var fetchMessages = async ({
   apiUrl,
+  apiHeaders,
   locale,
   searchParams,
-  loggerId
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry({ id: loggerId, scope: "fetcher" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "fetch-messages" });
   try {
     const params = new URLSearchParams(searchParams);
     params.append("locale", locale);
     const url = `${apiUrl}?${params.toString()}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...apiHeaders
+    };
     const response = await fetch(url, {
       method: "GET",
-      headers: { "Content-Type": "application/json" },
+      headers,
       cache: "no-store"
     });
     if (!response.ok) {
-      throw new Error(
-        `Fetch failed for locale "${locale}" at URL: ${url} - ${response.status} ${response.statusText}`
-      );
+      throw new Error(`Fetch failed: ${locale} (${response.status})`);
     }
     const data = await response.json();
     if (data == null || typeof data === "object" && Object.keys(data).length === 0) {
-      throw new Error(
-        `Missing or invalid messages for locale "${locale}" at URL: ${url}`
-      );
+      throw new Error(`Invalid messages: ${locale}`);
     }
     return data;
-  } catch {
+  } catch (error) {
     logger.warn(`Failed to fetch messages for locale "${locale}".`, {
       locale,
       apiUrl,
-      searchParams: decodeURIComponent(searchParams.toString())
+      searchParams: decodeURIComponent(searchParams.toString()),
+      error
     });
-    return void 0;
+    return;
   }
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/fetch-fallback-messages.ts
-var fetchFallbackMessages = async (apiUrl, searchParams, fallbackLocales, loggerId) => {
+// 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 fetcher({
+    const result = await fetchMessages({
       apiUrl,
       searchParams,
       locale: fallbackLocale,
-      loggerId
+      apiHeaders,
+      logger
     });
     if (result) {
       return { locale: fallbackLocale, messages: result };
     }
   }
-  return void 0;
+  return;
+};
+
+// src/modules/messages/load-api-messages/utils/build-search-params.ts
+var buildSearchParams = (params) => {
+  const searchParams = new URLSearchParams();
+  const appendParam = (key, value) => {
+    if (value === void 0 || 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;
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/fetch-api-messages.ts
-var fetchApiMessages = async ({
+// src/modules/messages/load-api-messages/load-api-messages.ts
+var loadApiMessages = async ({
   apiUrl,
+  apiHeaders,
   basePath,
   locale,
   fallbackLocales = [],
   namespaces = [],
-  loggerId
+  cache = DEFAULT_CACHE_OPTIONS,
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry({ id: loggerId, scope: "fetchApiMessages" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-api-messages" });
   if (!apiUrl) {
-    logger.warn("No apiUrl provided for fetchApiMessages. Skipping fetch.");
-    return void 0;
+    logger.warn("No apiUrl provided. Skipping fetch.");
+    return;
   }
-  const searchParams = buildSearchParams({
+  const pool = getGlobalMessagesPool();
+  const key = normalizeCacheKey([
+    loggerOptions.id,
     basePath,
-    loggerId,
-    namespaces
-  });
-  const messages = await fetcher({
+    locale,
+    [...fallbackLocales ?? []].sort().join(","),
+    [...namespaces ?? []].sort().join(",")
+  ]);
+  if (cache.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,
-    loggerId
+    logger: loggerOptions
   });
   if (messages) {
+    if (cache.enabled && key) {
+      await pool.set(key, messages, cache.ttl);
+    }
     return messages;
   }
-  const fallbackResult = await fetchFallbackMessages(
+  const fallbackResult = await fetchFallbackMessages({
     apiUrl,
+    apiHeaders,
     searchParams,
     fallbackLocales,
-    loggerId
-  );
+    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;
   }
   logger.warn("Failed to fetch messages for all locales.", {
     locale,
     fallbackLocales
   });
-  return void 0;
+  return;
 };
 
-// src/shared/utils/pathname/extract-pathname.ts
-var extractPathname = ({
-  config,
-  pathname: rawPathname
-}) => {
-  const { routing, defaultLocale } = config;
-  const { basePath, prefix } = routing;
-  const normalizedPathname = normalizePathname(rawPathname);
-  let prefixedPathname = normalizedPathname;
-  if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-    prefixedPathname = normalizedPathname.slice(basePath.length) || "/";
-  } else if (basePath && normalizedPathname === basePath) {
-    prefixedPathname = "/";
-  }
-  const pathParts = prefixedPathname.split("/").filter(Boolean);
-  const maybeLocale = pathParts[0] || "";
-  const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
-  let unprefixedPathname = prefixedPathname;
-  if (prefix === "all") {
-    if (isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  } else if (prefix === "except-default") {
-    if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  }
-  return {
-    basePath,
-    prefixedPathname,
-    unprefixedPathname,
-    maybeLocale,
-    isLocalePrefixed: Boolean(isLocalePrefixed)
-  };
-};
-
-// src/shared/utils/pathname/standardize-pathname.ts
-var standardizePathname = ({
-  config,
-  pathname
-}) => {
-  const { routing, prefixPlaceHolder } = config;
-  const { basePath } = routing;
-  const parts = [
-    normalizePathname(basePath),
-    normalizePathname(prefixPlaceHolder),
-    normalizePathname(pathname)
-  ];
-  const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
-  return normalizePathname(standardizedPathname);
-};
-
-// src/shared/utils/resolve-namespaces.ts
-var resolveNamespaces = ({
-  config,
-  pathname
-}) => {
-  const { loaderOptions, prefixPlaceHolder } = config;
-  const {
-    routeNamespaces = {},
-    namespaces: fallbackNamespaces
-  } = loaderOptions;
-  const { unprefixedPathname } = extractPathname({ config, pathname });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
-  const placeholderRemovedPathname = standardizedPathname.replace(
-    `/${prefixPlaceHolder}`,
-    ""
-  );
-  const defaultNamespaces = routeNamespaces.default ?? [];
-  const exactMatchNamespaces = routeNamespaces[standardizedPathname] ?? routeNamespaces[placeholderRemovedPathname];
-  if (exactMatchNamespaces) {
-    return [...defaultNamespaces, ...exactMatchNamespaces];
-  }
-  let bestMatch = "";
-  let bestNamespaces;
-  const prefixPatterns = Object.keys(routeNamespaces).filter(
-    (pattern) => pattern.endsWith("/*")
-  );
-  for (const pattern of prefixPatterns) {
-    const basePath = pattern.replace(/\/\*$/, "");
-    if (standardizedPathname.startsWith(basePath)) {
-      if (basePath.length > bestMatch.length) {
-        bestMatch = basePath;
-        bestNamespaces = routeNamespaces[pattern];
-      }
-    }
-  }
-  const matchedNamespaces = bestNamespaces ?? routeNamespaces["/*"] ?? fallbackNamespaces ?? [];
-  if (matchedNamespaces.length > 0) {
-    return [...defaultNamespaces, ...matchedNamespaces];
-  } else {
-    return [...defaultNamespaces];
-  }
-};
-
-// src/modules/intor-messages-loader/intor-messages-loader.ts
-var intorMessagesLoader = async ({
+// src/modules/messages/get-messages.ts
+var getMessages = async ({
   config,
   locale,
   pathname
 }) => {
-  const logger = logry({ id: config.id, scope: "intorMessagesLoader" });
-  const loaderOptions = config.loaderOptions;
+  const baseLogger = getLogger({ id: config.id });
+  const logger = baseLogger.child({ scope: "messages-loader" });
+  const loaderOptions = config.loader;
   const fallbackLocales = config.fallbackLocales[locale] || [];
   const namespaces = resolveNamespaces({ config, pathname });
-  let dynamicMessages;
-  logger.info("Namespaces ready for loading:", {
-    namespaces: namespaces.length > 0 ? { count: namespaces.length, list: [...namespaces] } : "All"
-  });
-  logger.debug("Loader type selected:", {
-    loaderType: loaderOptions.type
+  logger.debug("Namespaces ready for loading.", {
+    namespaces: namespaces.length > 0 ? { count: namespaces.length, list: [...namespaces] } : "All Namespaces"
   });
+  logger.debug("Loader type selected.", { loaderType: loaderOptions.type });
+  let loadedMessages;
   if (loaderOptions.type === "import") {
-    const loadLocalMessages2 = createLocalMessagesLoader(loaderOptions.basePath);
-    dynamicMessages = await loadLocalMessages2({
+    const loadLocalMessages2 = createLoadLocalMessages(loaderOptions.basePath);
+    loadedMessages = await loadLocalMessages2({
       ...loaderOptions,
       locale,
       fallbackLocales,
       namespaces,
-      loggerId: config.id
+      cache: config.cache,
+      logger: { id: config.id }
     });
   } else if (loaderOptions.type === "api") {
-    dynamicMessages = await fetchApiMessages({
+    loadedMessages = await loadApiMessages({
       ...loaderOptions,
       locale,
       fallbackLocales,
       namespaces,
-      loggerId: config.id
-    });
-  } else {
-    logger.error("Unknown loader type.", {
-      type: loaderOptions.type
-    });
-    throw new IntorError({
-      id: config.id,
-      code: "INTOR_UNKNOWN_LOADER_TYPE" /* UNKNOWN_LOADER_TYPE */,
-      message: `Unknown loader type: ${loaderOptions.type}`
+      logger: { id: config.id }
     });
   }
-  if (!dynamicMessages || Object.keys(dynamicMessages).length === 0) {
+  if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
     logger.warn("No messages found.", { locale, namespaces });
   }
-  return dynamicMessages;
-};
-
-// src/modules/intor-runtime/utils/should-load-dynamic-messages.ts
-var shouldLoadDynamicMessages = (loaderOptions, adapter) => {
-  if (!loaderOptions) {
-    return false;
-  }
-  const { type, lazyLoad } = loaderOptions;
-  if (type === "import") {
-    return true;
-  }
-  if (type === "api") {
-    if (adapter === "next-client" && lazyLoad) {
-      return false;
-    }
-    return true;
-  }
-  return false;
-};
-
-// src/shared/utils/merge-static-and-dynamic-messages.ts
-var mergeStaticAndDynamicMessages = (staticMessages = {}, dynamicMessages = {}) => {
-  const result = Object.keys(staticMessages).length ? { ...staticMessages } : {};
-  for (const locale in dynamicMessages) {
-    const dynamic = dynamicMessages[locale];
-    if (!result[locale]) {
-      result[locale] = dynamic;
-      continue;
-    }
-    result[locale] = {
-      ...result[locale],
-      ...dynamic
-    };
-  }
-  return result;
+  return loadedMessages;
 };
 
-// src/modules/intor-runtime/intor-runtime.ts
-var intorRuntime = async ({
-  request,
-  config
+// src/modules/intor/intor.ts
+var intor = async ({
+  config,
+  adapter,
+  adapterRuntime
 }) => {
-  const logger = logry({ id: config.id, scope: "intorRuntime" });
-  const {
-    messages: staticMessages,
-    // Static messages defined from config
-    loaderOptions,
-    adapter
-  } = config;
-  if (!intorAdapters.includes(adapter)) {
-    logger.error("Unsupported adapter:", { adapter });
-    throw new IntorError({
-      id: config.id,
-      code: "INTOR_UNSUPPORTED_ADAPTER" /* UNSUPPORTED_ADAPTER */,
-      message: `Unsupported adapter: ${adapter}`
-    });
-  }
-  const adapterRuntime = await resolceAdapterRuntimeLoader({ config });
-  const { locale, pathname } = await adapterRuntime({ config, request });
-  logger.info("Initialized locale and pathname:", { locale, pathname });
-  let dynamicMessages;
-  if (shouldLoadDynamicMessages(loaderOptions, adapter)) {
-    dynamicMessages = await intorMessagesLoader({ config, locale, pathname });
+  const baseLogger = getLogger({ id: config.id, ...config.logger });
+  const logger = baseLogger.child({ scope: "intor" });
+  logger.info("Start Intor initialization.");
+  const { messages, loader } = config;
+  let runtime;
+  if (adapter) {
+    runtime = await adapter(config);
+  } else {
+    runtime = {
+      locale: adapterRuntime?.locale || config.defaultLocale,
+      pathname: adapterRuntime?.pathname || ""
+    };
   }
-  const messages = mergeStaticAndDynamicMessages(
-    staticMessages,
-    dynamicMessages
-  );
-  logger.info("Loaded messages:", {
-    staticMessages: {
-      fromConfig: !!staticMessages
+  const { locale, pathname } = runtime;
+  logger.debug("Runtime resolved via adapter/fallback", runtime);
+  let loadedMessages;
+  if (shouldLoadMessages(loader)) {
+    loadedMessages = await getMessages({ config, locale, pathname });
+  }
+  const mergedMessages = mergeMessages(messages, loadedMessages);
+  logger.info("Messages initialized.", {
+    staticMessages: { enabled: !!messages },
+    loadedMessages: {
+      enabled: !!loadedMessages,
+      ...loader ? { loaderType: loader.type, lazyLoad: !!loader.lazyLoad } : null
     },
-    dynamicMessages: {
-      fromLoader: !!dynamicMessages,
-      ...loaderOptions ? {
-        loaderType: loaderOptions.type,
-        lazyLoad: !!loaderOptions.lazyLoad
-      } : null
-    },
-    mergedMessages: messages
+    mergedMessages
   });
   return {
     config,
     initialLocale: locale,
     pathname,
-    messages
-  };
-};
-
-// src/modules/intor/intor.ts
-var intor = async ({
-  request,
-  config
-}) => {
-  const logger = logry({
-    id: config.id,
-    scope: "intor",
-    ...config.logger
-  });
-  logger.info("Starting Intor initialization:", {
-    adapter: config.adapter
-  });
-  const runtime = await intorRuntime({ config, request });
-  switch (config.adapter) {
-    case "next-server": {
-      return runtime;
-    }
-    case "next-client": {
-      return runtime;
-    }
-    default: {
-      logger.error("Unsupported adapter:", { adapter: config.adapter });
-      throw new IntorError({
-        id: config.id,
-        code: "INTOR_UNSUPPORTED_ADAPTER" /* UNSUPPORTED_ADAPTER */,
-        message: `Unsupported adapter: ${config.adapter}`
-      });
-    }
-  }
-};
-var createIntor = (config, translateHandlers) => {
-  return async (request) => {
-    const { initialLocale, messages } = await intor({ config, request });
-    const translator = new Translator({
-      locale: initialLocale,
-      messages,
-      fallbackLocales: config.fallbackLocales,
-      loadingMessage: config.translator?.loadingMessage,
-      placeholder: config.translator?.placeholder,
-      handlers: translateHandlers
-    });
-    return translator;
+    messages: mergedMessages
   };
 };
 
-export { IntorError, IntorErrorCode, createIntor, extractPathname, fetchApiMessages, intor, loadLocalMessages, mergeStaticAndDynamicMessages, normalizeLocale, normalizePathname, resolveNamespaces, resolvePreferredLocale, standardizePathname };
+export { PREFIX_PLACEHOLDER, clearLoggerPool, clearMessagesPool, extractPathname, getMessages, intor, loadApiMessages, loadLocalMessages, mergeMessages, normalizeCacheKey, normalizeLocale, normalizePathname, resolveNamespaces, resolvePreferredLocale, standardizePathname };