intor 2.2.4 → 2.2.6

package/dist/index.js

@@ -1,248 +1,8 @@
-import path from 'path';
-import { performance as performance$1 } from 'perf_hooks';
-import pLimit from 'p-limit';
-import fs from 'fs/promises';
-import { logry } from 'logry';
 import merge from 'lodash.merge';
-import Keyv from 'keyv';
-import { Translator } from 'intor-translator';
 export { Translator } from 'intor-translator';
 
-// src/modules/intor/utils/should-load-messages.ts
-var shouldLoadMessages = (loader) => {
-  if (!loader) return false;
-  const { type, lazyLoad } = loader;
-  if (type === "local") return true;
-  if (lazyLoad) return false;
-  return true;
-};
-
-// 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/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 = "default",
-  formatterConfig,
-  preset,
-  ...options
-}) {
-  const pool = getGlobalLoggerPool();
-  let logger = pool.get(id);
-  const useDefault = !formatterConfig && !preset;
-  if (!logger) {
-    logger = logry({
-      id,
-      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
-      preset,
-      ...options
-    });
-    pool.set(id, logger);
-    if (pool.size > 1e3) {
-      const keys = [...pool.keys()];
-      for (const key of keys.slice(0, 200)) pool.delete(key);
-    }
-  }
-  return logger;
-}
-
-// src/modules/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.ts
-async function collectFileEntries({
-  readdir = fs.readdir,
-  limit,
-  rootDir,
-  namespaces,
-  extraOptions: { exts = [".json"], loggerOptions } = {}
-}) {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "collect-file-entries" });
-  const results = [];
-  const walk = async (currentDir) => {
-    let entries = [];
-    try {
-      entries = await readdir(currentDir, { withFileTypes: true });
-    } catch (error) {
-      logger.error(`Error reading directory: ${currentDir}`, { error });
-      return;
-    }
-    const tasks = entries.map(
-      (entry) => limit(async () => {
-        const fullPath = path.join(currentDir, entry.name);
-        if (entry.isDirectory()) {
-          await walk(fullPath);
-          return;
-        }
-        if (!exts.some((ext2) => entry.name.endsWith(ext2))) return;
-        const relativePath = path.relative(rootDir, fullPath);
-        const ext = path.extname(relativePath);
-        const withoutExt = relativePath.slice(0, -ext.length);
-        const segments = withoutExt.split(path.sep).filter(Boolean);
-        const namespace = segments.at(0);
-        if (!namespace) return;
-        if (namespaces && namespace !== "index") {
-          if (!namespaces.includes(namespace)) return;
-        }
-        results.push({
-          namespace,
-          fullPath,
-          relativePath,
-          segments,
-          basename: path.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
-    });
-  }
-  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/shared/utils/is-valid-messages.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isValidMessages(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 {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-async function jsonReader(filePath, readFile = fs.readFile) {
-  const raw = await readFile(filePath, "utf8");
-  const parsed = JSON.parse(raw);
-  return parsed;
-}
-
-// src/modules/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/nest-object-from-path.ts
-function nestObjectFromPath(path5, value) {
-  let obj = value;
-  for (let i = path5.length - 1; i >= 0; i--) {
-    obj = { [path5[i]]: obj };
-  }
-  return obj;
-}
-
-// src/modules/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.ts
-async function parseFileEntries({
-  fileEntries,
-  limit,
-  extraOptions: { messagesReader, loggerOptions } = {}
-}) {
-  const baseLogger = getLogger({ ...loggerOptions });
-  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 ext = path.extname(fullPath);
-        const json = ext !== ".json" && messagesReader ? await messagesReader(fullPath) : await jsonReader(fullPath);
-        if (!isValidMessages(json)) {
-          throw new Error(
-            "JSON file does not match NamespaceMessages structure"
-          );
-        }
-        const isIndex = basename === "index";
-        const keyPath = isIndex ? segsWithoutNs.slice(0, -1) : segsWithoutNs;
-        const nested = nestObjectFromPath(keyPath, json);
-        parsedFileEntries.push({ namespace, messages: nested });
-        logger.trace("Parsed file.", { path: fullPath });
-      } catch (error) {
-        logger.error("Failed to read or parse file.", {
-          path: fullPath,
-          error
-        });
-      }
-    })
-  );
-  await Promise.all(tasks);
-  const result = {};
-  for (const { namespace, messages } of parsedFileEntries) {
-    if (namespace === "index") {
-      merge(result, messages);
-    } else {
-      result[namespace] = merge(
-        result[namespace] ?? {},
-        messages
-      );
-    }
-  }
-  return result;
-}
-
-// src/modules/messages/load-local-messages/read-locale-messages/read-locale-messages.ts
-var readLocaleMessages = async ({
-  limit,
-  rootDir = "messages",
-  locale,
-  namespaces,
-  extraOptions: { exts, messagesReader, loggerOptions } = {}
-}) => {
-  const fileEntries = await collectFileEntries({
-    rootDir: path.resolve(process.cwd(), rootDir, locale),
-    namespaces,
-    limit,
-    extraOptions: { exts, loggerOptions }
-  });
-  const namespaceMessages = await parseFileEntries({
-    fileEntries,
-    limit,
-    extraOptions: { messagesReader, loggerOptions }
-  });
-  const localeMessages = { [locale]: namespaceMessages };
-  return localeMessages;
-};
-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/constants/prefix-placeholder.ts
+var PREFIX_PLACEHOLDER = "{locale}";
 var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
   if (!loadedMessages) return { ...staticMessages };
   return merge({}, staticMessages, loadedMessages);
@@ -267,9 +27,6 @@ var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
   return String(key);
 };
 
-// src/shared/constants/prefix-placeholder.ts
-var PREFIX_PLACEHOLDER = "{locale}";
-
 // src/shared/utils/resolve-namespaces.ts
 var resolveNamespaces = ({
   config,
@@ -434,335 +191,24 @@ var standardizePathname = ({
   return normalizePathname(standardizedPathname);
 };
 
-// src/modules/messages/load-local-messages/load-local-messages.ts
-var loadLocalMessages = async ({
-  pool = getGlobalMessagesPool(),
-  rootDir = "messages",
-  locale,
-  fallbackLocales,
-  namespaces,
-  extraOptions: {
-    concurrency = 10,
-    cacheOptions = DEFAULT_CACHE_OPTIONS,
-    loggerOptions = { id: "default" },
-    exts,
-    messagesReader
-  } = {},
-  allowCacheWrite = false
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-local-messages" });
-  const start = performance$1.now();
-  logger.debug("Loading local messages from directory.", {
-    rootDir,
-    resolvedRootDir: path.resolve(process.cwd(), rootDir)
-  });
-  const key = normalizeCacheKey([
-    loggerOptions.id,
-    "loaderType:local",
-    rootDir,
-    locale,
-    (fallbackLocales || []).toSorted().join(","),
-    (namespaces || []).toSorted().join(",")
-  ]);
-  if (cacheOptions.enabled && key) {
-    const cached = await pool?.get(key);
-    if (cached) {
-      logger.debug("Messages cache hit.", { key });
-      return cached;
-    }
+// src/shared/error/intor-error.ts
+var IntorError = class extends Error {
+  code;
+  id;
+  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);
   }
-  const limit = pLimit(concurrency);
-  const candidateLocales = [locale, ...fallbackLocales || []];
-  let messages;
-  for (const candidateLocale of candidateLocales) {
-    try {
-      const result = await readLocaleMessages({
-        limit,
-        rootDir,
-        locale: candidateLocale,
-        namespaces,
-        extraOptions: { loggerOptions, exts, messagesReader }
-      });
-      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
-        messages = result;
-        break;
-      }
-    } catch (error) {
-      logger.error("Failed to read locale messages", {
-        locale: candidateLocale,
-        error
-      });
-    }
-  }
-  if (allowCacheWrite && cacheOptions.enabled && key && messages) {
-    await pool?.set(key, messages, cacheOptions.ttl);
-  }
-  const end = performance$1.now();
-  const duration = Math.round(end - start);
-  logger.trace("Finished loading local messages.", {
-    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
-    duration: `${duration} ms`
-  });
-  return messages;
 };
+var IntorErrorCode = /* @__PURE__ */ ((IntorErrorCode2) => {
+  IntorErrorCode2["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
+  IntorErrorCode2["MISSING_DEFAULT_LOCALE"] = "INTOR_MISSING_DEFAULT_LOCALE";
+  IntorErrorCode2["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
+  return IntorErrorCode2;
+})(IntorErrorCode || {});
 
-// src/modules/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
-var fetchLocaleMessages = async ({
-  remoteUrl,
-  remoteHeaders,
-  searchParams,
-  locale,
-  extraOptions: { loggerOptions } = {}
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
-  try {
-    const params = new URLSearchParams(searchParams);
-    params.append("locale", locale);
-    const url = `${remoteUrl}?${params.toString()}`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...remoteHeaders
-    };
-    const response = await fetch(url, {
-      method: "GET",
-      headers,
-      cache: "no-store"
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!isValidMessages(data[locale])) {
-      throw new Error("JSON file does not match NamespaceMessages structure");
-    }
-    return data;
-  } catch (error) {
-    logger.warn("Fetching locale messages failed.", {
-      locale,
-      remoteUrl,
-      searchParams: decodeURIComponent(searchParams.toString()),
-      error
-    });
-    return;
-  }
-};
-
-// 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) => {
-    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-remote-messages/load-remote-messages.ts
-var loadRemoteMessages = async ({
-  pool = getGlobalMessagesPool(),
-  rootDir,
-  remoteUrl,
-  remoteHeaders,
-  locale,
-  fallbackLocales = [],
-  namespaces = [],
-  extraOptions: {
-    cacheOptions = DEFAULT_CACHE_OPTIONS,
-    loggerOptions = { id: "default" }
-  } = {},
-  allowCacheWrite
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  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,
-    "loaderType:remote",
-    rootDir,
-    locale,
-    (fallbackLocales ?? []).toSorted().join(","),
-    (namespaces ?? []).toSorted().join(",")
-  ]);
-  if (cacheOptions.enabled && key) {
-    const cached = await pool?.get(key);
-    if (cached) {
-      logger.debug("Messages cache hit.", { key });
-      return cached;
-    }
-  }
-  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
-      });
-    }
-  }
-  if (allowCacheWrite && cacheOptions.enabled && key && messages) {
-    await pool?.set(key, messages, cacheOptions.ttl);
-  }
-  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 messages;
-};
-
-// src/modules/messages/load-messages.ts
-var loadMessages = async ({
-  config,
-  locale,
-  pathname = "",
-  extraOptions: { exts, messagesReader } = {},
-  allowCacheWrite = false
-}) => {
-  const baseLogger = getLogger({ id: config.id, ...config.logger });
-  const logger = baseLogger.child({ scope: "load-messages" });
-  if (!config.loader) {
-    logger.warn(
-      "No loader options have been configured in the current config."
-    );
-    return;
-  }
-  const { type, concurrency, rootDir } = config.loader;
-  const fallbackLocales = config.fallbackLocales[locale] || [];
-  const namespaces = resolveNamespaces({ config, pathname });
-  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
-  });
-  let loadedMessages;
-  if (type === "local") {
-    loadedMessages = await loadLocalMessages({
-      rootDir,
-      locale,
-      fallbackLocales,
-      namespaces,
-      extraOptions: {
-        concurrency,
-        cacheOptions: config.cache,
-        loggerOptions: { id: config.id, ...config.logger },
-        exts,
-        messagesReader
-      },
-      allowCacheWrite
-    });
-  } else if (type === "remote") {
-    loadedMessages = await loadRemoteMessages({
-      rootDir,
-      remoteUrl: config.loader.remoteUrl,
-      remoteHeaders: config.loader.remoteHeaders,
-      locale,
-      fallbackLocales,
-      namespaces,
-      extraOptions: {
-        cacheOptions: config.cache,
-        loggerOptions: { id: config.id, ...config.logger }
-      }
-    });
-  }
-  if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
-    logger.warn("No messages found.", { locale, namespaces });
-  }
-  return loadedMessages;
-};
-
-// src/modules/intor/intor.ts
-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.");
-  const { messages, loader } = config;
-  const isI18nContextFunction = typeof i18nContext === "function";
-  const context = isI18nContextFunction ? await i18nContext(config) : {
-    locale: i18nContext?.locale || config.defaultLocale,
-    pathname: i18nContext?.pathname || ""
-  };
-  const { locale, pathname } = 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,
-      extraOptions: {
-        exts: loadMessagesOptions.exts,
-        messagesReader: loadMessagesOptions.messagesReader
-      },
-      allowCacheWrite: true
-    });
-  }
-  const mergedMessages = mergeMessages(messages, loadedMessages);
-  logger.info("Messages successfully initialized.", {
-    static: { enabled: !!messages },
-    loaded: {
-      enabled: !!loadedMessages,
-      ...loader ? { loaderType: loader.type, lazyLoad: !!loader.lazyLoad } : null
-    },
-    merged: mergedMessages
-  });
-  return {
-    config,
-    initialLocale: locale,
-    pathname,
-    messages: mergedMessages
-  };
-};
-async function getTranslator(opts) {
-  const { config, locale, pathname = "", preKey, handlers } = opts;
-  const messages = await loadMessages({ config, locale, pathname });
-  const translator = new Translator({
-    locale,
-    messages,
-    fallbackLocales: config.fallbackLocales,
-    loadingMessage: config.translator?.loadingMessage,
-    placeholder: config.translator?.placeholder,
-    handlers
-  });
-  const props = { messages, locale };
-  const scoped = translator.scoped(preKey);
-  return {
-    ...props,
-    hasKey: preKey ? scoped.hasKey : translator.hasKey,
-    t: preKey ? scoped.t : translator.t
-  };
-}
-
-export { PREFIX_PLACEHOLDER, clearLoggerPool, clearMessagesPool, extractPathname, getTranslator, intor, loadLocalMessages, loadMessages, loadRemoteMessages, mergeMessages, normalizeCacheKey, normalizeLocale, normalizePathname, resolveNamespaces, resolvePreferredLocale, standardizePathname };
+export { IntorError, IntorErrorCode, PREFIX_PLACEHOLDER, extractPathname, mergeMessages, normalizeCacheKey, normalizeLocale, normalizePathname, resolveNamespaces, resolvePreferredLocale, standardizePathname };