intor 2.3.2 → 2.3.4

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import merge from 'lodash.merge';
 import { isValidMessages } from '../../../shared/utils/is-valid-messages.js';
 import { getLogger } from '../../../../shared/logger/get-logger.js';
+import { deepMerge } from '../../../../../shared/utils/deep-merge.js';
 import { jsonReader } from './utils/json-reader.js';
 import { nestObjectFromPath } from './utils/nest-object-from-path.js';
 
@@ -41,7 +41,7 @@ async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesRe
     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 () => {
+    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath, relativePath }) => limit(async () => {
         try {
             const segsWithoutNs = segments.slice(1);
             const ext = path.extname(fullPath);
@@ -58,7 +58,7 @@ async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesRe
             // Nest the parsed content based on the path segments
             const nested = nestObjectFromPath(keyPath, json);
             parsedFileEntries.push({ namespace, messages: nested });
-            logger.trace("Parsed file.", { path: fullPath });
+            logger.trace(`Parsed message file: ${relativePath}`);
         }
         catch (error) {
             logger.error("Failed to read or parse file.", {
@@ -73,10 +73,13 @@ async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesRe
     for (const { namespace, messages } of parsedFileEntries) {
         // Handle root-level namespace (i.e., [rootDir]/index.json)
         if (namespace === "index") {
-            merge(result, messages);
+            const merged = deepMerge(result, messages);
+            if (merged)
+                Object.assign(result, merged);
         }
         else {
-            result[namespace] = merge(result[namespace] ?? {}, messages);
+            result[namespace] =
+                deepMerge(result[namespace] ?? {}, messages) || {};
         }
     }
     return result;

package/dist/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/types.d.ts

@@ -2,7 +2,7 @@ import type { LoggerOptions } from "../../../../../config/types/logger.types";
 import type { FileEntry } from "../../../../../server/messages/load-local-messages/read-locale-messages/types";
 import type { MessagesReader, Messages } from "../../../../../server/messages/shared/types";
 import type { LimitFunction } from "p-limit";
-export interface ParseFileEntriesOptions {
+export interface ParseFileEntriesParams {
     fileEntries: FileEntry[];
     limit: LimitFunction;
     extraOptions?: {

package/dist/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.d.ts

@@ -1,4 +1,4 @@
-import type { ReadLocaleMessagesOptions } from "./types";
+import type { ReadLocaleMessagesParams } from "../../../../server/messages/load-local-messages/read-locale-messages/types";
 import type { LocaleMessages } from "intor-translator";
 /**
  * Read messages for a specific locale from the file system.
@@ -7,4 +7,4 @@ import type { LocaleMessages } from "intor-translator";
  * 2. Parses each file into a messages object.
  * 3. Wraps the parsed messages under the locale key.
  */
-export declare const readLocaleMessages: ({ limit, rootDir, locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions }, }: ReadLocaleMessagesOptions) => Promise<LocaleMessages>;
+export declare const readLocaleMessages: ({ limit, rootDir, locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions }, }: ReadLocaleMessagesParams) => Promise<LocaleMessages>;

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

@@ -18,13 +18,13 @@ const readLocaleMessages = async ({ limit, rootDir = "messages", locale, namespa
         extraOptions: { exts, loggerOptions },
     });
     // 2. Parse file entries
-    const namespaceMessages = await parseFileEntries({
+    const messages = await parseFileEntries({
         fileEntries,
         limit,
         extraOptions: { messagesReader, loggerOptions },
     });
-    // 3. Wrap the parsed namespace messages under the locale key
-    const localeMessages = { [locale]: namespaceMessages };
+    // 3. Wrap the parsed messages under the locale key
+    const localeMessages = { [locale]: messages };
     return localeMessages;
 };
 

package/dist/src/server/messages/load-local-messages/read-locale-messages/types.d.ts

@@ -8,7 +8,7 @@ export interface FileEntry {
     segments: string[];
     basename: string;
 }
-export interface ReadLocaleMessagesOptions {
+export interface ReadLocaleMessagesParams {
     limit: LimitFunction;
     rootDir?: string;
     locale: string;

package/dist/src/server/messages/load-local-messages/types.d.ts

@@ -1,21 +1,22 @@
 import type { CacheResolvedOptions } from "../../../config/types/cache.types";
 import type { LoggerOptions } from "../../../config/types/logger.types";
-import type { MessagesPool } from "../../../server/messages/shared/global-messages-pool";
 import type { MessagesReader } from "../../../server/messages/shared/types";
-export interface LoadLocalMessagesOptions {
+import type { MessagesPool } from "../../../server/shared/messages/global-messages-pool";
+export interface LoadLocalMessagesExtraOptions {
+    concurrency?: number;
+    cacheOptions?: CacheResolvedOptions;
+    loggerOptions?: LoggerOptions & {
+        id?: string;
+    };
+    exts?: string[];
+    messagesReader?: MessagesReader;
+}
+export interface LoadLocalMessagesParams {
     pool?: MessagesPool;
     rootDir?: string;
     locale: string;
     fallbackLocales?: string[];
     namespaces?: string[];
-    extraOptions?: {
-        concurrency?: number;
-        cacheOptions?: CacheResolvedOptions;
-        loggerOptions?: LoggerOptions & {
-            id?: string;
-        };
-        exts?: string[];
-        messagesReader?: MessagesReader;
-    };
+    extraOptions?: LoadLocalMessagesExtraOptions;
     allowCacheWrite?: boolean;
 }

package/dist/src/server/messages/load-messages.d.ts

@@ -1,11 +1,14 @@
 import type { LoadMessagesOptions, LoadMessagesResult } from "../../server/messages/types";
-import type { GenConfigKeys } from "../../shared/types/generated.types";
+import type { GenConfigKeys } from "../../shared/types/generated";
 /**
- * Load messages for a given locale and pathname.
+ * Load locale messages based on the resolved Intor configuration.
  *
- * - Resolve namespaces based on config and pathname.
- * - Support both **local local** and **remote API** loaders.
- * - Apply fallback locales if needed.
- * - Cache messages if enabled (handled by underlying loader, not this function directly).
+ * This function acts as a thin orchestration layer that:
+ *
+ * - Selects the appropriate message loader (local or remote)
+ * - Applies fallback locale resolution
+ * - Delegates caching and concurrency behavior to the underlying loader
+ *
+ * It does not perform message normalization or transformation itself.
  */
-export declare const loadMessages: <C extends GenConfigKeys = "__default__">({ config, locale, pathname, extraOptions: { exts, messagesReader }, allowCacheWrite, }: LoadMessagesOptions) => LoadMessagesResult<C>;
+export declare const loadMessages: <CK extends GenConfigKeys = "__default__">({ config, locale, extraOptions: { exts, messagesReader }, allowCacheWrite, }: LoadMessagesOptions) => LoadMessagesResult<CK>;

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

@@ -1,30 +1,29 @@
 import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
 import { loadRemoteMessages } from './load-remote-messages/load-remote-messages.js';
 import { getLogger } from '../shared/logger/get-logger.js';
-import { resolveNamespaces } from '../../shared/utils/resolve-namespaces.js';
 
 /**
- * Load messages for a given locale and pathname.
+ * Load locale messages based on the resolved Intor configuration.
  *
- * - Resolve namespaces based on config and pathname.
- * - Support both **local local** and **remote API** loaders.
- * - Apply fallback locales if needed.
- * - Cache messages if enabled (handled by underlying loader, not this function directly).
+ * This function acts as a thin orchestration layer that:
+ *
+ * - Selects the appropriate message loader (local or remote)
+ * - Applies fallback locale resolution
+ * - Delegates caching and concurrency behavior to the underlying loader
+ *
+ * It does not perform message normalization or transformation itself.
  */
-const loadMessages = async ({ config, locale, pathname = "", extraOptions: { exts, messagesReader } = {}, allowCacheWrite = false, }) => {
+const loadMessages = async ({ config, locale, extraOptions: { exts, messagesReader } = {}, allowCacheWrite = false, }) => {
     const baseLogger = getLogger({ id: config.id, ...config.logger });
     const logger = baseLogger.child({ scope: "load-messages" });
+    // Guard: no loader configured
     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] || []; // fallback locales fro the pass-in target locale
-    const namespaces = resolveNamespaces({ config, pathname }); // Resolve namespaces with pathname
-    // Logs
-    if (logger.core.level === "debug") {
-        logger.debug("Starting to load messages.", { locale });
-    }
+    const { type, concurrency, rootDir, namespaces } = config.loader;
+    const fallbackLocales = config.fallbackLocales[locale] || [];
+    logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
         loaderType: type,
         locale,
@@ -34,13 +33,13 @@ const loadMessages = async ({ config, locale, pathname = "", extraOptions: { ext
         concurrency: concurrency ?? 10,
     });
     let loadedMessages;
-    //====== loader type: local ======
+    // --- loader type: local
     if (type === "local") {
         loadedMessages = await loadLocalMessages({
-            rootDir,
             locale,
             fallbackLocales,
             namespaces,
+            rootDir,
             extraOptions: {
                 concurrency,
                 cacheOptions: config.cache,
@@ -51,25 +50,26 @@ const loadMessages = async ({ config, locale, pathname = "", extraOptions: { ext
             allowCacheWrite,
         });
     }
-    //====== loader type: remote ======
+    // --- loader type: remote
     else if (type === "remote") {
         // Fetch messages from remote
         loadedMessages = await loadRemoteMessages({
-            rootDir,
-            remoteUrl: config.loader.remoteUrl,
-            remoteHeaders: config.loader.remoteHeaders,
             locale,
             fallbackLocales,
             namespaces,
+            rootDir,
+            remoteUrl: config.loader.remoteUrl,
+            remoteHeaders: config.loader.remoteHeaders,
             extraOptions: {
                 cacheOptions: config.cache,
                 loggerOptions: { id: config.id, ...config.logger },
             },
+            allowCacheWrite,
         });
     }
     // No messages found
     if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
-        logger.warn("No messages found.", { locale, namespaces });
+        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
     }
     return loadedMessages;
 };

package/dist/src/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.d.ts

@@ -6,4 +6,4 @@ import type { LocaleMessages } from "intor-translator";
  * - Validates that the returned JSON matches the expected `NamespaceMessages` structure.
  * - Uses `fetch` with `no-store` cache to always get fresh data.
  */
-export declare const fetchLocaleMessages: ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions }, }: FetcherOptions) => Promise<LocaleMessages | undefined>;
+export declare const fetchLocaleMessages: ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions }, signal, }: FetcherOptions) => Promise<LocaleMessages | undefined>;

package/dist/src/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.js

@@ -7,7 +7,7 @@ import { getLogger } from '../../../shared/logger/get-logger.js';
  * - Validates that the returned JSON matches the expected `NamespaceMessages` structure.
  * - Uses `fetch` with `no-store` cache to always get fresh data.
  */
-const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions } = {}, }) => {
+const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions } = {}, signal, }) => {
     const baseLogger = getLogger({ ...loggerOptions });
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
     try {
@@ -24,6 +24,7 @@ const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, loc
             method: "GET",
             headers,
             cache: "no-store",
+            signal,
         });
         if (!response.ok) {
             throw new Error(`HTTP error ${response.status} ${response.statusText}`);
@@ -37,6 +38,10 @@ const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, loc
         return data;
     }
     catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Fetching locale messages aborted.", { locale, remoteUrl });
+            return;
+        }
         logger.warn("Fetching locale messages failed.", {
             locale,
             remoteUrl,

package/dist/src/server/messages/load-remote-messages/fetch-locale-messages/types.d.ts

@@ -10,4 +10,5 @@ export interface FetcherOptions {
             id?: string;
         };
     };
+    signal?: AbortSignal;
 }

package/dist/src/server/messages/load-remote-messages/index.d.ts

@@ -1,2 +1,2 @@
 export { loadRemoteMessages } from "./load-remote-messages";
-export type { LoadRemoteMessagesOptions } from "./types";
+export type { LoadRemoteMessagesParams as LoadRemoteMessagesOptions } from "./types";

package/dist/src/server/messages/load-remote-messages/load-remote-messages.d.ts

@@ -1,9 +1,15 @@
-import type { LoadRemoteMessagesOptions } from "./types";
+import type { LoadRemoteMessagesParams } from "./types";
 import type { LocaleMessages } from "intor-translator";
 /**
  * Load locale messages from a remote API.
  *
- * - Fetch messages for a target locale with optional fallback locales.
- * - Cache messages if enabled.
+ * This function acts as the orchestration layer for remote message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Respecting abort signals across the entire async flow
+ *
+ * Network fetching and data validation are delegated to lower-level utilities.
  */
-export declare const loadRemoteMessages: ({ pool, rootDir, remoteUrl, remoteHeaders, locale, fallbackLocales, namespaces, extraOptions: { cacheOptions, loggerOptions, }, allowCacheWrite, }: LoadRemoteMessagesOptions) => Promise<LocaleMessages | undefined>;
+export declare const loadRemoteMessages: ({ pool, rootDir, locale, fallbackLocales, namespaces, remoteUrl, remoteHeaders, extraOptions: { cacheOptions, loggerOptions, }, allowCacheWrite, signal, }: LoadRemoteMessagesParams) => Promise<LocaleMessages | undefined>;

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

@@ -1,25 +1,34 @@
 import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
 import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
 import { buildSearchParams } from './fetch-locale-messages/utils/build-search-params.js';
-import { getGlobalMessagesPool } from '../shared/global-messages-pool.js';
 import { getLogger } from '../../shared/logger/get-logger.js';
-import 'lodash.merge';
-import { normalizeCacheKey } from '../../../shared/utils/normalize-cache-key.js';
+import { getGlobalMessagesPool } from '../../shared/messages/global-messages-pool.js';
+import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-cache-key.js';
 
 /**
  * Load locale messages from a remote API.
  *
- * - Fetch messages for a target locale with optional fallback locales.
- * - Cache messages if enabled.
+ * This function acts as the orchestration layer for remote message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Respecting abort signals across the entire async flow
+ *
+ * Network fetching and data validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, remoteUrl, remoteHeaders, locale, fallbackLocales = [], namespaces = [], extraOptions: { cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, } = {}, allowCacheWrite, }) => {
+const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, locale, fallbackLocales, namespaces, remoteUrl, remoteHeaders, extraOptions: { cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, } = {}, allowCacheWrite = false, signal, }) => {
     const baseLogger = getLogger({ ...loggerOptions });
     const logger = baseLogger.child({ scope: "load-remote-messages" });
-    // Start performance measurement
+    // Abort early if the request has already been cancelled
+    if (signal?.aborted) {
+        logger.debug("Remote message loading aborted before fetch.");
+        return;
+    }
     const start = performance.now();
-    logger.debug("Loading remote messages from api.", { remoteUrl });
-    //====== Cache lookup ======
-    const key = normalizeCacheKey([
+    logger.debug("Loading remote messages.", { remoteUrl });
+    // --- Cache key
+    const cacheKey = normalizeCacheKey([
         loggerOptions.id,
         "loaderType:remote",
         rootDir,
@@ -27,52 +36,74 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, rem
         (fallbackLocales ?? []).toSorted().join(","),
         (namespaces ?? []).toSorted().join(","),
     ]);
-    if (cacheOptions.enabled && key) {
-        const cached = await pool?.get(key);
+    // --- Cache read --------------------------------------------------
+    if (cacheOptions.enabled && cacheKey) {
+        const cached = await pool?.get(cacheKey);
+        if (signal?.aborted) {
+            logger.debug("Remote message loading aborted after cache read.");
+            return;
+        }
         if (cached) {
-            logger.debug("Messages cache hit.", { key });
+            logger.debug("Messages cache hit.", { key: cacheKey });
             return cached;
         }
     }
-    // Build search params
-    const searchParams = buildSearchParams({ rootDir, namespaces });
-    //============================================================
-    // Fetch messages
-    //============================================================
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
-    for (const candidateLocale of candidateLocales) {
+    // Try each candidate locale in order and stop at the first successful result
+    for (let i = 0; i < candidateLocales.length; i++) {
+        const candidateLocale = candidateLocales[i];
+        const isLast = i === candidateLocales.length - 1;
         try {
-            const result = await fetchLocaleMessages({
+            const fetched = await fetchLocaleMessages({
                 remoteUrl,
                 remoteHeaders,
-                searchParams,
                 locale: candidateLocale,
+                searchParams: buildSearchParams({ rootDir, namespaces }),
                 extraOptions: { loggerOptions },
+                signal,
             });
-            if (result && Object.values(result[candidateLocale] || {}).length > 0) {
-                messages = result;
+            // Stop at the first locale that yields non-empty messages
+            if (fetched && Object.values(fetched[candidateLocale] || {}).length > 0) {
+                messages = fetched;
                 break;
             }
         }
         catch (error) {
-            logger.error("Failed to fetch locale messages.", {
+            if (error instanceof Error && error.name === "AbortError") {
+                logger.debug("Remote message loading aborted.");
+                return;
+            }
+            if (isLast) {
+                logger.warn("Failed to load messages for all candidate locales.", {
+                    locale,
+                    fallbackLocales,
+                });
+            }
+            else {
+                logger.warn(`Failed to fetch locale messages for "${candidateLocale}", trying next fallback.`);
+            }
+            logger.trace("Remote fetch error detail.", {
                 locale: candidateLocale,
                 error,
             });
         }
     }
-    //====== Cache ======
-    if (allowCacheWrite && cacheOptions.enabled && key && messages) {
-        await pool?.set(key, messages, cacheOptions.ttl);
+    // --- Cache write --------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
+        if (signal?.aborted) {
+            logger.debug("Remote message loading aborted before cache write.");
+            return;
+        }
+        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+    }
+    // Final success log with resolved locale and timing
+    if (messages) {
+        logger.trace("Finished loading remote messages.", {
+            loadedLocale: messages ? Object.keys(messages)[0] : undefined,
+            duration: `${Math.round(performance.now() - start)} ms`,
+        });
     }
-    // Log out validnamespaces & performance measurement
-    const end = performance.now();
-    const duration = Math.round(end - start);
-    logger.trace("Finished loading remote messages.", {
-        loadedLocale: messages ? Object.keys(messages)[0] : undefined,
-        duration: `${duration} ms`,
-    });
     return messages;
 };
 

package/dist/src/server/messages/load-remote-messages/types.d.ts

@@ -1,12 +1,12 @@
 import type { CacheResolvedOptions } from "../../../config/types/cache.types";
 import type { RemoteHeaders } from "../../../config/types/loader.types";
 import type { LoggerOptions } from "../../../config/types/logger.types";
-import type { MessagesPool } from "../../../server/messages/shared/global-messages-pool";
-export interface LoadRemoteMessagesOptions {
+import type { MessagesPool } from "../../../server/shared/messages/global-messages-pool";
+export interface LoadRemoteMessagesParams {
     pool?: MessagesPool;
     rootDir?: string;
     locale: string;
-    fallbackLocales: string[];
+    fallbackLocales?: string[];
     namespaces?: string[];
     remoteUrl: string;
     remoteHeaders?: RemoteHeaders;
@@ -17,4 +17,5 @@ export interface LoadRemoteMessagesOptions {
         };
     };
     allowCacheWrite?: boolean;
+    signal?: AbortSignal;
 }

package/dist/src/server/messages/types.d.ts

@@ -1,15 +1,14 @@
 import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
 import type { MessagesReader } from "../../server/messages/shared/types";
-import type { GenConfigKeys, GenMessages } from "../../shared/types/generated.types";
+import type { GenConfigKeys, GenMessages } from "../../shared/types/generated";
 import type { Locale } from "intor-translator";
 export type LoadMessagesOptions = {
     config: IntorResolvedConfig;
     locale: Locale;
-    pathname?: string;
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;
     };
     allowCacheWrite?: boolean;
 };
-export type LoadMessagesResult<C extends GenConfigKeys = "__default__"> = Promise<GenMessages<C> | undefined>;
+export type LoadMessagesResult<CK extends GenConfigKeys = "__default__"> = Promise<GenMessages<CK> | undefined>;

package/dist/src/server/shared/logger/get-logger.d.ts

@@ -5,7 +5,7 @@ import type { Logger } from "logry";
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-export declare function getLogger({ id, formatterConfig, preset, ...options }: {
+export declare function getLogger({ id, formatConfig, renderConfig, preset, ...options }: {
     id?: string;
     scope?: string;
 } & LoggerOptions): Logger;

package/dist/src/server/shared/logger/get-logger.js

@@ -1,22 +1,27 @@
 import { logry } from 'logry';
 import { getGlobalLoggerPool } from './global-logger-pool.js';
 
-const DEFAULT_FORMATTER_CONFIG = {
-    node: { meta: { compact: true }, lineBreaksAfter: 1 },
+const DEFAULT_FORMAT_CONFIG = {
+    timestamp: { withDate: false },
+};
+const DEFAULT_RENDER_CONFIG = {
+    timestamp: {},
+    id: { visible: true, prefix: "<", suffix: ">" },
+    meta: { lineBreaksAfter: 1 },
 };
 /**
  * Get a shared logger instance by id.
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-function getLogger({ id = "default", formatterConfig, preset, ...options }) {
+function getLogger({ id = "default", formatConfig, renderConfig, 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,
+            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
+            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
             preset,
             ...options,
         });

package/dist/src/server/translator/get-translator.d.ts

@@ -1,20 +1,20 @@
 import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
-import type { GenConfigKeys, GenLocale, GenMessages } from "../../shared/types/generated.types";
-import type { TranslatorInstance } from "../../shared/types/translator-instance.types";
-import type { LocalizedNodeKeys, TranslateHandlers } from "intor-translator";
+import type { GenConfigKeys, GenLocale, GenMessages } from "../../shared/types/generated";
+import type { TranslatorInstance } from "../../shared/types/translator-instance";
+import type { LocalizedNodeKeys, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 import { type MessagesReader } from "../../server/messages";
 /**
- * Create a translator instance for a specific locale and pathname
+ * Create a translator instance for a specific locale.
  *
- * - Loads messages using the provided config, locale, and pathname.
+ * - Loads messages using the provided config, locale.
  * - Initializes a translator with `t`, `hasKey`, and optional scoped methods.
  * - Supports optional `preKey` to create a scoped translator for nested keys.
  */
 export declare function getTranslator<CK extends GenConfigKeys = "__default__">(options: {
     config: IntorResolvedConfig;
-    locale: GenLocale;
-    pathname?: string;
+    locale: GenLocale<CK>;
     handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;
@@ -22,9 +22,9 @@ export declare function getTranslator<CK extends GenConfigKeys = "__default__">(
 }): Promise<TranslatorInstance<GenMessages<CK>>>;
 export declare function getTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(options: {
     config: IntorResolvedConfig;
-    locale: GenLocale;
-    pathname?: string;
+    locale: GenLocale<CK>;
     handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;

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

@@ -1,21 +1,12 @@
 import { Translator } from 'intor-translator';
 import { loadMessages } from '../messages/load-messages.js';
-import 'node:path';
-import 'node:perf_hooks';
-import 'p-limit';
-import '../../config/constants/cache.constants.js';
-import 'node:fs/promises';
-import 'logry';
-import 'lodash.merge';
-import 'keyv';
 
 // Implementation
 async function getTranslator(options) {
-    const { config, locale, pathname = "", preKey } = options;
+    const { config, locale, preKey } = options;
     const messages = await loadMessages({
         config,
         locale,
-        pathname,
         extraOptions: options.extraOptions,
     });
     // Create a Translator instance
@@ -26,6 +17,7 @@ async function getTranslator(options) {
         loadingMessage: config.translator?.loadingMessage,
         placeholder: config.translator?.placeholder,
         handlers: options.handlers,
+        plugins: options.plugins,
     });
     const props = { messages, locale };
     const scoped = translator.scoped(preKey);
@@ -33,6 +25,10 @@ async function getTranslator(options) {
         ...props,
         hasKey: preKey ? scoped.hasKey : translator.hasKey,
         t: preKey ? scoped.t : translator.t,
+        // NOTE:
+        // Return type is fully validated by overload signatures.
+        // Assertion here is intentional due to TS inference limitations.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }
 

package/dist/src/shared/constants/index.d.ts

@@ -0,0 +1 @@
+export { PREFIX_PLACEHOLDER } from "./prefix-placeholder";