intor 2.4.16 → 2.5.0

package/dist/next/src/routing/locale/get-locale-from-accept-language.js

@@ -20,16 +20,18 @@ const getLocaleFromAcceptLanguage = (acceptLanguageHeader, supportedLocales) =>
     const supportedLocalesSet = new Set(supportedLocales);
     // 1. Parse Accept-Language header into language + priority pairs
     const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
-        const [rawLang, rawQ] = part.split(";");
+        const segments = part.split(";");
+        const rawLang = segments[0];
+        const rawQ = segments[1];
         const lang = rawLang.trim();
-        const q = rawQ ? Number.parseFloat(rawQ.split("=")[1]) : 1;
+        const q = rawQ !== undefined ? Number.parseFloat(rawQ.split("=")[1] ?? "") : 1;
         return {
             lang,
             q: Number.isNaN(q) ? 0 : q, // Invalid q values have lowest priority
         };
     });
     // 2. Sort by priority (highest first)
-    const sortedByPriority = parsedLanguages.toSorted((a, b) => b.q - a.q);
+    const sortedByPriority = parsedLanguages.sort((a, b) => b.q - a.q);
     // 3. Pick the first language explicitly supported
     const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
     return preferred;

package/dist/next/src/routing/locale/get-locale-from-pathname.js

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';

package/dist/next/src/routing/outbound/utils/derive-host-destination.js

@@ -6,7 +6,7 @@ const deriveHostDestination = (rawDestination, config, locale) => {
     const resolvedHost = host.map[locale] ?? host.default;
     if (!resolvedHost)
         return rawDestination;
-    const url = new URL(rawDestination, "http://internal");
+    const url = new URL(rawDestination, "http://localhost");
     return `${url.protocol}//${resolvedHost}${url.pathname}${url.search}`;
 };
 

package/dist/next/src/routing/outbound/utils/derive-query-destination.js

@@ -3,7 +3,7 @@
  */
 const deriveQueryDestination = (rawDestination, config, locale) => {
     const { queryKey } = config.routing.outbound;
-    const url = new URL(rawDestination, "http://internal");
+    const url = new URL(rawDestination, "http://localhost");
     url.searchParams.set(queryKey, locale);
     return `${url.pathname}${url.search}`;
 };

package/dist/next/src/routing/pathname/canonicalize-pathname.js

@@ -1,47 +1,78 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Returns a canonical, locale-agnostic pathname.
+ * Returns the internal canonical pathname.
+ *
+ * Canonical representation is the locale-neutral and deployment-neutral
+ * internal routing form used for identity and routing computation.
+ *
+ * Guarantees:
+ * - Pathname is normalized
+ * - Deployment prefix (`basePath`) is removed
+ * - Leading locale segment or `{locale}` placeholder is removed
+ * - Only the first path segment is evaluated for locale stripping
+ * - Result always starts with "/"
+ * - Root is represented as "/"
  *
  * Accepts `{locale}` as a locale placeholder segment.
  *
  * @example
  * ```ts
- * // config.supportedLocales: ["en-US"]
+ * // config.supportedLocales: ["en"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en-US/about", config);
+ * canonicalizePathname("/app/en/about", config);
  * // => "/about"
  *```
  */
 function canonicalizePathname(rawPathname, config) {
     const { routing, supportedLocales } = config;
-    const { basePath } = routing;
     const normalizedPathname = normalizePathname(rawPathname);
-    // Strip basePath
-    let prefixedPathname = normalizedPathname;
-    if (basePath && normalizedPathname === basePath) {
-        prefixedPathname = "/";
+    // ---------------------------------------------------------------------------
+    // Strip basePath (deployment prefix)
+    // ---------------------------------------------------------------------------
+    const basePath = routing.basePath === "/" ? "" : routing.basePath;
+    let path = normalizedPathname;
+    if (basePath) {
+        if (path === basePath) {
+            path = "/";
+        }
+        else if (path.startsWith(basePath + "/")) {
+            path = path.slice(basePath.length);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Detect first segment (allocation-minimized)
+    // ---------------------------------------------------------------------------
+    if (path === "/")
+        return "/";
+    const segmentStart = 1; // skip leading "/"
+    const nextSlash = path.indexOf("/", segmentStart);
+    const firstSegment = nextSlash === -1
+        ? path.slice(segmentStart)
+        : path.slice(segmentStart, nextSlash);
+    // ---------------------------------------------------------------------------
+    // Determine if first segment is locale representation
+    // ---------------------------------------------------------------------------
+    let localeLength;
+    if (firstSegment === LOCALE_PLACEHOLDER) {
+        localeLength = firstSegment.length;
+    }
+    else if (supportedLocales.includes(firstSegment)) {
+        localeLength = firstSegment.length;
     }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
+    // ---------------------------------------------------------------------------
+    // Strip locale segment (if any)
+    // ---------------------------------------------------------------------------
+    if (localeLength !== undefined) {
+        const stripped = path.slice(localeLength + 1);
+        return stripped || "/";
     }
-    // Detect locale segment
-    const firstSegment = prefixedPathname.split("/").find(Boolean);
-    const locale = firstSegment === LOCALE_PLACEHOLDER
-        ? LOCALE_PLACEHOLDER
-        : firstSegment && supportedLocales.includes(firstSegment)
-            ? firstSegment
-            : undefined;
-    // Strip locale segment
-    return locale
-        ? prefixedPathname.slice(locale.length + 1) || "/"
-        : prefixedPathname;
+    return path;
 }
 
 export { canonicalizePathname };

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

@@ -14,22 +14,24 @@ import { standardizePathname } from './standardize-pathname.js';
  * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
- * //   unprefixedPathname: '/about',
+ * //   canonicalPathname: '/about',
  * //   templatedPathname: '/app/{locale}/about',
  * // }
  * ```
+ *
+ * @public
  */
 const localizePathname = (rawPathname, config, locale) => {
     // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalized = canonicalizePathname(rawPathname, config);
+    const canonicalPathname = canonicalizePathname(rawPathname, config);
     // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardized = standardizePathname(canonicalized, config);
+    const standardizedPathname = standardizePathname(canonicalPathname, config);
     // 3. Materialize: apply routing rules to produce the final pathname
-    const materialized = materializePathname(standardized, config, locale);
+    const materializedPathname = materializePathname(standardizedPathname, config, locale);
     return {
-        pathname: materialized,
-        unprefixedPathname: canonicalized,
-        templatedPathname: standardized,
+        canonicalPathname,
+        templatedPathname: standardizedPathname,
+        pathname: materializedPathname,
     };
 };
 

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

@@ -1,42 +1,53 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Materializes a standardized pathname by applying
- * the configured locale prefix behavior.
+ * Materializes a standardized pathname into a concrete, locale-aware URL.
+ *
+ * This function resolves the `{locale}` placeholder according to the
+ * configured `localePrefix` strategy and produces the final pathname.
+ *
+ * Behavior:
+ * - "all": always injects the locale segment
+ * - "except-default": injects the locale unless it equals `defaultLocale`
+ * - "none": removes the locale placeholder entirely
+ *
+ * Invariants:
+ * - `standardizedPathname` must be produced by `standardizePathname`
+ * - The pathname must contain exactly one `{locale}` placeholder
+ * - The placeholder must appear as the first path segment
+ *
+ * This function performs structural transformation only.
+ * It does not normalize or sanitize the resulting pathname.
  *
  * @example
  * ```ts
  * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/en-US/about
+ * materializePathname("/app/{locale}/about", config, "en");
+ * // => /app/en/about
  *
  * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en-US");
+ * materializePathname("/app/{locale}/about", config, "en");
  * // => /app/about
  * ```
  */
 const materializePathname = (standardizedPathname, config, locale) => {
     const { localePrefix } = config.routing;
-    if (localePrefix !== "none" && !locale) {
-        throw new Error('No locale when using localePrefix "all", "except-default"');
-    }
+    const removeLocale = () => {
+        const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+        return result === "" ? "/" : result;
+    };
+    const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+    // localePrefix: "none"
+    if (localePrefix === "none")
+        return removeLocale();
     // localePrefix: "all"
-    if (localePrefix === "all") {
-        return normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
+    if (localePrefix === "all")
+        return injectLocale();
     // localePrefix: "except-default"
-    if (localePrefix === "except-default") {
-        return locale === config.defaultLocale
-            ? normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""))
-            : normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "none"
-    return normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""));
+    return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };

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

@@ -1,34 +1,39 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Standardizes a canonical pathname into an internal routing template
- * by applying the base path and injecting a locale placeholder.
+ * Standardizes a canonical pathname into an internal routing template.
+ *
+ * Standardized representation:
+ * - Prepends the deployment prefix (`basePath`) if defined
+ * - Injects the `{locale}` placeholder as the first path segment
+ * - Preserves the canonical pathname structure
+ *
+ * Input must be a canonical pathname.
+ *
+ * Output is an internal routing template and
+ * is not a locale-resolved URL.
  *
  * @example
  * ```ts
  * // config.routing.basePath: "/app",
- * // config.routing.prefix: "all"
  * standardizePathname("/about", config);
  * // => "/app/{locale}/about"
  * ```
  */
-const standardizePathname = (canonicalizedPathname, config) => {
-    const { basePath } = config.routing;
-    // Normalize each segment before join to avoid redundant slashes
-    const parts = [
-        normalizePathname(basePath),
-        LOCALE_PLACEHOLDER,
-        normalizePathname(canonicalizedPathname),
-    ];
-    // Avoid double slashes between segments
-    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-    // Final normalization to ensure leading slash, no trailing
-    return normalizePathname(standardizedPathname);
+const standardizePathname = (canonicalPathname, config) => {
+    const { routing } = config;
+    const basePath = routing.basePath && routing.basePath !== "/" ? routing.basePath : "";
+    if (canonicalPathname === "/") {
+        return basePath
+            ? `${basePath}/${LOCALE_PLACEHOLDER}`
+            : `/${LOCALE_PLACEHOLDER}`;
+    }
+    return basePath
+        ? `${basePath}/${LOCALE_PLACEHOLDER}${canonicalPathname}`
+        : `/${LOCALE_PLACEHOLDER}${canonicalPathname}`;
 };
 
 export { standardizePathname };

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

@@ -1,6 +1,4 @@
 export { IntorProvider } from '../../src/client/react/provider/intor-provider.js';
-export { useIntorContext } from '../../src/client/react/provider/use-intor-context.js';
+import 'react';
 export { useTranslator } from '../../src/client/react/translator/use-translator.js';
-export { Trans } from '../../src/client/react/translator/trans.js';
 export { useIntor } from '../../src/client/react/helpers/use-intor.js';
-export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

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

@@ -0,0 +1,5 @@
+import '../../../src/client/react/provider/intor-provider.js';
+export { useIntorContext } from '../../../src/client/react/provider/use-intor-context.js';
+import 'intor-translator';
+import 'react';
+import 'intor';

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

@@ -1,6 +1,14 @@
 import * as React from 'react';
-import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
+import { getClientLocale } from 'intor';
 
+/**
+ * Client-side Intor runtime helper.
+ *
+ * Manages locale state and dynamic message loading
+ * in pure client-side (SPA) environments.
+ *
+ * @public
+ */
 function useIntor(config, loader) {
     // ---------------------------------------------------------------------------
     // Initial locale
@@ -29,7 +37,7 @@ function useIntor(config, loader) {
     // Initial load
     // ---------------------------------------------------------------------------
     React.useEffect(() => {
-        onLocaleChange(locale);
+        void onLocaleChange(locale);
     }, [locale, onLocaleChange]);
     return {
         config,

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

@@ -1,7 +1,6 @@
 "use client";
 import * as React from 'react';
 import { shouldPersistOnFirstVisit } from '../../../../policies/should-persist-on-first-visit.js';
-import '../../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';

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

@@ -17,7 +17,7 @@ function useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoa
             isInitialRenderRef.current = false;
             return;
         }
-        refetchMessages(locale);
+        void refetchMessages(locale);
     }, [refetchMessages, locale]);
 }
 

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

@@ -2,11 +2,17 @@
 import { jsx } from 'react/jsx-runtime';
 import { Translator } from 'intor-translator';
 import * as React from 'react';
+import { resolveEffectiveMessages, resolveEffectiveIsLoading } from '../../shared/provider/effective-state.js';
 import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
 
 const IntorContext = React.createContext(undefined);
-function IntorProvider({ value: { config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }, children, }) {
+/**
+ * React provider for Intor.
+ *
+ * @public
+ */
+function IntorProvider({ value: { config, locale: initialLocale, messages, handlers, hooks, onLocaleChange, isLoading: externalIsLoading, }, children, }) {
     // -----------------------------------------------------------------------------
     // Internal state
     // -----------------------------------------------------------------------------
@@ -17,40 +23,41 @@ function IntorProvider({ value: { config, locale: initialLocale, messages, handl
     // Locale transition
     // -----------------------------------------------------------------------------
     /** Request a locale change. */
-    const setLocale = React.useCallback(async (newLocale) => {
+    const setLocale = React.useCallback((newLocale) => {
         if (newLocale === locale)
             return;
         setLocaleState(newLocale);
-        onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
+        void 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 || messages || config.messages || {}, [config.messages, messages, runtimeMessages]);
+    const effectiveIsLoading = resolveEffectiveIsLoading(!!externalIsLoading, internalIsLoading);
+    const effectiveMessages = resolveEffectiveMessages(runtimeMessages, messages, config.messages);
     // -----------------------------------------------------------------------------
     // Translator
     // -----------------------------------------------------------------------------
+    const { loadingMessage, missingMessage } = config.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,
+            ...(loadingMessage !== undefined ? { loadingMessage } : {}),
+            ...(missingMessage !== undefined ? { missingMessage } : {}),
+            ...(handlers !== undefined ? { handlers } : {}),
+            ...(hooks !== undefined ? { hooks } : {}),
         });
     }, [
         effectiveMessages,
         locale,
         effectiveIsLoading,
-        config,
+        config.fallbackLocales,
+        loadingMessage,
+        missingMessage,
         handlers,
-        plugins,
+        hooks,
     ]);
     // ---------------------------------------------------------------------------
     // Side effects

package/dist/react/src/client/react/translator/create-t-rich.js

@@ -1,5 +1,5 @@
-import { jsx, Fragment } from 'react/jsx-runtime';
 import { renderRichMessage } from 'intor-translator';
+import * as React from 'react';
 import { createReactRenderer } from '../render/create-react-renderer.js';
 
 /**
@@ -19,7 +19,11 @@ const createTRich = (t) => {
         const message = t(key, replacements);
         const reactRenderer = createReactRenderer(tagRenderers);
         const nodes = renderRichMessage(message, reactRenderer);
-        return nodes.map((node, index) => jsx(Fragment, { children: node }, index));
+        if (!Array.isArray(nodes))
+            return nodes;
+        return nodes.map((node, i) => React.isValidElement(node) && node.key == null
+            ? React.cloneElement(node, { key: i })
+            : node);
     };
 };
 

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

@@ -5,7 +5,7 @@ import { createTRich } from './create-t-rich.js';
 /**
  * React hook for accessing the active, scope-aware translator instance.
  *
- * @platform React
+ * @public
  */
 function useTranslator(preKey) {
     const { translator, setLocale } = useIntorContext();

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

@@ -1,4 +1,3 @@
-import '../../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../../core/utils/resolve-loader-options.js';
 import 'logry';
 import { loadRemoteMessages } from '../../../core/messages/load-remote-messages/load-remote-messages.js';
@@ -20,6 +19,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
         const loader = resolveLoaderOptions(config);
         if (!loader || loader.mode !== "remote")
             return;
+        const { namespaces, concurrency, url, headers } = loader;
         // Abort previous request
         controller?.abort();
         const currentController = new AbortController();
@@ -29,11 +29,11 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
             const loadedMessages = await loadRemoteMessages({
                 locale: newLocale,
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
-                namespaces: loader.namespaces,
-                concurrency: loader.concurrency,
+                ...(namespaces !== undefined ? { namespaces } : {}),
+                ...(concurrency !== undefined ? { concurrency } : {}),
                 fetch: globalThis.fetch,
-                url: loader.url,
-                headers: loader.headers,
+                url,
+                ...(headers !== undefined ? { headers } : {}),
                 signal: currentController.signal,
                 loggerOptions: config.logger,
             });

package/dist/react/src/client/shared/provider/effective-state.js

@@ -0,0 +1,12 @@
+// runtime > external > config
+// Always resolves to a non-null message object.
+function resolveEffectiveMessages(runtime, external, configMessages) {
+    return runtime ?? external ?? configMessages ?? {};
+}
+// external > internal
+// Loading is active if either source is truthy
+function resolveEffectiveIsLoading(external, internal) {
+    return !!external || internal;
+}
+
+export { resolveEffectiveIsLoading, resolveEffectiveMessages };

package/dist/react/src/client/shared/utils/build-cookie-string.js

@@ -6,7 +6,7 @@ const buildCookieString = (cookieOptions, value) => {
     // Cookie name and encoded value
     const parts = [`${name}=${encodeURIComponent(value)}`];
     // Add expiration and max-age if provided
-    if (maxAge) {
+    if (maxAge !== undefined) {
         const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
         parts.push(`expires=${expires}`, `max-age=${maxAge}`);
     }
@@ -18,7 +18,8 @@ const buildCookieString = (cookieOptions, value) => {
     }
     // Add SameSite policy (e.g., Lax, Strict)
     if (sameSite) {
-        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+        const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
+        parts.push(`SameSite=${normalized}`);
     }
     // Add Secure flag if not explicitly disabled
     if (secure !== false) {

package/dist/react/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/react/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");