intor 2.3.5 → 2.3.7

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

@@ -2,32 +2,27 @@ import { Translator } from 'intor-translator';
 import { loadMessages } from '../messages/load-messages.js';
 
 // Implementation
-async function getTranslator(options) {
-    const { config, locale, preKey } = options;
-    const messages = await loadMessages({
-        config,
-        locale,
-        extraOptions: options.extraOptions,
-    });
-    // Create a Translator instance
+async function getTranslator(params) {
+    const { config, locale, preKey, extraOptions } = params;
+    const messages = await loadMessages({ config, locale, extraOptions });
     const translator = new Translator({
         locale,
         messages,
         fallbackLocales: config.fallbackLocales,
         loadingMessage: config.translator?.loadingMessage,
-        placeholder: config.translator?.placeholder,
-        handlers: options.handlers,
-        plugins: options.plugins,
+        missingMessage: config.translator?.missingMessage,
+        handlers: params.handlers,
+        plugins: params.plugins,
     });
-    const props = { messages, locale };
     const scoped = translator.scoped(preKey);
     return {
-        ...props,
+        messages,
+        locale,
         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.
+        // The runtime implementation is intentionally erased.
+        // Type safety is guaranteed by public type contracts.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }

package/dist/react/export/react/index.js

@@ -1,18 +1,8 @@
-export { IntorProvider } from '../../src/client/react/contexts/intor-provider/intor-provider.js';
-import 'react/jsx-runtime';
-import 'react';
-import '../../src/client/react/contexts/config/context.js';
-export { useConfig } from '../../src/client/react/contexts/config/hook.js';
-import '../../src/client/react/contexts/locale/context.js';
-export { useLocale } from '../../src/client/react/contexts/locale/hook.js';
-import '../../src/config/constants/cache.constants.js';
-import 'logry';
-import 'keyv';
-import '../../src/client/react/contexts/messages/context.js';
-import 'intor-translator';
-export { TranslatorRuntimeProvider } from '../../src/client/react/contexts/translator-runtime/provider.js';
-import '../../src/client/react/contexts/translator-runtime/context.js';
-import '../../src/client/react/contexts/translator/context.js';
+export { IntorProvider } from '../../src/client/react/provider/intor-provider.js';
+export { useIntor } from '../../src/client/react/provider/use-intor.js';
 export { useTranslator } from '../../src/client/react/translator/use-translator.js';
 export { T } from '../../src/client/react/translator/t.js';
+export { useNavigationTarget } from '../../src/client/react/navigation/use-navigation-target.js';
+export { useNavigationStrategy } from '../../src/client/react/navigation/use-navigation-strategy.js';
+export { useLoadMessages } from '../../src/client/react/helpers/use-load-messages.js';
 export { getClientLocale } from '../../src/client/helpers/get-client-locale.js';

package/dist/react/src/client/helpers/get-client-locale.js

@@ -1,6 +1,9 @@
+import '../../core/error/intor-error.js';
+import { normalizeLocale } from '../../core/utils/normalizers/normalize-locale.js';
+import 'logry';
+import 'keyv';
 import { detectBrowserLocale } from '../shared/utils/locale/detect-browser-locale.js';
 import { getLocaleCookieBrowser } from '../shared/utils/locale/get-locale-cookie-browser.js';
-import { normalizeLocale } from '../../shared/utils/normalizers/normalize-locale.js';
 
 /**
  * Resolve the locale in a client-only environment.

package/dist/react/src/client/react/helpers/use-load-messages.js

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import '../../../core/error/intor-error.js';
+import { deepMerge } from '../../../core/utils/deep-merge.js';
+import 'logry';
+import 'keyv';
+import { getClientLocale } from '../../helpers/get-client-locale.js';
+
+function useLoadMessages(config, loader) {
+    // ---------------------------------------------------------------------------
+    // Initial locale
+    // ---------------------------------------------------------------------------
+    const initialLocale = React.useMemo(() => getClientLocale(config), [config]);
+    // ---------------------------------------------------------------------------
+    // State
+    // ---------------------------------------------------------------------------
+    const [messages, setMessages] = React.useState(config.messages || {});
+    const [isLoading, setIsLoading] = React.useState(true);
+    const activeLocaleRef = React.useRef(initialLocale);
+    // ---------------------------------------------------------------------------
+    // Locale change handler
+    // ---------------------------------------------------------------------------
+    const onLocaleChange = React.useCallback(async (newLocale) => {
+        activeLocaleRef.current = newLocale;
+        setIsLoading(true);
+        const loaded = await loader(newLocale);
+        // Ignore outdated results when locale changes again.
+        if (activeLocaleRef.current !== newLocale)
+            return;
+        setMessages(deepMerge(config.messages, loaded));
+        setIsLoading(false);
+    }, [config.messages, loader]);
+    // ---------------------------------------------------------------------------
+    // Initial load
+    // ---------------------------------------------------------------------------
+    React.useEffect(() => {
+        onLocaleChange(initialLocale);
+    }, [initialLocale, onLocaleChange]);
+    return {
+        initialLocale,
+        messages,
+        isLoading,
+        onLocaleChange,
+    };
+}
+
+export { useLoadMessages };

package/dist/{next → react}/src/client/react/navigation/use-navigation-strategy.js

@@ -1,5 +1,10 @@
-import { useConfig, useLocale } from 'intor/react';
 import { setLocaleCookieBrowser } from '../../shared/utils/locale/set-locale-cookie-browser.js';
+import '../../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../../core/utils/resolve-loader-options.js';
+import 'logry';
+import 'keyv';
+import '../provider/intor-provider.js';
+import { useIntor } from '../provider/use-intor.js';
 
 /**
  * Determines the navigation strategy for a resolved navigation target.
@@ -10,17 +15,16 @@ import { setLocaleCookieBrowser } from '../../shared/utils/locale/set-locale-coo
  * No navigation is performed here.
  */
 const useNavigationStrategy = () => {
-    const { config } = useConfig();
-    const { setLocale } = useLocale();
-    const { loader, cookie } = config;
+    const { config, setLocale } = useIntor();
+    const loader = resolveLoaderOptions(config);
     /** Decide how the given navigation target should be handled. */
     const decideNavigation = (target) => {
         if (target.isExternal) {
             return { kind: "external" };
         }
-        const fullReloadRequired = loader?.type === "local";
-        if (fullReloadRequired) {
-            setLocaleCookieBrowser(cookie, target.locale); // Persist locale before full page reload
+        const shouldFullReload = loader?.type === "local" || config.routing.forceFullReload;
+        if (shouldFullReload) {
+            setLocaleCookieBrowser(config.cookie, target.locale); // Persist locale before full page reload
             return { kind: "reload" };
         }
         setLocale(target.locale); // Sync locale state for client-side navigation

package/dist/{next → react}/src/client/react/navigation/use-navigation-target.js

@@ -1,5 +1,9 @@
-import { useConfig, useLocale } from 'intor/react';
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'keyv';
 import { resolveNavigationTarget } from '../../../routing/resolve-navigation-target.js';
+import '../provider/intor-provider.js';
+import { useIntor } from '../provider/use-intor.js';
 
 /**
  * Hook for resolving locale-aware navigation targets.
@@ -7,8 +11,7 @@ import { resolveNavigationTarget } from '../../../routing/resolve-navigation-tar
  * This hook bridges Next.js navigation context with Intor's routing decision logic.
  */
 const useNavigationTarget = (localizedPathname) => {
-    const { config } = useConfig();
-    const { locale: currentLocale } = useLocale();
+    const { config, locale: currentLocale } = useIntor();
     const resolveNavigation = (input) => {
         return resolveNavigationTarget(config, currentLocale, localizedPathname, {
             ...input,

package/dist/react/src/client/react/provider/effects/use-locale-effects.js

@@ -0,0 +1,14 @@
+"use client";
+import * as React from 'react';
+import { setLocaleCookieBrowser } from '../../../shared/utils/locale/set-locale-cookie-browser.js';
+import { setDocumentLocale } from '../../../shared/utils/locale/set-document-locale.js';
+
+function useLocaleEffects(config, locale) {
+    // Sync locale-related browser side effects.
+    React.useEffect(() => {
+        setLocaleCookieBrowser(config.cookie, locale);
+        setDocumentLocale(locale);
+    }, [config.cookie, locale]);
+}
+
+export { useLocaleEffects };

package/dist/react/src/client/react/provider/effects/use-messages-effects.js

@@ -0,0 +1,24 @@
+"use client";
+import * as React from 'react';
+import { createRefetchMessages } from '../../../shared/messages/create-refetch-messages.js';
+
+function useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoading) {
+    // Prepares message refetch function.
+    const refetchMessages = React.useMemo(() => createRefetchMessages({
+        config,
+        onLoadingStart: () => setInternalIsLoading(true),
+        onLoadingEnd: () => setInternalIsLoading(false),
+        onMessages: setRuntimeMessages,
+    }), [config, setRuntimeMessages, setInternalIsLoading]);
+    // Refetch messages when locale changes (except initial render).
+    const isInitialRenderRef = React.useRef(true);
+    React.useEffect(() => {
+        if (isInitialRenderRef.current) {
+            isInitialRenderRef.current = false;
+            return;
+        }
+        refetchMessages(locale);
+    }, [refetchMessages, locale]);
+}
+
+export { useMessagesEffects };

package/dist/react/src/client/react/provider/intor-provider.js

@@ -0,0 +1,70 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { Translator } from 'intor-translator';
+import * as React from 'react';
+import { useLocaleEffects } from './effects/use-locale-effects.js';
+import { useMessagesEffects } from './effects/use-messages-effects.js';
+
+const IntorContext = React.createContext(undefined);
+const IntorProvider = ({ value: { config, initialLocale, initialMessages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }, children, }) => {
+    // -----------------------------------------------------------------------------
+    // Internal state
+    // -----------------------------------------------------------------------------
+    const [locale, setLocaleState] = React.useState(initialLocale);
+    const [runtimeMessages, setRuntimeMessages] = React.useState(null);
+    const [internalIsLoading, setInternalIsLoading] = React.useState(false);
+    // -----------------------------------------------------------------------------
+    // Locale transition
+    // -----------------------------------------------------------------------------
+    /** Request a locale change. */
+    const setLocale = React.useCallback(async (newLocale) => {
+        if (newLocale === locale)
+            return;
+        setLocaleState(newLocale);
+        onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
+    }, [locale, onLocaleChange]);
+    // -----------------------------------------------------------------------------
+    // Effective state
+    // -----------------------------------------------------------------------------
+    // external > internal > localeTransitioning
+    const effectiveIsLoading = !!externalIsLoading || internalIsLoading;
+    // runtime (client refetch) > initial > config (static)
+    const effectiveMessages = React.useMemo(() => runtimeMessages || initialMessages || config.messages || {}, [config.messages, initialMessages, runtimeMessages]);
+    // -----------------------------------------------------------------------------
+    // Translator
+    // -----------------------------------------------------------------------------
+    const translator = React.useMemo(() => {
+        return new Translator({
+            messages: effectiveMessages,
+            locale,
+            isLoading: effectiveIsLoading,
+            fallbackLocales: config.fallbackLocales,
+            loadingMessage: config.translator?.loadingMessage,
+            missingMessage: config.translator?.missingMessage,
+            handlers,
+            plugins,
+        });
+    }, [
+        effectiveMessages,
+        locale,
+        effectiveIsLoading,
+        config,
+        handlers,
+        plugins,
+    ]);
+    // ---------------------------------------------------------------------------
+    // Side effects
+    // ---------------------------------------------------------------------------
+    useLocaleEffects(config, locale);
+    useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoading);
+    return (jsx(IntorContext.Provider, { value: {
+            config,
+            locale,
+            setLocale,
+            messages: effectiveMessages,
+            isLoading: effectiveIsLoading,
+            translator,
+        }, children: children }));
+};
+
+export { IntorContext, IntorProvider };

package/dist/react/src/client/react/provider/use-intor.js

@@ -0,0 +1,11 @@
+import React__default from 'react';
+import { IntorContext } from './intor-provider.js';
+
+function useIntor() {
+    const context = React__default.useContext(IntorContext);
+    if (!context)
+        throw new Error("useIntor must be used within IntorProvider");
+    return context;
+}
+
+export { useIntor };

package/dist/react/src/client/react/render/create-react-renderer.js

@@ -1,4 +1,4 @@
-import { createElement } from 'react';
+import * as React from 'react';
 
 /**
  * Create a React renderer for semantic rich messages.
@@ -28,7 +28,7 @@ const createReactRenderer = (options) => {
                     : renderer;
             }
             // Default behavior: render as a native React element
-            return createElement(name, attributes, ...children);
+            return React.createElement(name, attributes, ...children);
         },
     };
 };

package/dist/react/src/client/react/translator/use-translator.js

@@ -1,34 +1,23 @@
-import 'react/jsx-runtime';
-import 'react';
-import '../contexts/config/context.js';
-import '../contexts/locale/context.js';
-import { useLocale } from '../contexts/locale/hook.js';
-import 'intor-translator';
-import '../../../config/constants/cache.constants.js';
-import 'logry';
-import 'keyv';
-import '../contexts/messages/context.js';
-import '../contexts/translator-runtime/context.js';
-import '../contexts/translator/context.js';
-import { useTranslator as useTranslator$1 } from '../contexts/translator/hook.js';
+import '../provider/intor-provider.js';
+import { useIntor } from '../provider/use-intor.js';
 import { createTRich } from './create-t-rich.js';
 
 // Implementation
 function useTranslator(preKey) {
-    const { translator } = useTranslator$1();
-    const { setLocale } = useLocale();
-    const props = {
+    const { translator, setLocale } = useIntor();
+    const scoped = translator.scoped(preKey);
+    return {
         messages: translator.messages,
         locale: translator.locale,
         isLoading: translator.isLoading,
         setLocale,
-    };
-    const scoped = translator.scoped(preKey);
-    return {
-        ...props,
         hasKey: preKey ? scoped.hasKey : translator.hasKey,
         t: preKey ? scoped.t : translator.t,
         tRich: createTRich(translator, preKey),
+        // NOTE:
+        // The runtime implementation is intentionally erased.
+        // Type safety is guaranteed by public type contracts.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }
 

package/dist/react/src/client/shared/messages/create-refetch-messages.js

@@ -0,0 +1,61 @@
+import '../../../core/error/intor-error.js';
+import { deepMerge } from '../../../core/utils/deep-merge.js';
+import { resolveLoaderOptions } from '../../../core/utils/resolve-loader-options.js';
+import 'logry';
+import { loadRemoteMessages } from '../../../core/messages/load-remote-messages/load-remote-messages.js';
+import 'keyv';
+
+/**
+ * Creates a framework-agnostic message refetcher.
+ *
+ * - At most one remote request is active at any time
+ * - Previous in-flight requests are aborted on subsequent calls
+ * - State updates are applied only for the latest, non-aborted request
+ */
+const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessages, }) => {
+    // Tracks the currently active remote request for this refetcher instance
+    let controller = null;
+    return async function refetchMessages(newLocale) {
+        // No-op when remote loading is not enabled
+        const loader = resolveLoaderOptions(config);
+        if (!loader || loader.type !== "remote")
+            return;
+        // Abort previous request
+        controller?.abort();
+        const currentController = new AbortController();
+        controller = currentController;
+        onLoadingStart?.();
+        try {
+            const loadedMessages = await loadRemoteMessages({
+                // --- Messages Scope ---
+                locale: newLocale,
+                fallbackLocales: config.fallbackLocales[newLocale] || [],
+                namespaces: loader.namespaces,
+                rootDir: loader.rootDir,
+                // --- Remote Source ---
+                url: loader.url,
+                headers: loader.headers,
+                signal: currentController.signal,
+                // --- Caching ---
+                cacheOptions: config.cache,
+                // --- Observability ---
+                loggerOptions: config.logger,
+            });
+            // Apply state updates only when this request is still the active one
+            // and has not been aborted.
+            if (controller === currentController &&
+                !currentController.signal.aborted) {
+                onMessages?.(deepMerge(config.messages, loadedMessages));
+            }
+        }
+        finally {
+            // Clear loading state only if this request is still the active one
+            if (controller === currentController &&
+                !currentController.signal.aborted) {
+                onLoadingEnd?.();
+            }
+        }
+    };
+};
+
+export { createRefetchMessages };

package/dist/react/src/core/constants/prefix-placeholder.js

@@ -0,0 +1,4 @@
+// Default prefix placeholder
+const PREFIX_PLACEHOLDER = "{locale}";
+
+export { PREFIX_PLACEHOLDER };

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

@@ -0,0 +1,9 @@
+var IntorErrorCode;
+(function (IntorErrorCode) {
+    // intor-config
+    IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
+    IntorErrorCode["MISSING_DEFAULT_LOCALE"] = "INTOR_MISSING_DEFAULT_LOCALE";
+    IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
+})(IntorErrorCode || (IntorErrorCode = {}));
+
+export { IntorErrorCode };

package/dist/{core/src/server → react/src/core}/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.js

@@ -1,5 +1,6 @@
-import { isValidMessages } from '../../shared/utils/is-valid-messages.js';
-import { getLogger } from '../../../shared/logger/get-logger.js';
+import { getLogger } from '../../../logger/get-logger.js';
+import { isValidMessages } from '../../utils/is-valid-messages.js';
+import { buildSearchParams } from './utils/build-search-params.js';
 
 /**
  * Fetches locale messages from a remote API.
@@ -7,22 +8,21 @@ 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 } = {}, signal, }) => {
-    const baseLogger = getLogger({ ...loggerOptions });
+const fetchLocaleMessages = async ({ locale, namespaces, rootDir, url: rawUrl, headers: rawHeaders, signal, extraOptions: { loggerOptions }, }) => {
+    const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+    const searchParams = buildSearchParams({ locale, rootDir, namespaces });
+    const url = `${rawUrl}?${searchParams.toString()}`;
     try {
-        const params = new URLSearchParams(searchParams);
-        params.append("locale", locale);
-        const url = `${remoteUrl}?${params.toString()}`;
         // Headers
         const headers = {
             "Content-Type": "application/json",
-            ...remoteHeaders,
+            ...rawHeaders,
         };
         // Fetch
         const response = await fetch(url, {
             method: "GET",
-            headers,
+            headers: headers,
             cache: "no-store",
             signal,
         });
@@ -39,12 +39,12 @@ const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, loc
     }
     catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
-            logger.debug("Fetching locale messages aborted.", { locale, remoteUrl });
+            logger.debug("Fetching locale messages aborted.", { locale, url });
             return;
         }
         logger.warn("Fetching locale messages failed.", {
             locale,
-            remoteUrl,
+            url,
             searchParams: decodeURIComponent(searchParams.toString()),
             error,
         });

package/dist/react/src/{server → core}/messages/load-remote-messages/load-remote-messages.js

@@ -1,9 +1,6 @@
-import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
+import { getLogger } from '../../logger/get-logger.js';
+import { normalizeCacheKey } from '../../utils/normalizers/normalize-cache-key.js';
 import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
-import { buildSearchParams } from './fetch-locale-messages/utils/build-search-params.js';
-import { getLogger } from '../../shared/logger/get-logger.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.
@@ -17,8 +14,8 @@ import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-c
  *
  * Network fetching and data validation are delegated to lower-level utilities.
  */
-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 loadRemoteMessages = async ({ 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
     if (signal?.aborted) {
@@ -26,8 +23,8 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
         return;
     }
     const start = performance.now();
-    logger.debug("Loading remote messages.", { remoteUrl });
-    // --- Cache key
+    logger.debug("Loading remote messages.", { url });
+    // --- Cache key ---
     const cacheKey = normalizeCacheKey([
         loggerOptions.id,
         "loaderType:remote",
@@ -36,7 +33,7 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
         (fallbackLocales ?? []).toSorted().join(","),
         (namespaces ?? []).toSorted().join(","),
     ]);
-    // --- Cache read --------------------------------------------------
+    // --- Cache read ---
     if (cacheOptions.enabled && cacheKey) {
         const cached = await pool?.get(cacheKey);
         if (signal?.aborted) {
@@ -56,12 +53,13 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
         const isLast = i === candidateLocales.length - 1;
         try {
             const fetched = await fetchLocaleMessages({
-                remoteUrl,
-                remoteHeaders,
                 locale: candidateLocale,
-                searchParams: buildSearchParams({ rootDir, namespaces }),
-                extraOptions: { loggerOptions },
+                namespaces,
+                rootDir,
+                url,
+                headers,
                 signal,
+                extraOptions: { loggerOptions },
             });
             // Stop at the first locale that yields non-empty messages
             if (fetched && Object.values(fetched[candidateLocale] || {}).length > 0) {
@@ -89,7 +87,7 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
             });
         }
     }
-    // --- Cache write --------------------------------------------------
+    // --- Cache write ---
     if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
         if (signal?.aborted) {
             logger.debug("Remote message loading aborted before cache write.");

package/dist/{core/src/shared → react/src/core}/utils/deep-merge.js

@@ -1,15 +1,12 @@
 /**
  * Deeply merges two objects.
+ *
  * - Nested objects → merged recursively
  * - Array / primitive → b overwrites a
+ *
+ * This function always returns a plain object.
  */
-const deepMerge = (a, b) => {
-    if (!a && !b)
-        return undefined;
-    if (!a)
-        return b;
-    if (!b)
-        return a;
+const deepMerge = (a = {}, b = {}) => {
     const result = { ...a };
     for (const key in b) {
         if (Object.prototype.hasOwnProperty.call(b, key)) {
@@ -21,11 +18,9 @@ const deepMerge = (a, b) => {
                 typeof bv === "object" &&
                 !Array.isArray(av) &&
                 !Array.isArray(bv)) {
-                // recursive merge
                 result[key] = deepMerge(av, bv);
             }
             else {
-                // overwrite with primitive or array
                 result[key] = bv;
             }
         }

package/dist/react/src/core/utils/is-external-destination.js

@@ -0,0 +1,11 @@
+/**
+ * Determines whether a navigation target should bypass app routing.
+ *
+ * Any value with an explicit scheme (e.g. http:, https:, mailto:)
+ * is treated as external navigation.
+ */
+const isExternalDestination = (destination) => {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(destination);
+};
+
+export { isExternalDestination };