intor 1.0.39 → 2.0.0

package/dist/next/server/index.cjs

@@ -0,0 +1,886 @@
+'use strict';
+
+var headers = require('next/headers');
+var logry = require('logry');
+var path = require('path');
+var perf_hooks = require('perf_hooks');
+var pLimit = require('p-limit');
+var fs = require('fs/promises');
+var Keyv = require('keyv');
+var intorTranslator = require('intor-translator');
+
+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 Keyv__default = /*#__PURE__*/_interopDefault(Keyv);
+
+// src/adapters/next/server/next-adapter.ts
+
+// src/adapters/next/shared/constants/pathname-header-name.ts
+var PATHNAME_HEADER_NAME = "x-intor-pathname";
+
+// 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__;
+}
+
+// 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.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/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 = {}) => {
+  const length = rawPathname.length;
+  let start = 0;
+  let end = length - 1;
+  while (start <= end && rawPathname.charCodeAt(start) <= 32) start++;
+  while (end >= start && rawPathname.charCodeAt(end) <= 32) end--;
+  if (start > end) return "/";
+  let result = "";
+  let hasSlash = false;
+  for (let i = start; i <= end; i++) {
+    const char = rawPathname[i];
+    if (char === "/") {
+      if (!hasSlash) {
+        hasSlash = true;
+      }
+    } else {
+      if (hasSlash || result === "") {
+        result += "/" + char;
+      } else {
+        result += char;
+      }
+      hasSlash = false;
+    }
+  }
+  if (options.removeLeadingSlash && result.startsWith("/")) {
+    result = result.slice(1);
+  }
+  return result || "/";
+};
+
+// 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/adapters/next/server/next-adapter.ts
+var nextAdapter = async (config) => {
+  const baseLogger = getLogger({ id: config.id, ...config.logger });
+  const logger = baseLogger.child({ scope: "next-adapter" });
+  const cookiesStore = await headers.cookies();
+  const headersStore = await headers.headers();
+  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.trace("Locale retrieved 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.trace("Locale retrieved from header.", { locale });
+  }
+  const pathname = headersStore.get(PATHNAME_HEADER_NAME);
+  if (pathname) {
+    logger.trace("Pathname retrieved from header.", { pathname });
+  }
+  return {
+    locale: locale || defaultLocale,
+    pathname: pathname || ""
+  };
+};
+
+// 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;
+    super(fullMessage);
+    this.name = "IntorError";
+    this.id = id;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/modules/messages/load-local-messages/utils/read-message-record-file.ts
+var readMessageRecordFile = async (filePath, loggerOptions) => {
+  const fileName = path__default.default.basename(filePath, ".json");
+  const content = await fs__default.default.readFile(filePath, "utf-8");
+  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"
+    });
+  }
+  return { fileName, content: parsed };
+};
+
+// src/modules/messages/load-local-messages/load-namespace-group/parse-message-file.ts
+var MAX_PATH_LENGTH = 260;
+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("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 readMessageRecordFile(trimmedPath, loggerOptions);
+    logger.trace(`Message file loaded.`, { filePath: trimmedPath });
+    return content;
+  } catch (error) {
+    logger.warn("Failed to parse message file.", {
+      filePath: trimmedPath,
+      error
+    });
+    return null;
+  }
+};
+
+// 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);
+      } else {
+        const name = fileName.replace(/\.json$/, "");
+        subEntries[name] = content;
+      }
+    })
+  );
+  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;
+  }
+  const group = namespaceGroups.get(nsKey) || {
+    isAtRoot,
+    filePaths: []
+  };
+  const filePathsSet = new Set(group.filePaths);
+  if (!filePathsSet.has(filePath)) {
+    filePathsSet.add(filePath);
+    group.filePaths = Array.from(filePathsSet);
+    namespaceGroups.set(nsKey, group);
+  }
+};
+
+// src/modules/messages/load-local-messages/prepare-namespace-groups/traverse-directory.ts
+var traverseDirectory = async ({
+  options,
+  currentDirPath,
+  namespaceGroups,
+  namespacePathSegments
+}) => {
+  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__default.default.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
+          });
+        }
+      }).catch((error) => {
+        logger.warn("Failed to process a locale file or directory.", {
+          name: dirent.name,
+          type: dirent.isFile() ? "file" : "directory",
+          path: currentDirPath,
+          error
+        });
+      })
+    );
+    await Promise.all(dirPromises);
+  } catch (error) {
+    logger.warn(`Error reading directory: ${currentDirPath}`, { error });
+  }
+};
+
+// 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;
+};
+
+// src/modules/messages/load-local-messages/load-single-locale/load-single-locale.ts
+var loadSingleLocale = async ({
+  basePath,
+  locale,
+  namespaces,
+  messages,
+  limit,
+  logger: loggerOptions = { id: "default" }
+}) => {
+  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,
+    limit,
+    namespaces: new Set(namespaces || []),
+    logger: 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,
+      fileCounts: 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 localesToTry = [targetLocale, ...fallbackLocales];
+  for (const locale of localesToTry) {
+    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: localesToTry
+  });
+  return;
+};
+function getGlobalMessagesPool() {
+  if (!globalThis.__INTOR_MESSAGES_POOL__) {
+    globalThis.__INTOR_MESSAGES_POOL__ = new Keyv__default.default();
+  }
+  return globalThis.__INTOR_MESSAGES_POOL__;
+}
+
+// src/modules/messages/load-local-messages/load-local-messages.ts
+var loadLocalMessages = async ({
+  basePath,
+  locale,
+  fallbackLocales,
+  namespaces,
+  concurrency = 10,
+  cache = DEFAULT_CACHE_OPTIONS,
+  logger: loggerOptions = { id: "default" }
+}) => {
+  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 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
+  });
+  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__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 end = perf_hooks.performance.now();
+  const duration = Math.round(end - start);
+  logger.trace("Finished loading local messages.", {
+    locale,
+    validNamespaces,
+    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,
+  searchParams,
+  logger: loggerOptions = { id: "default" }
+}) => {
+  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 headers2 = {
+      "Content-Type": "application/json",
+      ...apiHeaders
+    };
+    const response = await fetch(url, {
+      method: "GET",
+      headers: headers2,
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      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(`Invalid messages: ${locale}`);
+    }
+    return data;
+  } catch (error) {
+    logger.warn(`Failed to fetch messages for locale "${locale}".`, {
+      locale,
+      apiUrl,
+      searchParams: decodeURIComponent(searchParams.toString()),
+      error
+    });
+    return;
+  }
+};
+
+// 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
+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/messages/load-api-messages/load-api-messages.ts
+var loadApiMessages = async ({
+  apiUrl,
+  apiHeaders,
+  basePath,
+  locale,
+  fallbackLocales = [],
+  namespaces = [],
+  cache = DEFAULT_CACHE_OPTIONS,
+  logger: 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;
+  }
+  const pool = getGlobalMessagesPool();
+  const key = normalizeCacheKey([
+    loggerOptions.id,
+    basePath,
+    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,
+    logger: loggerOptions
+  });
+  if (messages) {
+    if (cache.enabled && key) {
+      await pool.set(key, messages, cache.ttl);
+    }
+    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;
+  }
+  logger.warn("Failed to fetch messages for all locales.", {
+    locale,
+    fallbackLocales
+  });
+  return;
+};
+
+// src/modules/messages/get-messages.ts
+var getMessages = async ({
+  config,
+  locale,
+  pathname
+}) => {
+  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 });
+  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 = createLoadLocalMessages(loaderOptions.basePath);
+    loadedMessages = await loadLocalMessages2({
+      ...loaderOptions,
+      locale,
+      fallbackLocales,
+      namespaces,
+      cache: config.cache,
+      logger: { id: config.id }
+    });
+  } else if (loaderOptions.type === "api") {
+    loadedMessages = await loadApiMessages({
+      ...loaderOptions,
+      locale,
+      fallbackLocales,
+      namespaces,
+      logger: { id: config.id }
+    });
+  }
+  if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
+    logger.warn("No messages found.", { locale, namespaces });
+  }
+  return loadedMessages;
+};
+
+// src/adapters/next/server/get-messages.ts
+var getMessages2 = async (config) => {
+  const { locale, pathname } = await nextAdapter(config);
+  const messages = await getMessages({ config, locale, pathname });
+  return messages;
+};
+var getTranslation = async (config, preKey, options) => {
+  const { locale, pathname } = await nextAdapter(config);
+  const messages = await getMessages({ config, locale, pathname });
+  const translator = new intorTranslator.Translator({ locale, messages, ...options });
+  const scoped = translator.scoped(preKey);
+  return scoped.t;
+};
+
+exports.getMessages = getMessages2;
+exports.getTranslation = getTranslation;
+exports.nextAdapter = nextAdapter;