intor 2.5.0 → 2.5.1

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

@@ -2,37 +2,19 @@ import { canonicalizePathname } from './canonicalize-pathname.js';
 import { materializePathname } from './materialize-pathname.js';
 import { standardizePathname } from './standardize-pathname.js';
 
-/**
- * Localizes a pathname by composing canonicalization,
- * standardization, and locale prefix strategies.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * localizePathname("/app/en-US/about", config, "en-US");
- * // => {
- * //   pathname: '/app/en-US/about'
- * //   canonicalPathname: '/about',
- * //   templatedPathname: '/app/{locale}/about',
- * // }
- * ```
- *
- * @public
- */
 const localizePathname = (rawPathname, config, locale) => {
-    // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalPathname = canonicalizePathname(rawPathname, config);
-    // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardizedPathname = standardizePathname(canonicalPathname, config);
-    // 3. Materialize: apply routing rules to produce the final pathname
-    const materializedPathname = materializePathname(standardizedPathname, config, locale);
-    return {
-        canonicalPathname,
-        templatedPathname: standardizedPathname,
-        pathname: materializedPathname,
-    };
+  const canonicalPathname = canonicalizePathname(rawPathname, config);
+  const standardizedPathname = standardizePathname(canonicalPathname, config);
+  const materializedPathname = materializePathname(
+    standardizedPathname,
+    config,
+    locale
+  );
+  return {
+    canonicalPathname,
+    templatedPathname: standardizedPathname,
+    pathname: materializedPathname
+  };
 };
 
 export { localizePathname };

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

@@ -3,51 +3,16 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Materializes a standardized pathname into a concrete, locale-aware URL.
- *
- * This function resolves the `{locale}` placeholder according to the
- * configured `localePrefix` strategy and produces the final pathname.
- *
- * Behavior:
- * - "all": always injects the locale segment
- * - "except-default": injects the locale unless it equals `defaultLocale`
- * - "none": removes the locale placeholder entirely
- *
- * Invariants:
- * - `standardizedPathname` must be produced by `standardizePathname`
- * - The pathname must contain exactly one `{locale}` placeholder
- * - The placeholder must appear as the first path segment
- *
- * This function performs structural transformation only.
- * It does not normalize or sanitize the resulting pathname.
- *
- * @example
- * ```ts
- * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en");
- * // => /app/en/about
- *
- * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en");
- * // => /app/about
- * ```
- */
 const materializePathname = (standardizedPathname, config, locale) => {
-    const { localePrefix } = config.routing;
-    const removeLocale = () => {
-        const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
-        return result === "" ? "/" : result;
-    };
-    const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
-    // localePrefix: "none"
-    if (localePrefix === "none")
-        return removeLocale();
-    // localePrefix: "all"
-    if (localePrefix === "all")
-        return injectLocale();
-    // localePrefix: "except-default"
-    return locale === config.defaultLocale ? removeLocale() : injectLocale();
+  const { localePrefix } = config.routing;
+  const removeLocale = () => {
+    const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+    return result === "" ? "/" : result;
+  };
+  const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+  if (localePrefix === "none") return removeLocale();
+  if (localePrefix === "all") return injectLocale();
+  return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };

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

@@ -3,37 +3,13 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Standardizes a canonical pathname into an internal routing template.
- *
- * Standardized representation:
- * - Prepends the deployment prefix (`basePath`) if defined
- * - Injects the `{locale}` placeholder as the first path segment
- * - Preserves the canonical pathname structure
- *
- * Input must be a canonical pathname.
- *
- * Output is an internal routing template and
- * is not a locale-resolved URL.
- *
- * @example
- * ```ts
- * // config.routing.basePath: "/app",
- * standardizePathname("/about", config);
- * // => "/app/{locale}/about"
- * ```
- */
 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}`;
+  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

@@ -4,30 +4,33 @@ 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.
- *
- * @public
- */
 async function getTranslator(config, params) {
-    const { locale, loader, readers, allowCacheWrite = false, fetch = globalThis.fetch, handlers, hooks, preKey, } = params;
-    // Initialize a locale-bound translator snapshot with messages loaded
-    const translator = await initTranslator(config, locale, {
-        ...(loader !== undefined ? { loader } : {}),
-        ...(readers !== undefined ? { readers } : {}),
-        allowCacheWrite,
-        fetch,
-        ...(handlers !== undefined ? { handlers } : {}),
-        ...(hooks !== undefined ? { hooks } : {}),
-    });
-    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

@@ -3,32 +3,27 @@ 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.
- *
- * @public
- */
 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}".`);
-    const { readers, allowCacheWrite = true, fetch = globalThis.fetch, } = options ?? {};
-    // Initialize a locale-bound translator snapshot with messages loaded
-    const translator = await initTranslator(config, locale, {
-        ...(readers !== undefined ? { readers: readers } : {}),
-        allowCacheWrite,
-        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,11 +1,8 @@
-/**
- * Get the messages pool.
- */
 function getMessagesPool() {
-    if (!globalThis.__INTOR_MESSAGES_POOL__) {
-        globalThis.__INTOR_MESSAGES_POOL__ = new Map();
-    }
-    return globalThis.__INTOR_MESSAGES_POOL__;
+  if (!globalThis.__INTOR_MESSAGES_POOL__) {
+    globalThis.__INTOR_MESSAGES_POOL__ = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__INTOR_MESSAGES_POOL__;
 }
 
 export { getMessagesPool };

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

@@ -6,101 +6,85 @@ 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?.sort().join(","),
-        namespaces?.sort().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 (const candidateLocale of candidateLocales) {
-        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
-        try {
-            const result = await readLocaleMessages({
-                locale: candidateLocale,
-                ...(namespaces !== undefined ? { namespaces } : {}),
-                rootDir,
-                limit,
-                readers: 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

@@ -4,87 +4,66 @@ 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(() => {
-            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 };