intor 2.4.17 → 2.5.1

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

@@ -1,5 +1,4 @@
 import path from 'node:path';
-import '../../../../../core/error/intor-error.js';
 import { deepMerge } from '../../../../../core/utils/deep-merge.js';
 import { getLogger } from '../../../../../core/logger/get-logger.js';
 import 'p-limit';
@@ -8,96 +7,62 @@ import { nestObjectFromPath } from '../../../../../core/messages/utils/nest-obje
 import 'intor-translator';
 import { jsonReader } from './utils/json-reader.js';
 
-/**
- * Parse locale message files into a unified Messages object (single-locale).
- *
- * - Reads JSON or custom formats (via `messagesReader`)
- * - Validates message structure
- * - Builds nested objects based on file path segments
- * - Deep-merges entries by namespace
- *
- * @example
- * ```plain
- * File paths:
- *   - en/index.json        = { a: "A" }
- *   - en/ui.json           = { b: "B" }
- *   - en/auth/index.json   = { c: "C" }
- *   - en/auth/verify.json  = { d: "D" }
- *```
-
- * The final return value is a `Messages` object:
- * ```ts
- * {
- *   a: "A",
- *   ui: { b: "B" },
- *   auth: {
- *     c: "C",
- *     verify: { d: "D" },
- *   },
- * }
- * ```
- */
-async function parseFileEntries({ fileEntries, limit, readers, loggerOptions, }) {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "parse-file-entries" });
-    // Read and parse all file entries
-    const parsedFileEntries = [];
-    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath }) => limit(async () => {
-        try {
-            // -------------------------------------------------------------------
-            // Read and validate file content
-            // -------------------------------------------------------------------
-            const ext = path.extname(fullPath).slice(1); // remove dot
-            let raw;
-            if (ext === "json") {
-                raw = await jsonReader(fullPath);
-            }
-            else {
-                const reader = readers?.[ext];
-                if (!reader) {
-                    throw new Error(`No message reader registered for .${ext} files. ` +
-                        `Please register a reader for the "${ext}" extension.`);
-                }
-                raw = await reader(fullPath);
-            }
-            // Validate messages structure
-            if (!isValidMessages(raw)) {
-                throw new Error("Parsed content does not match expected Messages structure");
-            }
-            // -------------------------------------------------------------------
-            // Build nested message object from path segments
-            // -------------------------------------------------------------------
-            const segmentsWithoutNamespace = segments.slice(1);
-            const isIndexFile = basename === "index";
-            const keyPath = isIndexFile
-                ? segmentsWithoutNamespace.slice(0, -1)
-                : segmentsWithoutNamespace;
-            // Nest the parsed content based on the path segments
-            const nestedMessages = nestObjectFromPath(keyPath, raw);
-            parsedFileEntries.push({ namespace, messages: nestedMessages });
-        }
-        catch (error) {
-            logger.warn("Failed to read or parse file.", {
-                path: fullPath,
-                error,
-            });
-        }
-    }));
-    await Promise.all(tasks);
-    // ---------------------------------------------------------------------------
-    // Merge parsed entries by namespace
-    // ---------------------------------------------------------------------------
-    const result = {};
-    for (const { namespace, messages } of parsedFileEntries) {
-        // Root-level namespace (e.g. [locale]/index.json)
-        if (namespace === "index") {
-            Object.assign(result, deepMerge(result, messages));
+async function parseFileEntries({
+  fileEntries,
+  limit,
+  readers,
+  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 ext = path.extname(fullPath).slice(1);
+        let raw;
+        if (ext === "json") {
+          raw = await jsonReader(fullPath);
+        } else {
+          const reader = readers?.[ext];
+          if (!reader) {
+            throw new Error(
+              `No message reader registered for .${ext} files. Please register a reader for the "${ext}" extension.`
+            );
+          }
+          raw = await reader(fullPath);
         }
-        else {
-            result[namespace] = deepMerge(result[namespace], messages);
+        if (!isValidMessages(raw)) {
+          throw new Error(
+            "Parsed content does not match expected Messages structure"
+          );
         }
+        const segmentsWithoutNamespace = segments.slice(1);
+        const isIndexFile = basename === "index";
+        const keyPath = isIndexFile ? segmentsWithoutNamespace.slice(0, -1) : segmentsWithoutNamespace;
+        const nestedMessages = nestObjectFromPath(keyPath, raw);
+        parsedFileEntries.push({ namespace, messages: nestedMessages });
+      } catch (error) {
+        logger.warn("Failed to read or parse file.", {
+          path: fullPath,
+          error
+        });
+      }
+    })
+  );
+  await Promise.all(tasks);
+  const result = {};
+  for (const { namespace, messages } of parsedFileEntries) {
+    if (namespace === "index") {
+      Object.assign(result, deepMerge(result, messages));
+    } else {
+      result[namespace] = deepMerge(
+        result[namespace],
+        messages
+      );
     }
-    return result;
+  }
+  return result;
 }
 
 export { parseFileEntries };

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

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

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

@@ -2,41 +2,29 @@ import path from 'node:path';
 import { collectFileEntries } from './collect-file-entries/collect-file-entries.js';
 import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
 
-/**
- * Read and assemble messages for a single locale from the file system.
- *
- * This function acts as a thin orchestration layer:
- * - Collects message file metadata for the locale
- * - Parses files into a single Messages object
- * - Wraps the result under the locale key
- *
- * It does not perform validation or transformation itself.
- */
-const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, readers, loggerOptions, }) => {
-    // ---------------------------------------------------------------------------
-    // Collect message file entries for the locale
-    // ---------------------------------------------------------------------------
-    const fileEntries = await collectFileEntries({
-        namespaces,
-        rootDir: path.resolve(rootDir, locale),
-        limit,
-        exts: Object.keys(readers || {}),
-        loggerOptions,
-    });
-    // ---------------------------------------------------------------------------
-    // Parse collected files into a Messages object (single-locale)
-    // ---------------------------------------------------------------------------
-    const messages = await parseFileEntries({
-        fileEntries,
-        limit,
-        readers,
-        loggerOptions,
-    });
-    // ---------------------------------------------------------------------------
-    // Wrap parsed messages under the locale key
-    // ---------------------------------------------------------------------------
-    const localeMessages = { [locale]: messages };
-    return localeMessages;
+const readLocaleMessages = async ({
+  locale,
+  namespaces,
+  rootDir = "messages",
+  limit,
+  readers,
+  loggerOptions
+}) => {
+  const fileEntries = await collectFileEntries({
+    ...namespaces !== void 0 ? { namespaces } : {},
+    rootDir: path.resolve(rootDir, locale),
+    limit,
+    exts: Object.keys(readers || {}),
+    loggerOptions
+  });
+  const messages = await parseFileEntries({
+    fileEntries,
+    limit,
+    readers: readers ?? {},
+    loggerOptions
+  });
+  const localeMessages = { [locale]: messages };
+  return localeMessages;
 };
 
 export { readLocaleMessages };

package/dist/core/src/server/messages/load-messages.js

@@ -1,78 +1,66 @@
-import '../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import { getLogger } from '../../core/logger/get-logger.js';
 import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
 import 'intor-translator';
 import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
 
-/**
- * Load locale messages according to the resolved Intor loader configuration.
- *
- * This function is the top-level orchestration entry for message loading.
- * It is responsible for:
- *
- * - Resolving the active loader strategy (local or remote)
- * - Dispatching to the appropriate loader implementation
- * - Passing through cache and read-related options
- *
- * Message traversal, parsing, fallback resolution, and caching logic
- * are delegated to the selected loader.
- */
-const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
-    const baseLogger = getLogger(config.logger);
-    const logger = baseLogger.child({ scope: "load-messages" });
-    // ---------------------------------------------------------------------------
-    // Resolve loader configuration
-    // ---------------------------------------------------------------------------
-    const loader = resolveLoaderOptions(config, "server");
-    if (!loader) {
-        logger.warn("No loader options have been configured in the current config.");
-        return;
-    }
-    const { mode, namespaces, concurrency } = loader;
-    const fallbackLocales = config.fallbackLocales[locale] || [];
-    logger.info(`Loading messages for locale "${locale}".`);
-    logger.trace("Starting to load messages with runtime context.", {
-        loaderMode: mode,
-        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
-        locale,
-        fallbackLocales: fallbackLocales.join(", "),
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
+const loadMessages = async ({
+  config,
+  locale,
+  readers,
+  allowCacheWrite = false,
+  fetch
+}) => {
+  const baseLogger = getLogger(config.logger);
+  const logger = baseLogger.child({ scope: "load-messages" });
+  const loader = resolveLoaderOptions(config, "server");
+  if (!loader) {
+    logger.warn(
+      "No loader options have been configured in the current config."
+    );
+    return;
+  }
+  const { mode, namespaces, concurrency } = loader;
+  const fallbackLocales = config.fallbackLocales[locale] || [];
+  logger.info(`Loading messages for locale "${locale}".`);
+  logger.trace("Starting to load messages with runtime context.", {
+    loaderMode: mode,
+    ...mode === "local" ? { rootDir: loader.rootDir } : {},
+    locale,
+    fallbackLocales: fallbackLocales.join(", "),
+    namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*"
+  });
+  let loadedMessages;
+  if (mode === "local") {
+    const { rootDir } = loader;
+    loadedMessages = await loadLocalMessages({
+      id: config.id,
+      locale,
+      fallbackLocales,
+      ...namespaces !== void 0 ? { namespaces } : {},
+      ...rootDir !== void 0 ? { rootDir } : {},
+      ...concurrency !== void 0 ? { concurrency } : {},
+      readers: readers ?? {},
+      allowCacheWrite,
+      loggerOptions: config.logger
     });
-    // ---------------------------------------------------------------------------
-    // Dispatch to loader implementation
-    // ---------------------------------------------------------------------------
-    let loadedMessages;
-    if (mode === "local") {
-        loadedMessages = await loadLocalMessages({
-            id: config.id,
-            locale,
-            fallbackLocales,
-            namespaces,
-            rootDir: loader.rootDir,
-            concurrency,
-            readers,
-            allowCacheWrite,
-            loggerOptions: config.logger,
-        });
-    }
-    else if (mode === "remote") {
-        loadedMessages = await loadRemoteMessages({
-            locale,
-            fallbackLocales,
-            namespaces,
-            concurrency,
-            fetch,
-            url: loader.url,
-            headers: loader.headers,
-            loggerOptions: config.logger,
-        });
-    }
-    // Final sanity check
-    if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
-        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
-    }
-    return loadedMessages;
+  } else if (mode === "remote") {
+    const { url, headers } = loader;
+    loadedMessages = await loadRemoteMessages({
+      locale,
+      fallbackLocales,
+      ...namespaces !== void 0 ? { namespaces } : {},
+      ...concurrency !== void 0 ? { concurrency } : {},
+      fetch,
+      url,
+      ...headers !== void 0 ? { headers } : {},
+      loggerOptions: config.logger
+    });
+  }
+  if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
+    logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
+  }
+  return loadedMessages;
 };
 
 export { loadMessages };

package/dist/core/src/server/translator/init-translator.js

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import 'logry';
 import 'p-limit';
@@ -8,32 +7,36 @@ import { loadMessages } from '../messages/load-messages.js';
 import 'node:path';
 import 'node:fs/promises';
 
-/**
- * Initialize a locale-bound Translator snapshot.
- *
- * - Resolves loader options and loads messages if configured
- * - Creates an immutable Translator instance for server usage
- */
 async function initTranslator(config, locale, options) {
-    const { loader, readers, allowCacheWrite = false, fetch, handlers, plugins, } = options;
-    const loaderOptions = resolveLoaderOptions(config, "server");
-    // Load messages
-    let messages = {};
-    if (loaderOptions && !loader) {
-        const loaded = await loadMessages({
-            config,
-            locale,
-            readers,
-            allowCacheWrite,
-            fetch,
-        });
-        messages = loaded || {};
-    }
-    if (loader) {
-        messages = await loader(config, locale);
-    }
-    // Create immutable translator snapshot
-    return createTranslator({ config, locale, messages, handlers, plugins });
+  const {
+    loader,
+    readers,
+    allowCacheWrite = false,
+    fetch,
+    handlers,
+    hooks
+  } = options;
+  const loaderOptions = resolveLoaderOptions(config, "server");
+  let messages = {};
+  if (loader) {
+    messages = await loader(config, locale);
+  } else if (loaderOptions) {
+    const loaded = await loadMessages({
+      config,
+      locale,
+      ...readers !== void 0 ? { readers } : {},
+      allowCacheWrite,
+      fetch
+    });
+    messages = loaded || {};
+  }
+  return createTranslator({
+    config,
+    locale,
+    messages,
+    ...handlers !== void 0 ? { handlers } : {},
+    ...hooks !== void 0 ? { hooks } : {}
+  });
 }
 
 export { initTranslator };

package/dist/express/src/adapters/express/create-intor-handler.js

@@ -1,4 +1,4 @@
-import '../../core/error/intor-error.js';
+import { getTranslator } from 'intor/server';
 import { parseCookieHeader } from '../../core/utils/parse-cookie-header.js';
 import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
@@ -6,52 +6,43 @@ import 'p-limit';
 import 'intor-translator';
 import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
-import 'node:path';
-import 'node:fs/promises';
-import { getTranslator } from '../../server/helpers/get-translator.js';
 
-/**
- * Resolves locale-aware routing for the current execution context.
- *
- * - Binds resolved routing state to the request.
- * - Convenience routing shortcuts are also bound to the request for downstream consumption.
- *
- * @platform Express
- */
 function createIntorHandler(config, options) {
-    return async function intorHandler(req, _res, next) {
-        // Locale from Accept-Language header
-        const acceptLanguage = req.headers["accept-language"];
-        const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
-        // ----------------------------------------------------------
-        // Resolve inbound routing decision (pure computation)
-        // ----------------------------------------------------------
-        const { locale, localeSource, pathname } = await resolveInbound(config, req.path, {
-            host: req.hostname,
-            query: normalizeQuery(req.query),
-            cookie: parseCookieHeader(req.headers.cookie)[config.cookie.name],
-            detected: localeFromAcceptLanguage || config.defaultLocale,
-        });
-        // --------------------------------------------------
-        // Bind inbound routing context
-        // --------------------------------------------------
-        req.intor = { locale, localeSource, pathname };
-        const { hasKey, t, tRich } = await getTranslator(config, {
-            locale,
-            handlers: options?.handlers,
-            plugins: options?.plugins,
-            readers: options?.readers,
-            allowCacheWrite: true,
-        });
-        // DX shortcuts (enabled by default)
-        if (options?.shortcuts !== false) {
-            req.locale = locale;
-            req.hasKey = hasKey;
-            req.t = t;
-            req.tRich = tRich;
-        }
-        return next();
-    };
+  return async function intorHandler(req, _res, next) {
+    const acceptLanguage = req.headers["accept-language"];
+    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(
+      acceptLanguage,
+      config.supportedLocales
+    );
+    const cookie = parseCookieHeader(req.headers.cookie)[config.cookie.name];
+    const { locale, localeSource, pathname } = resolveInbound(
+      config,
+      req.path,
+      {
+        host: req.hostname,
+        query: normalizeQuery(req.query),
+        ...cookie !== void 0 ? { cookie } : {},
+        ...localeFromAcceptLanguage !== void 0 ? { detected: localeFromAcceptLanguage } : {}
+      }
+    );
+    req.intor = { locale, localeSource, pathname };
+    const { loader, readers, handlers, hooks } = options ?? {};
+    const { hasKey, t, tRich } = await getTranslator(config, {
+      locale,
+      ...loader !== void 0 ? { loader } : {},
+      ...readers !== void 0 ? { readers } : {},
+      allowCacheWrite: true,
+      ...handlers !== void 0 ? { handlers } : {},
+      ...hooks !== void 0 ? { hooks } : {}
+    });
+    if (options?.shortcuts !== false) {
+      req.locale = locale;
+      req.hasKey = hasKey;
+      req.t = t;
+      req.tRich = tRich;
+    }
+    return next();
+  };
 }
 
 export { createIntorHandler };

package/dist/express/src/adapters/express/get-translator.js

@@ -1,29 +1,8 @@
-import '../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import 'node:path';
-import 'node:fs/promises';
-import { getTranslator as getTranslator$1 } from '../../server/helpers/get-translator.js';
+import { getTranslator as getTranslator$1 } from 'intor/server';
 
-/**
- * Get a server-side translator for the current execution context.
- *
- * - Automatically resolves the locale from the framework context.
- *
- * @platform Express
- */
 async function getTranslator(config, req, params) {
-    const { loader, readers, allowCacheWrite, handlers, plugins, preKey } = params || {};
-    return getTranslator$1(config, {
-        locale: req.intor?.locale || config.defaultLocale,
-        loader,
-        readers,
-        allowCacheWrite,
-        handlers,
-        plugins,
-        preKey,
-    });
+  const locale = req.intor?.locale ?? config.defaultLocale;
+  return getTranslator$1(config, { locale, ...params ?? {} });
 }
 
 export { getTranslator };

package/dist/express/src/core/constants/locale-placeholder.js

@@ -1,4 +1,3 @@
-// Default locale placeholder
 const LOCALE_PLACEHOLDER = "{locale}";
 
 export { LOCALE_PLACEHOLDER };

package/dist/express/src/core/locale/canonicalize-locale.js

@@ -1,23 +1,12 @@
-/**
- * Canonicalizes a BCP 47 locale string.
- *
- * - Uses `Intl.getCanonicalLocales` when available.
- * - Returns the original input if `Intl` is unavailable.
- * - Returns `undefined` for invalid locale input.
- *
- * This function performs normalization only.
- * It does not perform matching or fallback.
- */
 function canonicalizeLocale(input) {
-    try {
-        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
-            return input;
-        }
-        return Intl.getCanonicalLocales(input)[0];
-    }
-    catch {
-        return;
+  try {
+    if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+      return input;
     }
+    return Intl.getCanonicalLocales(input)[0];
+  } catch {
+    return;
+  }
 }
 
 export { canonicalizeLocale };