intor 2.4.17 → 2.5.1

package/dist/next/src/routing/outbound/utils/is-external-destination.js

@@ -1,11 +1,5 @@
-/**
- * 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);
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(destination);
 };
 
 export { isExternalDestination };

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

@@ -1,47 +1,36 @@
 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.
- *
- * Accepts `{locale}` as a locale placeholder segment.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en-US/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 = "/";
+  const { routing, supportedLocales } = config;
+  const normalizedPathname = normalizePathname(rawPathname);
+  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);
     }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
-    }
-    // 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;
+  }
+  if (path === "/") return "/";
+  const segmentStart = 1;
+  const nextSlash = path.indexOf("/", segmentStart);
+  const firstSegment = nextSlash === -1 ? path.slice(segmentStart) : path.slice(segmentStart, nextSlash);
+  let localeLength;
+  if (firstSegment === LOCALE_PLACEHOLDER) {
+    localeLength = firstSegment.length;
+  } else if (supportedLocales.includes(firstSegment)) {
+    localeLength = firstSegment.length;
+  }
+  if (localeLength !== void 0) {
+    const stripped = path.slice(localeLength + 1);
+    return stripped || "/";
+  }
+  return path;
 }
 
 export { canonicalizePathname };

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

@@ -2,35 +2,19 @@ import { canonicalizePathname } from './canonicalize-pathname.js';
 import { materializePathname } from './materialize-pathname.js';
 import { standardizePathname } from './standardize-pathname.js';
 
-/**
- * Localizes a pathname by composing canonicalization,
- * standardization, and locale prefix strategies.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * localizePathname("/app/en-US/about", config, "en-US");
- * // => {
- * //   pathname: '/app/en-US/about'
- * //   unprefixedPathname: '/about',
- * //   templatedPathname: '/app/{locale}/about',
- * // }
- * ```
- */
 const localizePathname = (rawPathname, config, locale) => {
-    // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalized = canonicalizePathname(rawPathname, config);
-    // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardized = standardizePathname(canonicalized, config);
-    // 3. Materialize: apply routing rules to produce the final pathname
-    const materialized = materializePathname(standardized, config, locale);
-    return {
-        pathname: materialized,
-        unprefixedPathname: canonicalized,
-        templatedPathname: standardized,
-    };
+  const canonicalPathname = canonicalizePathname(rawPathname, config);
+  const standardizedPathname = standardizePathname(canonicalPathname, config);
+  const materializedPathname = materializePathname(
+    standardizedPathname,
+    config,
+    locale
+  );
+  return {
+    canonicalPathname,
+    templatedPathname: standardizedPathname,
+    pathname: materializedPathname
+  };
 };
 
 export { localizePathname };

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

@@ -1,42 +1,18 @@
 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.
- *
- * @example
- * ```ts
- * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/en-US/about
- *
- * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /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"');
-    }
-    // localePrefix: "all"
-    if (localePrefix === "all") {
-        return normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // 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}`, ""));
+  const { localePrefix } = config.routing;
+  const removeLocale = () => {
+    const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+    return result === "" ? "/" : result;
+  };
+  const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+  if (localePrefix === "none") return removeLocale();
+  if (localePrefix === "all") return injectLocale();
+  return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };

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

@@ -1,34 +1,15 @@
 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.
- *
- * @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,43 +1,32 @@
 import * as React from 'react';
-import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
+import { getClientLocale } from 'intor';
 
 function useIntor(config, loader) {
-    // ---------------------------------------------------------------------------
-    // Initial locale
-    // ---------------------------------------------------------------------------
-    const locale = React.useMemo(() => getClientLocale(config), [config]);
-    // ---------------------------------------------------------------------------
-    // State
-    // ---------------------------------------------------------------------------
-    const [messages, setMessages] = React.useState(config.messages || {});
-    const [isLoading, setIsLoading] = React.useState(true);
-    const activeLocaleRef = React.useRef(locale);
-    // ---------------------------------------------------------------------------
-    // Locale change handler
-    // ---------------------------------------------------------------------------
-    const onLocaleChange = React.useCallback(async (newLocale) => {
-        activeLocaleRef.current = newLocale;
-        setIsLoading(true);
-        const loaded = await loader(config, newLocale);
-        // Ignore outdated results when locale changes again.
-        if (activeLocaleRef.current !== newLocale)
-            return;
-        setMessages(loaded);
-        setIsLoading(false);
-    }, [config, loader]);
-    // ---------------------------------------------------------------------------
-    // Initial load
-    // ---------------------------------------------------------------------------
-    React.useEffect(() => {
-        onLocaleChange(locale);
-    }, [locale, onLocaleChange]);
-    return {
-        config,
-        locale,
-        messages,
-        isLoading,
-        onLocaleChange,
-    };
+  const locale = React.useMemo(() => getClientLocale(config), [config]);
+  const [messages, setMessages] = React.useState(config.messages || {});
+  const [isLoading, setIsLoading] = React.useState(true);
+  const activeLocaleRef = React.useRef(locale);
+  const onLocaleChange = React.useCallback(
+    async (newLocale) => {
+      activeLocaleRef.current = newLocale;
+      setIsLoading(true);
+      const loaded = await loader(config, newLocale);
+      if (activeLocaleRef.current !== newLocale) return;
+      setMessages(loaded);
+      setIsLoading(false);
+    },
+    [config, loader]
+  );
+  React.useEffect(() => {
+    void onLocaleChange(locale);
+  }, [locale, onLocaleChange]);
+  return {
+    config,
+    locale,
+    messages,
+    isLoading,
+    onLocaleChange
+  };
 }
 
 export { useIntor };

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';
@@ -10,31 +9,26 @@ import { setLocaleCookie } from '../../../shared/utils/locale/set-locale-cookie.
 import { setDocumentLocale } from '../../../shared/utils/locale/set-document-locale.js';
 
 function useLocaleEffects(config, locale) {
-    const { cookie, routing } = config;
-    const isFirstSyncRef = React.useRef(true);
-    React.useEffect(() => {
-        // Always sync document language
-        setDocumentLocale(locale);
-        // -----------------------------------------------------------------------
-        // First sync (initial mount / hydration)
-        // -----------------------------------------------------------------------
-        if (isFirstSyncRef.current) {
-            isFirstSyncRef.current = false;
-            const localeCookie = getLocaleFromCookie(cookie.name);
-            const isFirstVisit = !localeCookie;
-            if (shouldPersistOnFirstVisit(isFirstVisit, routing.inbound.firstVisit.persist) &&
-                cookie.persist) {
-                setLocaleCookie(cookie, locale);
-            }
-            return;
-        }
-        // -----------------------------------------------------------------------
-        // Subsequent locale changes (user-driven)
-        // -----------------------------------------------------------------------
-        if (cookie.persist) {
-            setLocaleCookie(cookie, locale);
-        }
-    }, [locale, cookie, routing.inbound.firstVisit.persist]);
+  const { cookie, routing } = config;
+  const isFirstSyncRef = React.useRef(true);
+  React.useEffect(() => {
+    setDocumentLocale(locale);
+    if (isFirstSyncRef.current) {
+      isFirstSyncRef.current = false;
+      const localeCookie = getLocaleFromCookie(cookie.name);
+      const isFirstVisit = !localeCookie;
+      if (shouldPersistOnFirstVisit(
+        isFirstVisit,
+        routing.inbound.firstVisit.persist
+      ) && cookie.persist) {
+        setLocaleCookie(cookie, locale);
+      }
+      return;
+    }
+    if (cookie.persist) {
+      setLocaleCookie(cookie, locale);
+    }
+  }, [locale, cookie, routing.inbound.firstVisit.persist]);
 }
 
 export { useLocaleEffects };

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

@@ -3,22 +3,23 @@ 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]);
+  const refetchMessages = React.useMemo(
+    () => createRefetchMessages({
+      config,
+      onLoadingStart: () => setInternalIsLoading(true),
+      onLoadingEnd: () => setInternalIsLoading(false),
+      onMessages: setRuntimeMessages
+    }),
+    [config, setRuntimeMessages, setInternalIsLoading]
+  );
+  const isInitialRenderRef = React.useRef(true);
+  React.useEffect(() => {
+    if (isInitialRenderRef.current) {
+      isInitialRenderRef.current = false;
+      return;
+    }
+    void refetchMessages(locale);
+  }, [refetchMessages, locale]);
 }
 
 export { useMessagesEffects };

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

@@ -1,69 +1,73 @@
 "use client";
-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, }) {
-    // -----------------------------------------------------------------------------
-    // 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 || messages || config.messages || {}, [config.messages, messages, 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);
-    // Sync internal locale with external prop
-    React.useEffect(() => {
-        if (initialLocale !== locale)
-            setLocaleState(initialLocale);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [initialLocale]);
-    return (jsx(IntorContext.Provider, { value: { config, locale, setLocale, translator }, children: children }));
+const IntorContext = React.createContext(
+  void 0
+);
+function IntorProvider({
+  value: {
+    config,
+    locale: initialLocale,
+    messages,
+    handlers,
+    hooks,
+    onLocaleChange,
+    isLoading: externalIsLoading
+  },
+  children
+}) {
+  const [locale, setLocaleState] = React.useState(initialLocale);
+  const [runtimeMessages, setRuntimeMessages] = React.useState(null);
+  const [internalIsLoading, setInternalIsLoading] = React.useState(false);
+  const setLocale = React.useCallback(
+    (newLocale) => {
+      if (newLocale === locale) return;
+      setLocaleState(newLocale);
+      void onLocaleChange?.(newLocale);
+    },
+    [locale, onLocaleChange]
+  );
+  const effectiveIsLoading = resolveEffectiveIsLoading(
+    !!externalIsLoading,
+    internalIsLoading
+  );
+  const effectiveMessages = resolveEffectiveMessages(
+    runtimeMessages,
+    messages,
+    config.messages
+  );
+  const { loadingMessage, missingMessage } = config.translator ?? {};
+  const translator = React.useMemo(() => {
+    return new Translator({
+      messages: effectiveMessages,
+      locale,
+      isLoading: effectiveIsLoading,
+      fallbackLocales: config.fallbackLocales,
+      ...loadingMessage !== void 0 ? { loadingMessage } : {},
+      ...missingMessage !== void 0 ? { missingMessage } : {},
+      ...handlers !== void 0 ? { handlers } : {},
+      ...hooks !== void 0 ? { hooks } : {}
+    });
+  }, [
+    effectiveMessages,
+    locale,
+    effectiveIsLoading,
+    config.fallbackLocales,
+    loadingMessage,
+    missingMessage,
+    handlers,
+    hooks
+  ]);
+  useLocaleEffects(config, locale);
+  useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoading);
+  React.useEffect(() => {
+    if (initialLocale !== locale) setLocaleState(initialLocale);
+  }, [initialLocale]);
+  return /* @__PURE__ */ React.createElement(IntorContext.Provider, { value: { config, locale, setLocale, translator } }, children);
 }
 
 export { IntorContext, IntorProvider };

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

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

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

@@ -1,30 +1,24 @@
 import * as React from 'react';
 
-/**
- * Create a React renderer for semantic rich messages.
- */
 const createReactRenderer = (tagRenderers) => {
-    return {
-        /** Render plain text nodes */
-        text(value) {
-            return value;
-        },
-        /** Render semantic tag nodes */
-        tag(name, _attributes, children) {
-            const tagRenderer = tagRenderers?.[name];
-            if (tagRenderer) {
-                return typeof tagRenderer === "function"
-                    ? tagRenderer(children)
-                    : tagRenderer;
-            }
-            // Default behavior: render as a native React element
-            return React.createElement(name, null, ...children);
-        },
-        /** Render raw (non-tokenized) message values */
-        raw(value) {
-            return value;
-        },
-    };
+  return {
+    /** Render plain text nodes */
+    text(value) {
+      return value;
+    },
+    /** Render semantic tag nodes */
+    tag(name, _attributes, children) {
+      const tagRenderer = tagRenderers?.[name];
+      if (tagRenderer) {
+        return typeof tagRenderer === "function" ? tagRenderer(children) : tagRenderer;
+      }
+      return React.createElement(name, null, ...children);
+    },
+    /** Render raw (non-tokenized) message values */
+    raw(value) {
+      return value;
+    }
+  };
 };
 
 export { createReactRenderer };