intor 2.5.0 → 2.6.0

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

@@ -2,37 +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'
- * //   canonicalPathname: '/about',
- * //   templatedPathname: '/app/{locale}/about',
- * // }
- * ```
- *
- * @public
- */
 const localizePathname = (rawPathname, config, locale) => {
-    // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalPathname = canonicalizePathname(rawPathname, config);
-    // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardizedPathname = standardizePathname(canonicalPathname, config);
-    // 3. Materialize: apply routing rules to produce the final pathname
-    const materializedPathname = materializePathname(standardizedPathname, config, locale);
-    return {
-        canonicalPathname,
-        templatedPathname: standardizedPathname,
-        pathname: materializedPathname,
-    };
+  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

@@ -3,51 +3,16 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * 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");
- * // => /app/en/about
- *
- * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en");
- * // => /app/about
- * ```
- */
 const materializePathname = (standardizedPathname, config, locale) => {
-    const { localePrefix } = config.routing;
-    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 injectLocale();
-    // localePrefix: "except-default"
-    return locale === config.defaultLocale ? removeLocale() : injectLocale();
+  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

@@ -3,37 +3,13 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * 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",
- * standardizePathname("/about", config);
- * // => "/app/{locale}/about"
- * ```
- */
 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}`;
+  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/src/client/react/helpers/use-intor.js

@@ -1,51 +1,32 @@
 import * as React from 'react';
 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
-    // ---------------------------------------------------------------------------
-    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(() => {
-        void 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

@@ -9,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;
-        }
-        void 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,76 +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);
-/**
- * React provider for Intor.
- *
- * @public
- */
-function IntorProvider({ value: { config, locale: initialLocale, messages, handlers, hooks, 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((newLocale) => {
-        if (newLocale === locale)
-            return;
-        setLocaleState(newLocale);
-        void onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
-    }, [locale, onLocaleChange]);
-    // -----------------------------------------------------------------------------
-    // Effective state
-    // -----------------------------------------------------------------------------
-    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 !== undefined ? { loadingMessage } : {}),
-            ...(missingMessage !== undefined ? { missingMessage } : {}),
-            ...(handlers !== undefined ? { handlers } : {}),
-            ...(hooks !== undefined ? { hooks } : {}),
-        });
-    }, [
-        effectiveMessages,
-        locale,
-        effectiveIsLoading,
-        config.fallbackLocales,
-        loadingMessage,
-        missingMessage,
-        handlers,
-        hooks,
-    ]);
-    // ---------------------------------------------------------------------------
-    // 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 };

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

@@ -2,29 +2,16 @@ import { renderRichMessage } from 'intor-translator';
 import * as React from 'react';
 import { createReactRenderer } from '../render/create-react-renderer.js';
 
-/**
- * Create a React-specific rich translation function.
- *
- * This adapter bridges the core Translator with the React rich
- * message rendering flow.
- *
- * - Resolves translated messages via `translator.t`
- * - Renders semantic tags using React renderers
- * - Supports optional scoped keys via `preKey`
- *
- * Intended for React client usage only.
- */
 const createTRich = (t) => {
-    return (key, tagRenderers, replacements) => {
-        const message = t(key, replacements);
-        const reactRenderer = createReactRenderer(tagRenderers);
-        const nodes = renderRichMessage(message, reactRenderer);
-        if (!Array.isArray(nodes))
-            return nodes;
-        return nodes.map((node, i) => React.isValidElement(node) && node.key == null
-            ? React.cloneElement(node, { key: i })
-            : node);
-    };
+  return (key, tagRenderers, replacements) => {
+    const message = t(key, replacements);
+    const reactRenderer = createReactRenderer(tagRenderers);
+    const nodes = renderRichMessage(message, reactRenderer);
+    if (!Array.isArray(nodes)) return nodes;
+    return nodes.map(
+      (node, i) => React.isValidElement(node) && node.key == null ? React.cloneElement(node, { key: i }) : node
+    );
+  };
 };
 
 export { createTRich };

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

@@ -2,23 +2,18 @@ import '../provider/intor-provider.js';
 import { useIntorContext } from '../provider/use-intor-context.js';
 import { createTRich } from './create-t-rich.js';
 
-/**
- * React hook for accessing the active, scope-aware translator instance.
- *
- * @public
- */
 function useTranslator(preKey) {
-    const { translator, setLocale } = useIntorContext();
-    const scoped = translator.scoped(preKey);
-    return {
-        messages: translator.messages,
-        locale: translator.locale,
-        isLoading: translator.isLoading,
-        setLocale,
-        hasKey: scoped.hasKey,
-        t: scoped.t,
-        tRich: createTRich(scoped.t),
-    };
+  const { translator, setLocale } = useIntorContext();
+  const scoped = translator.scoped(preKey);
+  return {
+    messages: translator.messages,
+    locale: translator.locale,
+    isLoading: translator.isLoading,
+    setLocale,
+    hasKey: scoped.hasKey,
+    t: scoped.t,
+    tRich: createTRich(scoped.t)
+  };
 }
 
 export { useTranslator };