intor 2.4.17 → 2.5.1

package/dist/core/src/routing/pathname/standardize-pathname.js

@@ -1,34 +1,15 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Standardizes a canonical pathname into an internal routing template
- * by applying the base path and injecting a locale placeholder.
- *
- * @example
- * ```ts
- * // config.routing.basePath: "/app",
- * // config.routing.prefix: "all"
- * standardizePathname("/about", config);
- * // => "/app/{locale}/about"
- * ```
- */
-const standardizePathname = (canonicalizedPathname, config) => {
-    const { basePath } = config.routing;
-    // Normalize each segment before join to avoid redundant slashes
-    const parts = [
-        normalizePathname(basePath),
-        LOCALE_PLACEHOLDER,
-        normalizePathname(canonicalizedPathname),
-    ];
-    // Avoid double slashes between segments
-    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-    // Final normalization to ensure leading slash, no trailing
-    return normalizePathname(standardizedPathname);
+const standardizePathname = (canonicalPathname, config) => {
+  const { routing } = config;
+  const basePath = routing.basePath && routing.basePath !== "/" ? routing.basePath : "";
+  if (canonicalPathname === "/") {
+    return basePath ? `${basePath}/${LOCALE_PLACEHOLDER}` : `/${LOCALE_PLACEHOLDER}`;
+  }
+  return basePath ? `${basePath}/${LOCALE_PLACEHOLDER}${canonicalPathname}` : `/${LOCALE_PLACEHOLDER}${canonicalPathname}`;
 };
 
 export { standardizePathname };

package/dist/core/src/server/helpers/get-translator.js

@@ -1,32 +1,36 @@
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import { createTRich } from '../../core/translator/create-t-rich.js';
 import { initTranslator } from '../translator/init-translator.js';
 
-/**
- * Get a server-side translator for the current execution context.
- */
 async function getTranslator(config, params) {
-    const { locale, loader, readers, allowCacheWrite = false, fetch, handlers, plugins, preKey, } = params;
-    // Initialize a locale-bound translator snapshot with messages loaded
-    const translator = await initTranslator(config, locale, {
-        loader,
-        readers,
-        allowCacheWrite,
-        fetch: fetch || globalThis.fetch,
-        handlers,
-        plugins,
-    });
-    const scoped = translator.scoped(preKey);
-    return {
-        messages: translator.messages,
-        locale: translator.locale,
-        hasKey: scoped.hasKey,
-        t: scoped.t,
-        tRich: createTRich(scoped.t),
-    };
+  const {
+    locale,
+    loader,
+    readers,
+    allowCacheWrite = false,
+    fetch = globalThis.fetch,
+    handlers,
+    hooks,
+    preKey
+  } = params;
+  const translator = await initTranslator(config, locale, {
+    ...loader !== void 0 ? { loader } : {},
+    ...readers !== void 0 ? { readers } : {},
+    allowCacheWrite,
+    fetch,
+    ...handlers !== void 0 ? { handlers } : {},
+    ...hooks !== void 0 ? { hooks } : {}
+  });
+  const scoped = translator.scoped(preKey);
+  return {
+    messages: translator.messages,
+    locale: translator.locale,
+    hasKey: scoped.hasKey,
+    t: scoped.t,
+    tRich: createTRich(scoped.t)
+  };
 }
 
 export { getTranslator };

package/dist/core/src/server/intor/intor.js

@@ -1,32 +1,29 @@
-import '../../core/error/intor-error.js';
 import { getLogger } from '../../core/logger/get-logger.js';
 import 'p-limit';
 import 'intor-translator';
 import { initTranslator } from '../translator/init-translator.js';
 
-/**
- * Initializes Intor for the current execution context.
- *
- * Produces a server-side snapshot for SSR and
- * full-stack rendering environments.
- */
 async function intor(config, locale, options) {
-    const baseLogger = getLogger(config.logger);
-    const logger = baseLogger.child({ scope: "intor" });
-    logger.info("Start Intor initialization.");
-    logger.debug(`Initializing Intor with locale "${locale}".`);
-    // Initialize a locale-bound translator snapshot with messages loaded
-    const translator = await initTranslator(config, locale, {
-        readers: options?.readers,
-        allowCacheWrite: options?.allowCacheWrite ?? true,
-        fetch: options?.fetch || globalThis.fetch,
-    });
-    logger.info("Intor initialized.");
-    return {
-        config,
-        locale: translator.locale,
-        messages: translator.messages,
-    };
+  const baseLogger = getLogger(config.logger);
+  const logger = baseLogger.child({ scope: "intor" });
+  logger.info("Start Intor initialization.");
+  logger.debug(`Initializing Intor with locale "${locale}".`);
+  const {
+    readers,
+    allowCacheWrite = true,
+    fetch = globalThis.fetch
+  } = options ?? {};
+  const translator = await initTranslator(config, locale, {
+    ...readers !== void 0 ? { readers } : {},
+    allowCacheWrite,
+    fetch
+  });
+  logger.info("Intor initialized.");
+  return {
+    config,
+    locale: translator.locale,
+    messages: translator.messages
+  };
 }
 
 export { intor };

package/dist/core/src/server/messages/load-local-messages/cache/messages-pool.js

@@ -1,17 +1,8 @@
-/**
- * Get the messages pool.
- */
 function getMessagesPool() {
-    if (!globalThis.__INTOR_MESSAGES_POOL__) {
-        globalThis.__INTOR_MESSAGES_POOL__ = new Map();
-    }
-    return globalThis.__INTOR_MESSAGES_POOL__;
-}
-/**
- * Clear all cached messages.
- */
-function clearMessagesPool() {
-    getMessagesPool().clear();
+  if (!globalThis.__INTOR_MESSAGES_POOL__) {
+    globalThis.__INTOR_MESSAGES_POOL__ = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__INTOR_MESSAGES_POOL__;
 }
 
-export { clearMessagesPool, getMessagesPool };
+export { getMessagesPool };

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

@@ -1,108 +1,90 @@
 import path from 'node:path';
 import pLimit from 'p-limit';
-import '../../../core/error/intor-error.js';
 import { normalizeCacheKey } from '../../../core/utils/normalizers/normalize-cache-key.js';
 import { getLogger } from '../../../core/logger/get-logger.js';
 import 'intor-translator';
 import { getMessagesPool } from './cache/messages-pool.js';
 import { readLocaleMessages } from './read-locale-messages/read-locale-messages.js';
 
-/**
- * Load locale messages from the local file system.
- *
- * This function serves as the orchestration layer for local message loading.
- * It coordinates:
- *
- * - Locale resolution with fallbacks
- * - Concurrency control for file system access
- * - Process-level memoization (read by default, write by ownership)
- *
- * Local messages are cached for the lifetime of the process.
- * Cache writes are restricted to the primary initialization flow.
- *
- * File traversal, parsing, and validation are delegated to lower-level utilities.
- */
-const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readers, pool = getMessagesPool(), allowCacheWrite = false, loggerOptions, }) => {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "load-local-messages" });
-    const start = performance.now();
-    logger.debug("Loading local messages.", {
-        rootDir,
-        resolvedRootDir: path.resolve(rootDir),
-    });
-    // ---------------------------------------------------------------------------
-    // Cache key resolution
-    // ---------------------------------------------------------------------------
-    const cacheKey = normalizeCacheKey([
-        id,
-        "loaderType:local",
-        rootDir,
-        locale,
-        fallbackLocales?.toSorted().join(","),
-        namespaces?.toSorted().join(","),
-    ].filter(Boolean));
-    // ---------------------------------------------------------------------------
-    // Cache read
-    // ---------------------------------------------------------------------------
-    if (cacheKey) {
-        const cached = pool.get(cacheKey);
-        if (cached) {
-            logger.debug("Messages cache hit.", { key: cacheKey });
-            return cached;
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Resolve locale messages with ordered fallback strategy
-    // ---------------------------------------------------------------------------
-    const limit = pLimit(concurrency);
-    const candidateLocales = [locale, ...(fallbackLocales || [])];
-    let messages;
-    for (let i = 0; i < candidateLocales.length; i++) {
-        const candidateLocale = candidateLocales[i];
-        const isLast = i === candidateLocales.length - 1;
-        try {
-            const result = await readLocaleMessages({
-                locale: candidateLocale,
-                namespaces,
-                rootDir,
-                limit,
-                readers,
-                loggerOptions,
-            });
-            // Stop at the first locale that yields non-empty messages
-            if (Object.values(result[candidateLocale] || {}).length > 0) {
-                messages = result;
-                break;
-            }
-        }
-        catch {
-            if (isLast) {
-                logger.warn("Failed to load messages for all candidate locales.", {
-                    locale,
-                    fallbackLocales,
-                });
-            }
-            else {
-                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
-            }
-        }
+const loadLocalMessages = async ({
+  id,
+  locale,
+  fallbackLocales,
+  namespaces,
+  rootDir = "messages",
+  concurrency = 10,
+  readers,
+  pool = getMessagesPool(),
+  allowCacheWrite = false,
+  loggerOptions
+}) => {
+  const baseLogger = getLogger(loggerOptions);
+  const logger = baseLogger.child({ scope: "load-local-messages" });
+  const start = performance.now();
+  logger.debug("Loading local messages.", {
+    rootDir,
+    resolvedRootDir: path.resolve(rootDir)
+  });
+  const cacheKey = normalizeCacheKey(
+    [
+      id,
+      "loaderType:local",
+      rootDir,
+      locale,
+      fallbackLocales?.sort().join(","),
+      namespaces?.sort().join(",")
+    ].filter(Boolean)
+  );
+  if (cacheKey) {
+    const cached = pool.get(cacheKey);
+    if (cached) {
+      logger.debug("Messages cache hit.", { key: cacheKey });
+      return cached;
     }
-    // ---------------------------------------------------------------------------
-    // Cache write (explicitly permitted)
-    // ---------------------------------------------------------------------------
-    const isProd = process.env.NODE_ENV === "production";
-    const canWriteCache = isProd && allowCacheWrite;
-    if (canWriteCache && cacheKey && messages) {
-        pool.set(cacheKey, messages);
-    }
-    // Final success log with resolved locale and timing
-    if (messages) {
-        logger.trace("Finished loading local messages.", {
-            loadedLocale: Object.keys(messages)[0],
-            duration: `${Math.round(performance.now() - start)} ms`,
+  }
+  const limit = pLimit(concurrency);
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
+    try {
+      const result = await readLocaleMessages({
+        locale: candidateLocale,
+        ...namespaces !== void 0 ? { namespaces } : {},
+        rootDir,
+        limit,
+        readers: readers ?? {},
+        loggerOptions
+      });
+      if (Object.values(result[candidateLocale] || {}).length > 0) {
+        messages = result;
+        break;
+      }
+    } catch {
+      if (isLast) {
+        logger.warn("Failed to load messages for all candidate locales.", {
+          locale,
+          fallbackLocales
         });
+      } else {
+        logger.warn(
+          `Failed to load locale messages for "${candidateLocale}", trying next fallback.`
+        );
+      }
     }
-    return messages;
+  }
+  const isProd = process.env["NODE_ENV"] === "production";
+  const canWriteCache = isProd && allowCacheWrite;
+  if (canWriteCache && cacheKey && messages) {
+    pool.set(cacheKey, messages);
+  }
+  if (messages) {
+    logger.trace("Finished loading local messages.", {
+      loadedLocale: Object.keys(messages)[0],
+      duration: `${Math.round(performance.now() - start)} ms`
+    });
+  }
+  return messages;
 };
 
 export { loadLocalMessages };

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

@@ -1,91 +1,69 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import '../../../../../core/error/intor-error.js';
 import { getLogger } from '../../../../../core/logger/get-logger.js';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Recursively collects message file metadata under a given locale root.
- *
- * - Traverses directories and collects matching message files
- * - Supports filtering by file extensions and optional namespaces
- *
- * @example
- * ```ts
- * [{
- *     namespace: "auth", // If messages under locale root (no namespace) -> "index"
- *     fullPath: "/Users/john/my-app/messages/en-US/auth/login.json",
- *     relativePath: "auth/login.json",
- *     segments: ["auth", "login"],
- *     basename: "login",
- * }, ... ];
- * ```
- */
-async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, exts = [], loggerOptions, }) {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "collect-file-entries" });
-    const supportedExts = new Set(["json", ...exts]);
-    const fileEntries = [];
-    // Recursive directory walk
-    const walk = async (currentDir) => {
-        // -------------------------------------------------------------------------
-        // Read directory entries
-        // -------------------------------------------------------------------------
-        let entries = [];
-        try {
-            entries = await readdir(currentDir, { withFileTypes: true });
-        }
-        catch {
-            logger.debug("Locale directory not found, skipping locale.", {
-                localeDir: currentDir,
-            });
-            return;
-        }
-        // -------------------------------------------------------------------------
-        // 1. Recurse into sub-directories (control flow, no limit)
-        // -------------------------------------------------------------------------
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            await walk(path.join(currentDir, entry.name));
-        }
-        // -------------------------------------------------------------------------
-        // 2. Process files (IO-bound, concurrency-limited)
-        // -------------------------------------------------------------------------
-        const tasks = entries
-            .filter((entry) => entry.isFile())
-            .map((entry) => limit(async () => {
-            const fullPath = path.join(currentDir, entry.name);
-            const ext = path.extname(entry.name).slice(1);
-            if (!ext || !supportedExts.has(ext))
-                return;
-            const relativePath = path.relative(rootDir, fullPath);
-            const withoutExt = relativePath.slice(0, relativePath.length - (ext.length + 1));
-            const segments = withoutExt.split(path.sep).filter(Boolean);
-            const namespace = segments.at(0);
-            if (!namespace)
-                return;
-            // Apply namespace filter (always allow "index")
-            if (namespaces && namespace !== "index") {
-                if (!namespaces.includes(namespace))
-                    return;
-            }
-            fileEntries.push({
-                namespace,
-                fullPath,
-                relativePath,
-                segments,
-                basename: path.basename(entry.name, `.${ext}`),
-            });
-        }));
-        await Promise.all(tasks);
-    };
-    await walk(rootDir);
-    if (fileEntries.length > 0) {
-        logger.trace(`Collected ${fileEntries.length} local message files for locale "${path.basename(rootDir)}".`);
+async function collectFileEntries({
+  readdir = fs.readdir,
+  namespaces,
+  rootDir,
+  limit,
+  exts = [],
+  loggerOptions
+}) {
+  const baseLogger = getLogger(loggerOptions);
+  const logger = baseLogger.child({ scope: "collect-file-entries" });
+  const supportedExts = /* @__PURE__ */ new Set(["json", ...exts]);
+  const fileEntries = [];
+  const walk = async (currentDir) => {
+    let entries = [];
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      logger.debug("Locale directory not found, skipping locale.", {
+        localeDir: currentDir
+      });
+      return;
     }
-    return fileEntries;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      await walk(path.join(currentDir, entry.name));
+    }
+    const tasks = entries.filter((entry) => entry.isFile()).map(
+      (entry) => limit(() => {
+        const fullPath = path.join(currentDir, entry.name);
+        const ext = path.extname(entry.name).slice(1);
+        if (!ext || !supportedExts.has(ext)) return;
+        const relativePath = path.relative(rootDir, fullPath);
+        const withoutExt = relativePath.slice(
+          0,
+          relativePath.length - (ext.length + 1)
+        );
+        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;
+        }
+        fileEntries.push({
+          namespace,
+          fullPath,
+          relativePath,
+          segments,
+          basename: path.basename(entry.name, `.${ext}`)
+        });
+      })
+    );
+    await Promise.all(tasks);
+  };
+  await walk(rootDir);
+  if (fileEntries.length > 0) {
+    logger.trace(
+      `Collected ${fileEntries.length} local message files for locale "${path.basename(rootDir)}".`
+    );
+  }
+  return fileEntries;
 }
 
 export { collectFileEntries };