intor 2.3.9 → 2.3.10

package/README.md

@@ -15,9 +15,3 @@ Fast to start, easy to extend, and free from the usual i18n heaviness.
 [![License](https://img.shields.io/npm/l/intor?style=flat&colorA=000000&colorB=000000)](LICENSE)
 
 </div>
-
-<div align="center">
-
-#### 🍳 Cooking the Intor v2 docs, crafting them to perfection...
-
-</div>

package/dist/core/export/index.js

@@ -1,10 +1,12 @@
 export { PREFIX_PLACEHOLDER } from '../src/core/constants/prefix-placeholder.js';
 export { IntorError, IntorErrorCode } from '../src/core/error/intor-error.js';
 export { deepMerge } from '../src/core/utils/deep-merge.js';
+export { resolveLoaderOptions } from '../src/core/utils/resolve-loader-options.js';
 import 'logry';
 export { clearLoggerPool } from '../src/core/logger/global-logger-pool.js';
 export { isValidMessages } from '../src/core/messages/utils/is-valid-messages.js';
 export { clearMessagesPool, setGlobalMessagesPool } from '../src/core/messages/global-messages-pool.js';
+export { mergeMessages } from '../src/core/messages/merge-messages.js';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';
 import '../src/config/constants/cookie.js';
 import '../src/config/constants/cache.js';

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

@@ -1,8 +1,6 @@
 export { intor } from '../../src/server/intor/intor.js';
 export { loadMessages } from '../../src/server/messages/load-messages.js';
 import 'intor-translator';
-import '../../src/core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 export { getTranslator } from '../../src/server/helpers/get-translator.js';
 export { loadMessagesFromUrl } from '../../src/server/helpers/local-messages-from-url.js';

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

@@ -5,16 +5,16 @@ import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messag
 /**
  * Load locale messages from a remote API.
  *
- * This function acts as the orchestration layer for remote message loading.
- * It is responsible for:
+ * This function serves as the orchestration layer for remote message loading.
+ * It coordinates:
  *
- * - Resolving fallback locales in order
- * - Coordinating cache read / write behavior
+ * - Locale resolution with fallbacks
+ * - 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 ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -24,16 +24,20 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
     }
     const start = performance.now();
     logger.debug("Loading remote messages.", { url });
-    // --- Cache key ---
+    // ---------------------------------------------------------------------------
+    // Cache key resolution
+    // ---------------------------------------------------------------------------
     const cacheKey = normalizeCacheKey([
-        loggerOptions.id,
+        id,
         "loaderType:remote",
         rootDir,
         locale,
-        (fallbackLocales ?? []).toSorted().join(","),
-        (namespaces ?? []).toSorted().join(","),
+        (fallbackLocales || []).toSorted().join(","),
+        (namespaces || []).toSorted().join(","),
     ]);
-    // --- Cache read ---
+    // ---------------------------------------------------------------------------
+    // Cache read
+    // ---------------------------------------------------------------------------
     if (cacheOptions.enabled && cacheKey) {
         const cached = await pool?.get(cacheKey);
         if (signal?.aborted) {
@@ -45,9 +49,11 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             return cached;
         }
     }
+    // ---------------------------------------------------------------------------
+    // Resolve locale messages with ordered fallback strategy
+    // ---------------------------------------------------------------------------
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
-    // 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;
@@ -87,13 +93,17 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             });
         }
     }
-    // --- Cache write ---
-    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
+    // ---------------------------------------------------------------------------
+    // Cache write (explicitly permitted)
+    // ---------------------------------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite) {
         if (signal?.aborted) {
             logger.debug("Remote message loading aborted before cache write.");
             return;
         }
-        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        if (cacheKey && messages) {
+            await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        }
     }
     // Final success log with resolved locale and timing
     if (messages) {

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

@@ -0,0 +1,33 @@
+import { getLogger } from '../logger/get-logger.js';
+import { deepMerge } from '../utils/deep-merge.js';
+
+/**
+ * Merge locale-specific messages with runtime overrides.
+ *
+ * - Only merges messages under the given locale
+ * - Emits debug logs for add / override events
+ */
+function mergeMessages(a, b, { config, locale, onEvent }) {
+    const baseLogger = getLogger({ ...config.logger, id: config.id });
+    const logger = baseLogger.child({ scope: "merge-messages" });
+    // Merge messages for the active locale only
+    const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
+        onOverride: (event) => {
+            if (onEvent) {
+                onEvent(event);
+                return;
+            }
+            const { kind, path, next, prev } = event;
+            if (kind === "add")
+                return;
+            logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
+        },
+    });
+    // Preserve other locales, update only the target one
+    return {
+        ...a,
+        [locale]: merged,
+    };
+}
+
+export { mergeMessages };

package/dist/core/src/core/utils/deep-merge.js

@@ -1,28 +1,44 @@
 /**
- * Deeply merges two objects.
+ * Deeply merges two plain objects.
  *
- * - Nested objects → merged recursively
- * - Array / primitive → b overwrites a
+ * - Nested plain objects → merged recursively
+ * - Arrays / primitives → `b` overwrites `a`
  *
- * This function always returns a plain object.
+ * Debug behavior (optional):
+ * - Emits override events via `onOverride`
+ * - Zero overhead when no options are provided
+ *
+ * This function always returns a new plain object.
  */
-const deepMerge = (a = {}, b = {}) => {
+const deepMerge = (a = {}, b = {}, options) => {
     const result = { ...a };
+    const basePath = options?._path ?? [];
+    // Iterate only over b's own enumerable properties
     for (const key in b) {
-        if (Object.prototype.hasOwnProperty.call(b, key)) {
-            const av = a[key];
-            const bv = b[key];
-            if (av &&
-                bv &&
-                typeof av === "object" &&
-                typeof bv === "object" &&
-                !Array.isArray(av) &&
-                !Array.isArray(bv)) {
-                result[key] = deepMerge(av, bv);
-            }
-            else {
-                result[key] = bv;
-            }
+        if (!Object.prototype.hasOwnProperty.call(b, key))
+            continue;
+        const aValue = a[key];
+        const bValue = b[key];
+        const nextPath = [...basePath, key];
+        // Recursively merge when both sides are plain objects
+        if (aValue &&
+            bValue &&
+            typeof aValue === "object" &&
+            typeof bValue === "object" &&
+            !Array.isArray(aValue) &&
+            !Array.isArray(bValue)) {
+            result[key] = deepMerge(aValue, bValue, options ? { ...options, _path: nextPath } : undefined);
+        }
+        else {
+            // Emit override event only when debugging is enabled
+            const isAdd = aValue === undefined;
+            options?.onOverride?.({
+                path: nextPath.join("."),
+                prev: aValue,
+                next: bValue,
+                kind: isAdd ? "add" : "override",
+            });
+            result[key] = bValue;
         }
     }
     return result;

package/dist/core/src/core/utils/resolve-loader-options.js

@@ -18,6 +18,15 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
+    // --- runtime: client ---
+    if (runtime === "client") {
+        const client = config.client?.loader;
+        if (client) {
+            // Client loader is always remote by design
+            return { type: "remote", ...client };
+        }
+        return config.server?.loader ?? config.loader;
+    }
     // --- runtime: server ---
     return config.server?.loader ?? config.loader;
 };

package/dist/core/src/server/helpers/local-messages-from-url.js

@@ -37,6 +37,7 @@ async function loadMessagesFromUrl(url, options) {
     const fallbackLocales = parseMultiValueParam(url.searchParams.getAll("fallbackLocales"));
     // Load local messages
     return loadLocalMessages({
+        id: options?.id || "default",
         rootDir,
         locale,
         namespaces,

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

@@ -18,7 +18,7 @@ import { readLocaleMessages } from './read-locale-messages/read-locale-messages.
  *
  * File traversal, parsing, and validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-local-messages" });
     const start = performance.now();
@@ -30,7 +30,7 @@ const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir
     // Cache key resolution
     // ---------------------------------------------------------------------------
     const cacheKey = normalizeCacheKey([
-        loggerOptions.id,
+        id,
         "loaderType:local",
         rootDir,
         locale,

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

@@ -24,19 +24,19 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
     // ---------------------------------------------------------------------------
     // Resolve loader configuration
     // ---------------------------------------------------------------------------
-    const loader = resolveLoaderOptions(config);
+    const loader = resolveLoaderOptions(config, "server");
     if (!loader) {
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, rootDir } = loader;
+    const { type, namespaces } = 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,
         fallbackLocales,
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "[ALL]",
+        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : ["*"],
         cache: config.cache,
     });
     // ---------------------------------------------------------------------------
@@ -45,10 +45,11 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
     let loadedMessages;
     if (type === "local") {
         loadedMessages = await loadLocalMessages({
+            id: config.id,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir,
+            rootDir: loader.rootDir,
             concurrency: loader.concurrency,
             readOptions,
             cacheOptions: config.cache,
@@ -58,10 +59,11 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
     }
     else if (type === "remote") {
         loadedMessages = await loadRemoteMessages({
+            id: config.id,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir,
+            rootDir: loader.rootDir,
             url: loader.url,
             headers: loader.headers,
             allowCacheWrite,

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

@@ -1,8 +1,5 @@
 import { Translator } from 'intor-translator';
-import '../../core/error/intor-error.js';
-import { deepMerge } from '../../core/utils/deep-merge.js';
-import 'logry';
-import 'keyv';
+import { mergeMessages } from '../../core/messages/merge-messages.js';
 
 /**
  * Create a server-side translator snapshot.
@@ -17,7 +14,10 @@ import 'keyv';
 function createTranslator(params) {
     const { config, locale, messages, preKey, handlers, plugins } = params;
     // Merge static config messages with runtime-loaded messages
-    const finalMessages = deepMerge(config.messages, messages);
+    const finalMessages = mergeMessages(config.messages, messages, {
+        config,
+        locale,
+    });
     const translator = new Translator({
         locale,
         messages: finalMessages,

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

@@ -5,16 +5,16 @@ import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messag
 /**
  * Load locale messages from a remote API.
  *
- * This function acts as the orchestration layer for remote message loading.
- * It is responsible for:
+ * This function serves as the orchestration layer for remote message loading.
+ * It coordinates:
  *
- * - Resolving fallback locales in order
- * - Coordinating cache read / write behavior
+ * - Locale resolution with fallbacks
+ * - 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 ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -24,16 +24,20 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
     }
     const start = performance.now();
     logger.debug("Loading remote messages.", { url });
-    // --- Cache key ---
+    // ---------------------------------------------------------------------------
+    // Cache key resolution
+    // ---------------------------------------------------------------------------
     const cacheKey = normalizeCacheKey([
-        loggerOptions.id,
+        id,
         "loaderType:remote",
         rootDir,
         locale,
-        (fallbackLocales ?? []).toSorted().join(","),
-        (namespaces ?? []).toSorted().join(","),
+        (fallbackLocales || []).toSorted().join(","),
+        (namespaces || []).toSorted().join(","),
     ]);
-    // --- Cache read ---
+    // ---------------------------------------------------------------------------
+    // Cache read
+    // ---------------------------------------------------------------------------
     if (cacheOptions.enabled && cacheKey) {
         const cached = await pool?.get(cacheKey);
         if (signal?.aborted) {
@@ -45,9 +49,11 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             return cached;
         }
     }
+    // ---------------------------------------------------------------------------
+    // Resolve locale messages with ordered fallback strategy
+    // ---------------------------------------------------------------------------
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
-    // 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;
@@ -87,13 +93,17 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             });
         }
     }
-    // --- Cache write ---
-    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
+    // ---------------------------------------------------------------------------
+    // Cache write (explicitly permitted)
+    // ---------------------------------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite) {
         if (signal?.aborted) {
             logger.debug("Remote message loading aborted before cache write.");
             return;
         }
-        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        if (cacheKey && messages) {
+            await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        }
     }
     // Final success log with resolved locale and timing
     if (messages) {

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

@@ -0,0 +1,33 @@
+import { getLogger } from '../logger/get-logger.js';
+import { deepMerge } from '../utils/deep-merge.js';
+
+/**
+ * Merge locale-specific messages with runtime overrides.
+ *
+ * - Only merges messages under the given locale
+ * - Emits debug logs for add / override events
+ */
+function mergeMessages(a, b, { config, locale, onEvent }) {
+    const baseLogger = getLogger({ ...config.logger, id: config.id });
+    const logger = baseLogger.child({ scope: "merge-messages" });
+    // Merge messages for the active locale only
+    const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
+        onOverride: (event) => {
+            if (onEvent) {
+                onEvent(event);
+                return;
+            }
+            const { kind, path, next, prev } = event;
+            if (kind === "add")
+                return;
+            logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
+        },
+    });
+    // Preserve other locales, update only the target one
+    return {
+        ...a,
+        [locale]: merged,
+    };
+}
+
+export { mergeMessages };

package/dist/express/src/core/utils/deep-merge.js

@@ -1,28 +1,44 @@
 /**
- * Deeply merges two objects.
+ * Deeply merges two plain objects.
  *
- * - Nested objects → merged recursively
- * - Array / primitive → b overwrites a
+ * - Nested plain objects → merged recursively
+ * - Arrays / primitives → `b` overwrites `a`
  *
- * This function always returns a plain object.
+ * Debug behavior (optional):
+ * - Emits override events via `onOverride`
+ * - Zero overhead when no options are provided
+ *
+ * This function always returns a new plain object.
  */
-const deepMerge = (a = {}, b = {}) => {
+const deepMerge = (a = {}, b = {}, options) => {
     const result = { ...a };
+    const basePath = options?._path ?? [];
+    // Iterate only over b's own enumerable properties
     for (const key in b) {
-        if (Object.prototype.hasOwnProperty.call(b, key)) {
-            const av = a[key];
-            const bv = b[key];
-            if (av &&
-                bv &&
-                typeof av === "object" &&
-                typeof bv === "object" &&
-                !Array.isArray(av) &&
-                !Array.isArray(bv)) {
-                result[key] = deepMerge(av, bv);
-            }
-            else {
-                result[key] = bv;
-            }
+        if (!Object.prototype.hasOwnProperty.call(b, key))
+            continue;
+        const aValue = a[key];
+        const bValue = b[key];
+        const nextPath = [...basePath, key];
+        // Recursively merge when both sides are plain objects
+        if (aValue &&
+            bValue &&
+            typeof aValue === "object" &&
+            typeof bValue === "object" &&
+            !Array.isArray(aValue) &&
+            !Array.isArray(bValue)) {
+            result[key] = deepMerge(aValue, bValue, options ? { ...options, _path: nextPath } : undefined);
+        }
+        else {
+            // Emit override event only when debugging is enabled
+            const isAdd = aValue === undefined;
+            options?.onOverride?.({
+                path: nextPath.join("."),
+                prev: aValue,
+                next: bValue,
+                kind: isAdd ? "add" : "override",
+            });
+            result[key] = bValue;
         }
     }
     return result;

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

@@ -18,7 +18,7 @@ import { readLocaleMessages } from './read-locale-messages/read-locale-messages.
  *
  * File traversal, parsing, and validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-local-messages" });
     const start = performance.now();
@@ -30,7 +30,7 @@ const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir
     // Cache key resolution
     // ---------------------------------------------------------------------------
     const cacheKey = normalizeCacheKey([
-        loggerOptions.id,
+        id,
         "loaderType:local",
         rootDir,
         locale,

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

@@ -29,14 +29,14 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, rootDir } = loader;
+    const { type, namespaces } = 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,
         fallbackLocales,
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "[ALL]",
+        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : ["*"],
         cache: config.cache,
     });
     // ---------------------------------------------------------------------------
@@ -45,10 +45,11 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
     let loadedMessages;
     if (type === "local") {
         loadedMessages = await loadLocalMessages({
+            id: config.id,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir,
+            rootDir: loader.rootDir,
             concurrency: loader.concurrency,
             readOptions,
             cacheOptions: config.cache,
@@ -58,10 +59,11 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
     }
     else if (type === "remote") {
         loadedMessages = await loadRemoteMessages({
+            id: config.id,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir,
+            rootDir: loader.rootDir,
             url: loader.url,
             headers: loader.headers,
             allowCacheWrite,

package/dist/express/src/server/translator/create-translator.js

@@ -1,8 +1,5 @@
 import { Translator } from 'intor-translator';
-import '../../core/error/intor-error.js';
-import { deepMerge } from '../../core/utils/deep-merge.js';
-import 'logry';
-import 'keyv';
+import { mergeMessages } from '../../core/messages/merge-messages.js';
 
 /**
  * Create a server-side translator snapshot.
@@ -17,7 +14,10 @@ import 'keyv';
 function createTranslator(params) {
     const { config, locale, messages, preKey, handlers, plugins } = params;
     // Merge static config messages with runtime-loaded messages
-    const finalMessages = deepMerge(config.messages, messages);
+    const finalMessages = mergeMessages(config.messages, messages, {
+        config,
+        locale,
+    });
     const translator = new Translator({
         locale,
         messages: finalMessages,

package/dist/next/src/adapters/next/navigation/link.js

@@ -3,7 +3,7 @@ import { jsx } from 'react/jsx-runtime';
 import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
 import NextLink from 'next/link';
 import 'react';
-import { useResolveNavigation } from 'intor/react';
+import { useResolveNavigation, useExecuteNavigation } from 'intor/react';
 import { usePathname } from './use-pathname.js';
 
 /**
@@ -16,26 +16,25 @@ import { usePathname } from './use-pathname.js';
  */
 const Link = ({ href, locale, children, onClick, ...props }) => {
     const { pathname } = usePathname();
-    const { resolveNavigation } = useResolveNavigation();
+    const resolveNavigation = useResolveNavigation();
+    const executeNavigation = useExecuteNavigation();
     // Normalize href into a string destination
     const rawDestination = typeof href === "string" ? href : href ? formatUrl(href) : undefined;
     // Resolve navigation result for this link
-    const { kind, destination } = resolveNavigation(pathname, {
+    const navigationResult = resolveNavigation(pathname, {
         destination: rawDestination,
         locale,
     });
+    // --------------------------------------------------
+    // Execute navigation on user interaction
+    // --------------------------------------------------
     const handleClick = (e) => {
         onClick?.(e);
         if (e.defaultPrevented)
             return;
-        // Decide how this navigation should be executed
-        if (kind === "reload") {
-            e.preventDefault(); // prevent client-side navigation
-            globalThis.location.href = destination;
-            return;
-        }
+        executeNavigation(navigationResult, e);
     };
-    return (jsx(NextLink, { href: destination, onClick: handleClick, ...props, children: children }));
+    return (jsx(NextLink, { href: navigationResult.destination, onClick: handleClick, ...props, children: children }));
 };
 
 export { Link };