intor 2.4.16 → 2.5.0

package/dist/core/export/edge/index.js

@@ -1,6 +1 @@
 export { getTranslator } from '../../src/edge/helpers/get-translator.js';
-import '../../src/core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-export { resolveInboundFromRequest } from '../../src/routing/inbound/helpers/resolve-inbound-from-request.js';

package/dist/core/export/index.js

@@ -1,11 +1,11 @@
-export { LOCALE_PLACEHOLDER } from '../src/core/constants/locale-placeholder.js';
-export { IntorError, IntorErrorCode } from '../src/core/error/intor-error.js';
+export { INTOR_ERROR_CODE, IntorError } from '../src/core/error/intor-error.js';
 export { matchLocale } from '../src/core/locale/match-locale.js';
 import 'logry';
-export { clearLoggerPool } from '../src/core/logger/global-logger-pool.js';
 import 'p-limit';
 export { mergeMessages } from '../src/core/messages/merge-messages.js';
-export { Translator } from 'intor-translator';
+import 'intor-translator';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';
 import '../src/config/constants/cookie.js';
 export { localizePathname } from '../src/routing/pathname/localize-pathname.js';
+export { resolveInboundFromRequest } from '../src/routing/inbound/helpers/resolve-inbound-from-request.js';
+export { getClientLocale } from '../src/client/shared/helpers/get-client-locale.js';

package/dist/core/export/internal/index.js

@@ -1,8 +1,7 @@
-import '../../src/core/error/intor-error.js';
 export { resolveLoaderOptions } from '../../src/core/utils/resolve-loader-options.js';
 import 'logry';
 import 'p-limit';
-export { INTOR_MESSAGES_KIND, INTOR_MESSAGES_KIND_KEY, INTOR_PREFIX, getMessagesKind } from '../../src/core/messages/internal-metadata.js';
+export { INTOR_MESSAGES_KIND, INTOR_MESSAGES_KIND_KEY, INTOR_PREFIX } from '../../src/core/messages/internal-metadata.js';
 import 'intor-translator';
 export { loadMessages } from '../../src/server/messages/load-messages.js';
 import 'node:path';

package/dist/core/export/server/index.js

@@ -1,9 +1,7 @@
 export { intor } from '../../src/server/intor/intor.js';
-import '../../src/core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import 'node:path';
-export { clearMessagesPool } from '../../src/server/messages/load-local-messages/cache/messages-pool.js';
 import 'node:fs/promises';
 export { getTranslator } from '../../src/server/helpers/get-translator.js';

package/dist/{react → core}/src/client/shared/helpers/get-client-locale.js

@@ -1,4 +1,3 @@
-import '../../../core/error/intor-error.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
@@ -7,7 +6,17 @@ import { detectBrowserLocale } from '../utils/locale/detect-browser-locale.js';
 import { getLocaleFromCookie } from '../utils/locale/get-locale-from-cookie.js';
 
 /**
- * Resolve the active locale in a pure client-side environment.
+ * Resolve the active locale in a browser-only environment.
+ *
+ * This helper is intended for pure client-side setups where
+ * no server-side locale resolution is involved.
+ *
+ * Resolution order:
+ * 1. Locale from cookie
+ * 2. Locale from browser preference
+ * 3. Fallback to `defaultLocale`
+ *
+ * @public
  */
 function getClientLocale(config) {
     const { defaultLocale, supportedLocales, cookie } = config;

package/dist/core/src/client/shared/utils/locale/get-locale-from-cookie.js

@@ -0,0 +1,16 @@
+/**
+ * Gets the locale value from the browser cookie.
+ *
+ * This function relies on `document.cookie`.
+ */
+function getLocaleFromCookie(cookieName) {
+    if (typeof document === "undefined")
+        return undefined;
+    const cookies = document.cookie.split(";").map((c) => c.trim());
+    const entry = cookies.find((c) => c.startsWith(`${cookieName}=`));
+    if (!entry)
+        return undefined;
+    return decodeURIComponent(entry.slice(cookieName.length + 1));
+}
+
+export { getLocaleFromCookie };

package/dist/core/src/config/constants/cookie.js

@@ -6,7 +6,7 @@ const DEFAULT_COOKIE_OPTIONS = {
     path: "/",
     maxAge: 60 * 60 * 24 * 365, // 365 days
     httpOnly: false,
-    secure: process.env.NODE_ENV !== "development",
+    secure: process.env["NODE_ENV"] !== "development",
     sameSite: "lax",
 };
 

package/dist/core/src/config/constants/routing.js

@@ -10,7 +10,7 @@ const DEFAULT_ROUTING_OPTIONS = {
     outbound: {
         localeCarrier: "path",
         queryKey: "locale",
-        host: { map: {}, default: undefined },
+        host: { map: {} },
         forceFullReload: false,
     },
 };

package/dist/core/src/config/define-intor-config.js

@@ -8,12 +8,17 @@ import { validateSupportedLocales } from './validators/validate-supported-locale
 /**
  * Defines the canonical Intor configuration.
  *
- * Transforms a raw config into a validated and runtime-ready form by:
+ * This is the primary entry point for creating a validated,
+ * runtime-ready Intor configuration.
+ *
+ * It transforms a user-provided raw config into a normalized form by:
  * - enforcing required invariants
  * - resolving derived options
  * - applying stable defaults
  *
- * This function is declarative and side-effect free.
+ * This function is pure and side-effect free.
+ *
+ * @public
  */
 const defineIntorConfig = (config) => {
     // -----------------------------------------------------------------------------
@@ -31,17 +36,19 @@ const defineIntorConfig = (config) => {
     const routing = resolveRoutingOptions(config.routing);
     return {
         id,
-        messages: config.messages,
-        loader: config.loader,
+        ...(config.messages !== undefined ? { messages: config.messages } : {}),
+        ...(config.loader !== undefined ? { loader: config.loader } : {}),
         defaultLocale,
         supportedLocales,
         fallbackLocales,
-        translator: config.translator,
+        ...(config.translator !== undefined
+            ? { translator: config.translator }
+            : {}),
         cookie,
         routing,
         logger: { id, ...config.logger },
-        client: config.client,
-        server: config.server,
+        ...(config.client !== undefined ? { client: config.client } : {}),
+        ...(config.server !== undefined ? { server: config.server } : {}),
     };
 };
 

package/dist/core/src/config/resolvers/resolve-fallback-locales.js

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import { getLogger } from '../../core/logger/get-logger.js';
 import 'p-limit';
 import 'intor-translator';

package/dist/core/src/config/resolvers/resolve-routing-options.js

@@ -1,5 +1,5 @@
-import '../../core/error/intor-error.js';
 import { deepMerge } from '../../core/utils/deep-merge.js';
+import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -14,12 +14,28 @@ import '../constants/cookie.js';
  * - Defaults are applied last.
  */
 function resolveRoutingOptions(raw) {
-    if (!raw)
-        return DEFAULT_ROUTING_OPTIONS;
+    if (!raw) {
+        return enforceRoutingInvariants(DEFAULT_ROUTING_OPTIONS);
+    }
     const projectedFromFlat = projectFlatToStructured(raw);
     const structuredOverrides = stripFlatShortcuts(raw);
     const defined = deepMerge(projectedFromFlat, structuredOverrides);
-    return deepMerge(DEFAULT_ROUTING_OPTIONS, defined);
+    const merged = deepMerge(DEFAULT_ROUTING_OPTIONS, defined);
+    return enforceRoutingInvariants(merged);
+}
+/**
+ * Enforces runtime invariants for routing configuration.
+ *
+ * Invariants:
+ * - basePath is normalized
+ * - basePath always starts with "/"
+ * - root basePath is represented as "/"
+ */
+function enforceRoutingInvariants(routing) {
+    const normalizedBase = routing.basePath && routing.basePath !== "/"
+        ? normalizePathname(routing.basePath)
+        : "/";
+    return { ...routing, basePath: normalizedBase };
 }
 /** Assigns a value to the target only if it is explicitly defined. */
 function assignIfDefined(target, key, value) {

package/dist/core/src/config/validators/validate-default-locale.js

@@ -1,4 +1,4 @@
-import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import { IntorError, INTOR_ERROR_CODE } from '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -12,7 +12,7 @@ const validateDefaultLocale = (id, defaultLocale, supportedSet) => {
     if (!supportedSet.has(defaultLocale)) {
         throw new IntorError({
             id,
-            code: IntorErrorCode.UNSUPPORTED_DEFAULT_LOCALE,
+            code: INTOR_ERROR_CODE.CONFIG_UNSUPPORTED_DEFAULT_LOCALE,
             message: `"defaultLocale" must be included in "supportedLocales".`,
         });
     }

package/dist/core/src/config/validators/validate-id.js

@@ -1,4 +1,4 @@
-import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import { IntorError, INTOR_ERROR_CODE } from '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -12,7 +12,7 @@ const validateId = (id) => {
     if (id.trim() === "") {
         throw new IntorError({
             id,
-            code: IntorErrorCode.INVALID_CONFIG_ID,
+            code: INTOR_ERROR_CODE.CONFIG_INVALID_ID,
             message: `"id" must be a non-empty string.`,
         });
     }

package/dist/core/src/config/validators/validate-supported-locales.js

@@ -1,4 +1,4 @@
-import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import { IntorError, INTOR_ERROR_CODE } from '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -12,7 +12,7 @@ const validateSupportedLocales = (id, supportedLocales) => {
     if (!supportedLocales || supportedLocales.length === 0) {
         throw new IntorError({
             id,
-            code: IntorErrorCode.MISSING_SUPPORTED_LOCALES,
+            code: INTOR_ERROR_CODE.CONFIG_MISSING_SUPPORTED_LOCALES,
             message: `"supportedLocales" must be specified.`,
         });
     }

package/dist/core/src/core/error/intor-error.js

@@ -1,3 +1,10 @@
+/**
+ * Framework-level error used by Intor.
+ *
+ * Extends the native Error with optional structured metadata.
+ *
+ * @public
+ */
 class IntorError extends Error {
     code;
     id;
@@ -5,17 +12,24 @@ class IntorError extends Error {
         const fullMessage = id ? `[${id}] ${message}` : message;
         super(fullMessage);
         this.name = "IntorError";
-        this.id = id;
-        this.code = code;
+        if (id)
+            this.id = id;
+        if (code)
+            this.code = code;
         Object.setPrototypeOf(this, new.target.prototype); // Fix prototype
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(this, IntorError);
     }
 }
-var IntorErrorCode;
-(function (IntorErrorCode) {
-    // config
-    IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
-    IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
-    IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
-})(IntorErrorCode || (IntorErrorCode = {}));
+/**
+ * Built-in error codes used by Intor.
+ *
+ * @public
+ */
+const INTOR_ERROR_CODE = {
+    CONFIG_INVALID_ID: "INTOR_CONFIG_INVALID_ID",
+    CONFIG_MISSING_SUPPORTED_LOCALES: "INTOR_CONFIG_MISSING_SUPPORTED_LOCALES",
+    CONFIG_UNSUPPORTED_DEFAULT_LOCALE: "INTOR_CONFIG_UNSUPPORTED_DEFAULT_LOCALE",
+};
 
-export { IntorError, IntorErrorCode };
+export { INTOR_ERROR_CODE, IntorError };

package/dist/core/src/core/locale/match-locale.js

@@ -9,12 +9,16 @@ import { parseLocale } from './parse-locale.js';
  * 2. Same language + same script
  * 3. Same language only (only if candidate has no script)
  *
+ * Returns one of the original `supportedLocales` values if matched.
  * Returns `undefined` if no match is found.
  *
  * Notes:
  * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to default locale.
- * - Does not cross script boundaries.
+ * - Does not perform automatic fallback to a default locale.
+ *   Consumers are responsible for applying fallback logic.
+ * - If the candidate includes a script subtag, language-only fallback is skipped.
+ *
+ * @public
  */
 function matchLocale(locale, supportedLocales = []) {
     if (!locale || supportedLocales.length === 0)

package/dist/core/src/core/locale/parse-locale.js

@@ -12,8 +12,8 @@ function parseLocale(tag) {
             const locale = new Intl.Locale(tag);
             return {
                 language: locale.language,
-                script: locale.script,
-                region: locale.region,
+                ...(locale.script !== undefined ? { script: locale.script } : {}),
+                ...(locale.region !== undefined ? { region: locale.region } : {}),
             };
         }
     }

package/dist/core/src/core/logger/get-logger.js

@@ -5,7 +5,6 @@ const DEFAULT_FORMAT_CONFIG = {
     timestamp: { withDate: false },
 };
 const DEFAULT_RENDER_CONFIG = {
-    timestamp: {},
     id: { visible: true, prefix: "<", suffix: ">" },
     meta: { lineBreaksAfter: 1 },
 };
@@ -14,23 +13,27 @@ const DEFAULT_RENDER_CONFIG = {
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
+function getLogger({ id = "default", preset, ...options }) {
     const pool = getGlobalLoggerPool();
-    let logger = pool.get(id);
-    if (!logger) {
-        logger = logry({
-            id,
-            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
-            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
-            preset,
-            ...options,
-        });
-        pool.set(id, logger);
-        // Soft LRU: keep pool size under control
-        if (pool.size > 1000) {
-            const keys = [...pool.keys()];
-            for (const key of keys.slice(0, 200))
-                pool.delete(key);
+    const existing = pool.get(id);
+    if (existing)
+        return existing;
+    const baseConfig = preset === undefined
+        ? {
+            formatConfig: DEFAULT_FORMAT_CONFIG,
+            renderConfig: DEFAULT_RENDER_CONFIG,
+        }
+        : { preset };
+    const logger = logry({
+        id,
+        ...baseConfig,
+        ...options,
+    });
+    pool.set(id, logger);
+    // Soft LRU: keep pool size under control
+    if (pool.size > 1000) {
+        for (const key of [...pool.keys()].slice(0, 200)) {
+            pool.delete(key);
         }
     }
     return logger;

package/dist/core/src/core/logger/global-logger-pool.js

@@ -4,13 +4,5 @@ function getGlobalLoggerPool() {
     }
     return globalThis.__INTOR_LOGGER_POOL__;
 }
-/**
- * Optional: clear all cache
- * Useful in tests or dynamic reloads.
- */
-function clearLoggerPool() {
-    const pool = getGlobalLoggerPool();
-    pool.clear();
-}
 
-export { clearLoggerPool, getGlobalLoggerPool };
+export { getGlobalLoggerPool };

package/dist/core/src/core/messages/internal-metadata.js

@@ -3,14 +3,5 @@ const INTOR_MESSAGES_KIND_KEY = `${INTOR_PREFIX}kind`;
 const INTOR_MESSAGES_KIND = {
     markdown: "markdown",
 };
-/**
- * Read the Intor internal kind from a message container.
- */
-function getMessagesKind(value) {
-    if (!value || typeof value !== "object")
-        return;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return value[INTOR_MESSAGES_KIND_KEY];
-}
 
-export { INTOR_MESSAGES_KIND, INTOR_MESSAGES_KIND_KEY, INTOR_PREFIX, getMessagesKind };
+export { INTOR_MESSAGES_KIND, INTOR_MESSAGES_KIND_KEY, INTOR_PREFIX };

package/dist/core/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -21,13 +21,13 @@ async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions,
             method: "GET",
             headers: { "Content-Type": "application/json", ...headers },
             cache: "no-store",
-            signal,
+            ...(signal !== undefined ? { signal } : {}),
         });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status} ${response.statusText}`);
         }
         // Parse JSON body
-        const data = await response.json();
+        const data = (await response.json());
         // Validate messages structure
         if (!isValidMessages(data)) {
             throw new Error("Invalid messages structure");

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

@@ -34,9 +34,8 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
     const limit = concurrency ? pLimit(concurrency) : undefined;
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
-    for (let i = 0; i < candidateLocales.length; i++) {
-        const candidateLocale = candidateLocales[i];
-        const isLast = i === candidateLocales.length - 1;
+    for (const candidateLocale of candidateLocales) {
+        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
         try {
             // -----------------------------------------------------------------
             // Collect remote message resources for the locale
@@ -44,12 +43,18 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             const resources = collectRemoteResources({
                 locale: candidateLocale,
                 baseUrl,
-                namespaces,
+                ...(namespaces !== undefined ? { namespaces } : {}),
             });
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
+            const fetchUrl = (url) => fetchRemoteResource({
+                url,
+                ...(headers !== undefined ? { headers } : {}),
+                ...(signal !== undefined ? { signal } : {}),
+                loggerOptions,
+                fetch,
+            });
             const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
             // Guard: no valid remote resources
             if (!results.some(Boolean))
@@ -57,7 +62,10 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Resolve and merge remote message resources
             // -----------------------------------------------------------------
-            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            const resolved = resolveRemoteResources(resources.map((res, i) => {
+                const data = results[i];
+                return { path: res.path, ...(data !== undefined ? { data } : {}) };
+            }));
             // -----------------------------------------------------------------
             // Wrap resolved messages into locale-scoped LocaleMessages
             // -----------------------------------------------------------------

package/dist/core/src/core/messages/merge-messages.js

@@ -6,6 +6,8 @@ import { deepMerge } from '../utils/deep-merge.js';
  *
  * - Only merges messages under the given locale
  * - Emits debug logs for add / override events
+ *
+ * @public
  */
 function mergeMessages(a, b, { config, locale, onEvent }) {
     const baseLogger = getLogger({ ...config.logger, id: config.id });

package/dist/core/src/core/translator/create-translator.js

@@ -6,23 +6,24 @@ import { mergeMessages } from '../messages/merge-messages.js';
  *
  * - Merges static config messages with runtime-loaded messages
  * - Initializes a Translator bound to a specific locale
- * - Injects fallback rules, handlers, and plugins from config
+ * - Injects fallback rules, handlers, and hooks from config
  */
 function createTranslator(params) {
-    const { config, locale, messages, handlers, plugins } = params;
+    const { config, locale, messages, handlers, hooks } = params;
     // Merge static config messages with runtime-loaded messages
     const finalMessages = mergeMessages(config.messages, messages, {
         config,
         locale,
     });
+    const { loadingMessage, missingMessage } = config.translator ?? {};
     const translator = new Translator({
         locale,
         messages: finalMessages,
         fallbackLocales: config.fallbackLocales,
-        loadingMessage: config.translator?.loadingMessage,
-        missingMessage: config.translator?.missingMessage,
-        handlers,
-        plugins,
+        ...(loadingMessage !== undefined ? { loadingMessage } : {}),
+        ...(missingMessage !== undefined ? { missingMessage } : {}),
+        ...(handlers !== undefined ? { handlers } : {}),
+        ...(hooks !== undefined ? { hooks } : {}),
     });
     return translator;
 }

package/dist/core/src/core/utils/normalizers/normalize-pathname.js

@@ -1,21 +1,24 @@
 /**
- * Normalize a raw pathname string to ensure consistent formatting.
+ * Normalizes a raw pathname string into a consistent structural form.
  *
- * - Trims leading and trailing whitespace (code points ≤ 32).
- * - Collapses consecutive slashes into a single slash.
- * - Ensures a single leading slash and removes redundant trailing slashes.
- * - Optionally removes the leading slash.
- * - Avoids intermediate array allocations for performance.
+ * Canonical guarantees:
+ * - Leading and trailing whitespace (code points ≤ 32) are trimmed
+ * - Consecutive slashes are collapsed into a single slash
+ * - The result always starts with a single "/"
+ * - Redundant trailing slashes are removed
+ * - The root path is represented as "/"
+ *
+ * This function is deterministic and allocation-minimized.
  */
-const normalizePathname = (rawPathname, options = {}) => {
+const normalizePathname = (rawPathname) => {
     const length = rawPathname.length;
     let start = 0;
     let end = length - 1;
     // Trim leading whitespace
-    while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32)
+    while (start <= end && rawPathname.codePointAt(start) <= 32)
         start++;
     // Trim trailing whitespace
-    while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32)
+    while (end >= start && rawPathname.codePointAt(end) <= 32)
         end--;
     if (start > end)
         return "/"; // Only whitespace
@@ -33,10 +36,6 @@ const normalizePathname = (rawPathname, options = {}) => {
             hasSlash = false;
         }
     }
-    // If the result has a leading slash and we want to remove it, do so
-    if (options.removeLeadingSlash && result.startsWith("/")) {
-        result = result.slice(1);
-    }
     return result || "/";
 };
 

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

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -7,14 +6,16 @@ import { initTranslator } from '../translator/init-translator.js';
 
 /**
  * Get a edge-runtime translator for the current execution context.
+ *
+ * @public
  */
 async function getTranslator(config, params) {
-    const { locale, fetch, preKey, handlers, plugins } = params;
+    const { locale, fetch = globalThis.fetch, preKey, handlers, hooks } = params;
     // Initialize a locale-bound translator snapshot with messages loaded
     const translator = await initTranslator(config, locale, {
-        fetch: fetch || globalThis.fetch,
-        plugins,
-        handlers,
+        fetch,
+        ...(handlers !== undefined ? { handlers } : {}),
+        ...(hooks !== undefined ? { hooks } : {}),
     });
     const scoped = translator.scoped(preKey);
     return {

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

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import 'logry';
 import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
 import { createTranslator } from '../../core/translator/create-translator.js';
@@ -12,24 +11,31 @@ import 'intor-translator';
  */
 async function initTranslator(config, locale, options) {
     const { loader } = config;
-    const { fetch, handlers, plugins } = options;
+    const { fetch, handlers, hooks } = options;
     // Load messages
     let messages = {};
     if (loader && loader.mode === "remote") {
+        const { namespaces, concurrency, url, headers } = loader;
         const loaded = await loadRemoteMessages({
             locale,
             fallbackLocales: config.fallbackLocales[locale] || [],
-            namespaces: loader.namespaces,
-            concurrency: loader.concurrency,
+            ...(namespaces !== undefined ? { namespaces } : {}),
+            ...(concurrency !== undefined ? { concurrency } : {}),
             fetch,
-            url: loader.url,
-            headers: loader.headers,
+            url,
+            ...(headers !== undefined ? { headers: headers } : {}),
             loggerOptions: config.logger,
         });
         messages = loaded || {};
     }
     // Create immutable translator snapshot
-    return createTranslator({ config, locale, messages, handlers, plugins });
+    return createTranslator({
+        config,
+        locale,
+        messages,
+        ...(handlers !== undefined ? { handlers } : {}),
+        ...(hooks !== undefined ? { hooks } : {}),
+    });
 }
 
 export { initTranslator };