intor 2.4.17 → 2.5.1

package/dist/next/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.js

@@ -1,42 +0,0 @@
-import path from 'node:path';
-import { collectFileEntries } from './collect-file-entries/collect-file-entries.js';
-import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
-
-/**
- * Read and assemble messages for a single locale from the file system.
- *
- * This function acts as a thin orchestration layer:
- * - Collects message file metadata for the locale
- * - Parses files into a single Messages object
- * - Wraps the result under the locale key
- *
- * It does not perform validation or transformation itself.
- */
-const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, readers, loggerOptions, }) => {
-    // ---------------------------------------------------------------------------
-    // Collect message file entries for the locale
-    // ---------------------------------------------------------------------------
-    const fileEntries = await collectFileEntries({
-        namespaces,
-        rootDir: path.resolve(rootDir, locale),
-        limit,
-        exts: Object.keys(readers || {}),
-        loggerOptions,
-    });
-    // ---------------------------------------------------------------------------
-    // Parse collected files into a Messages object (single-locale)
-    // ---------------------------------------------------------------------------
-    const messages = await parseFileEntries({
-        fileEntries,
-        limit,
-        readers,
-        loggerOptions,
-    });
-    // ---------------------------------------------------------------------------
-    // Wrap parsed messages under the locale key
-    // ---------------------------------------------------------------------------
-    const localeMessages = { [locale]: messages };
-    return localeMessages;
-};
-
-export { readLocaleMessages };

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

@@ -1,78 +0,0 @@
-import '../../core/error/intor-error.js';
-import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
-import { getLogger } from '../../core/logger/get-logger.js';
-import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
-import 'intor-translator';
-import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
-
-/**
- * Load locale messages according to the resolved Intor loader configuration.
- *
- * This function is the top-level orchestration entry for message loading.
- * It is responsible for:
- *
- * - Resolving the active loader strategy (local or remote)
- * - Dispatching to the appropriate loader implementation
- * - Passing through cache and read-related options
- *
- * Message traversal, parsing, fallback resolution, and caching logic
- * are delegated to the selected loader.
- */
-const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
-    const baseLogger = getLogger(config.logger);
-    const logger = baseLogger.child({ scope: "load-messages" });
-    // ---------------------------------------------------------------------------
-    // Resolve loader configuration
-    // ---------------------------------------------------------------------------
-    const loader = resolveLoaderOptions(config, "server");
-    if (!loader) {
-        logger.warn("No loader options have been configured in the current config.");
-        return;
-    }
-    const { mode, namespaces, concurrency } = loader;
-    const fallbackLocales = config.fallbackLocales[locale] || [];
-    logger.info(`Loading messages for locale "${locale}".`);
-    logger.trace("Starting to load messages with runtime context.", {
-        loaderMode: mode,
-        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
-        locale,
-        fallbackLocales: fallbackLocales.join(", "),
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
-    });
-    // ---------------------------------------------------------------------------
-    // Dispatch to loader implementation
-    // ---------------------------------------------------------------------------
-    let loadedMessages;
-    if (mode === "local") {
-        loadedMessages = await loadLocalMessages({
-            id: config.id,
-            locale,
-            fallbackLocales,
-            namespaces,
-            rootDir: loader.rootDir,
-            concurrency,
-            readers,
-            allowCacheWrite,
-            loggerOptions: config.logger,
-        });
-    }
-    else if (mode === "remote") {
-        loadedMessages = await loadRemoteMessages({
-            locale,
-            fallbackLocales,
-            namespaces,
-            concurrency,
-            fetch,
-            url: loader.url,
-            headers: loader.headers,
-            loggerOptions: config.logger,
-        });
-    }
-    // Final sanity check
-    if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
-        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
-    }
-    return loadedMessages;
-};
-
-export { loadMessages };

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

@@ -1,39 +0,0 @@
-import '../../core/error/intor-error.js';
-import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
-import 'logry';
-import 'p-limit';
-import { createTranslator } from '../../core/translator/create-translator.js';
-import 'intor-translator';
-import { loadMessages } from '../messages/load-messages.js';
-import 'node:path';
-import 'node:fs/promises';
-
-/**
- * Initialize a locale-bound Translator snapshot.
- *
- * - Resolves loader options and loads messages if configured
- * - Creates an immutable Translator instance for server usage
- */
-async function initTranslator(config, locale, options) {
-    const { loader, readers, allowCacheWrite = false, fetch, handlers, plugins, } = options;
-    const loaderOptions = resolveLoaderOptions(config, "server");
-    // Load messages
-    let messages = {};
-    if (loaderOptions && !loader) {
-        const loaded = await loadMessages({
-            config,
-            locale,
-            readers,
-            allowCacheWrite,
-            fetch,
-        });
-        messages = loaded || {};
-    }
-    if (loader) {
-        messages = await loader(config, locale);
-    }
-    // Create immutable translator snapshot
-    return createTranslator({ config, locale, messages, handlers, plugins });
-}
-
-export { initTranslator };

package/dist/react/src/client/react/translator/trans.js

@@ -1,15 +0,0 @@
-import { jsx, Fragment } from 'react/jsx-runtime';
-import { useTranslator } from './use-translator.js';
-
-/**
- * `<Trans />` is a lightweight React component for rendering rich translations.
- *
- * It is a thin adapter around `translator.tRich` and introduces no additional logic.
- */
-function Trans(props) {
-    const { i18nKey, components, values } = props;
-    const { tRich } = useTranslator();
-    return jsx(Fragment, { children: tRich(i18nKey, components, values) });
-}
-
-export { Trans };

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

@@ -1,22 +0,0 @@
-import '../../../core/error/intor-error.js';
-import { matchLocale } from '../../../core/locale/match-locale.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import { detectBrowserLocale } from '../utils/locale/detect-browser-locale.js';
-import { getLocaleFromCookie } from '../utils/locale/get-locale-from-cookie.js';
-
-/**
- * Resolve the active locale in a pure client-side environment.
- */
-function getClientLocale(config) {
-    const { defaultLocale, supportedLocales, cookie } = config;
-    // Locale from browser cookie
-    const cookieLocale = getLocaleFromCookie(cookie.name);
-    // Locale from browser preference
-    const browserLocale = detectBrowserLocale();
-    const localeCandidate = cookieLocale || browserLocale;
-    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
-}
-
-export { getClientLocale };

package/dist/react/src/client/shared/utils/locale/detect-browser-locale.js

@@ -1,12 +0,0 @@
-/**
- * Detect the preferred locale from the browser.
- *
- * This function relies on `navigator.languages` and `navigator.language`.
- */
-function detectBrowserLocale() {
-    if (typeof navigator === "undefined")
-        return undefined;
-    return navigator.languages?.[0] || navigator.language || undefined;
-}
-
-export { detectBrowserLocale };

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

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

package/dist/react/src/core/locale/canonicalize-locale.js

@@ -1,23 +0,0 @@
-/**
- * Canonicalizes a BCP 47 locale string.
- *
- * - Uses `Intl.getCanonicalLocales` when available.
- * - Returns the original input if `Intl` is unavailable.
- * - Returns `undefined` for invalid locale input.
- *
- * This function performs normalization only.
- * It does not perform matching or fallback.
- */
-function canonicalizeLocale(input) {
-    try {
-        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
-            return input;
-        }
-        return Intl.getCanonicalLocales(input)[0];
-    }
-    catch {
-        return;
-    }
-}
-
-export { canonicalizeLocale };

package/dist/react/src/core/locale/match-locale.js

@@ -1,57 +0,0 @@
-import { canonicalizeLocale } from './canonicalize-locale.js';
-import { parseLocale } from './parse-locale.js';
-
-/**
- * Matches a locale candidate against a list of supported locales.
- *
- * Resolution order:
- * 1. Exact canonical match
- * 2. Same language + same script
- * 3. Same language only (only if candidate has no script)
- *
- * Returns `undefined` if no match is found.
- *
- * Notes:
- * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to default locale.
- * - Does not cross script boundaries.
- */
-function matchLocale(locale, supportedLocales = []) {
-    if (!locale || supportedLocales.length === 0)
-        return;
-    const canonicalCandidate = canonicalizeLocale(locale);
-    if (!canonicalCandidate)
-        return;
-    const candidateParts = parseLocale(canonicalCandidate);
-    const supportedCanonical = supportedLocales.flatMap((original) => {
-        const canonical = canonicalizeLocale(original);
-        if (!canonical)
-            return [];
-        return [{ original, canonical, parts: parseLocale(canonical) }];
-    });
-    // 1. Exact match
-    for (const s of supportedCanonical) {
-        if (s.canonical === canonicalCandidate) {
-            return s.original;
-        }
-    }
-    // 2. Same language + same script
-    if (candidateParts.script) {
-        for (const s of supportedCanonical) {
-            if (s.parts.language === candidateParts.language &&
-                s.parts.script === candidateParts.script) {
-                return s.original;
-            }
-        }
-        return;
-    }
-    // 3. Same language only
-    for (const s of supportedCanonical) {
-        if (s.parts.language === candidateParts.language) {
-            return s.original;
-        }
-    }
-    return;
-}
-
-export { matchLocale };

package/dist/react/src/core/locale/parse-locale.js

@@ -1,27 +0,0 @@
-/**
- * Parses a canonical locale tag into structural components.
- *
- * - Uses `Intl.Locale` when available.
- * - Falls back to minimal parsing (language only) if unavailable.
- *
- * This function does not validate or match locales.
- */
-function parseLocale(tag) {
-    try {
-        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
-            const locale = new Intl.Locale(tag);
-            return {
-                language: locale.language,
-                script: locale.script,
-                region: locale.region,
-            };
-        }
-    }
-    catch {
-        // fallback below
-    }
-    const parts = tag.split("-");
-    return { language: parts[0].toLowerCase() };
-}
-
-export { parseLocale };

package/dist/svelte/src/client/shared/helpers/get-client-locale.js

@@ -1,22 +0,0 @@
-import '../../../core/error/intor-error.js';
-import { matchLocale } from '../../../core/locale/match-locale.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import { detectBrowserLocale } from '../utils/locale/detect-browser-locale.js';
-import { getLocaleFromCookie } from '../utils/locale/get-locale-from-cookie.js';
-
-/**
- * Resolve the active locale in a pure client-side environment.
- */
-function getClientLocale(config) {
-    const { defaultLocale, supportedLocales, cookie } = config;
-    // Locale from browser cookie
-    const cookieLocale = getLocaleFromCookie(cookie.name);
-    // Locale from browser preference
-    const browserLocale = detectBrowserLocale();
-    const localeCandidate = cookieLocale || browserLocale;
-    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
-}
-
-export { getClientLocale };

package/dist/svelte/src/client/shared/utils/locale/detect-browser-locale.js

@@ -1,12 +0,0 @@
-/**
- * Detect the preferred locale from the browser.
- *
- * This function relies on `navigator.languages` and `navigator.language`.
- */
-function detectBrowserLocale() {
-    if (typeof navigator === "undefined")
-        return undefined;
-    return navigator.languages?.[0] || navigator.language || undefined;
-}
-
-export { detectBrowserLocale };

package/dist/svelte/src/client/svelte/provider/effects/locale-effects.js

@@ -1,38 +0,0 @@
-import { shouldPersistOnFirstVisit } from '../../../../policies/should-persist-on-first-visit.js';
-import '../../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import { getLocaleFromCookie } from '../../../shared/utils/locale/get-locale-from-cookie.js';
-import { setLocaleCookie } from '../../../shared/utils/locale/set-locale-cookie.js';
-import { setDocumentLocale } from '../../../shared/utils/locale/set-document-locale.js';
-
-function attachLocaleEffects(locale, config) {
-    const { cookie, routing } = config;
-    let isFirstSync = true;
-    return locale.subscribe((currentLocale) => {
-        // Always sync document language
-        setDocumentLocale(currentLocale);
-        // -------------------------------------------------------------
-        // First sync (initial mount / hydration)
-        // -------------------------------------------------------------
-        if (isFirstSync) {
-            isFirstSync = false;
-            const localeCookie = getLocaleFromCookie(cookie.name);
-            const isFirstVisit = !localeCookie;
-            if (shouldPersistOnFirstVisit(isFirstVisit, routing.inbound.firstVisit.persist) &&
-                cookie.persist) {
-                setLocaleCookie(cookie, currentLocale);
-            }
-            return;
-        }
-        // -------------------------------------------------------------
-        // Subsequent locale changes (user-driven)
-        // -------------------------------------------------------------
-        if (cookie.persist) {
-            setLocaleCookie(cookie, currentLocale);
-        }
-    });
-}
-
-export { attachLocaleEffects };

package/dist/svelte/src/client/svelte/provider/effects/messages-effects.js

@@ -1,23 +0,0 @@
-import { createRefetchMessages } from '../../../shared/messages/create-refetch-messages.js';
-
-function attachMessagesEffects({ locale, config, runtimeMessages, internalIsLoading, }) {
-    // Prepares message refetch function.
-    const refetchMessages = createRefetchMessages({
-        config,
-        onLoadingStart: () => internalIsLoading.set(true),
-        onLoadingEnd: () => internalIsLoading.set(false),
-        onMessages: (messages) => runtimeMessages.set(messages),
-    });
-    // Refetch messages when locale changes (except initial render).
-    let isInitial = true;
-    const unsubscribe = locale.subscribe((value) => {
-        if (isInitial) {
-            isInitial = false;
-            return;
-        }
-        refetchMessages(value);
-    });
-    return unsubscribe;
-}
-
-export { attachMessagesEffects };

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

@@ -1,11 +0,0 @@
-import { getContext } from 'svelte';
-import { INTOR_CONTEXT_KEY } from './create-intor-store.js';
-
-function useIntorContext() {
-    const context = getContext(INTOR_CONTEXT_KEY);
-    if (!context)
-        throw new Error("useIntorContext must be used within IntorProvider");
-    return context;
-}
-
-export { useIntorContext };

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

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

package/dist/svelte/src/core/locale/canonicalize-locale.js

@@ -1,23 +0,0 @@
-/**
- * Canonicalizes a BCP 47 locale string.
- *
- * - Uses `Intl.getCanonicalLocales` when available.
- * - Returns the original input if `Intl` is unavailable.
- * - Returns `undefined` for invalid locale input.
- *
- * This function performs normalization only.
- * It does not perform matching or fallback.
- */
-function canonicalizeLocale(input) {
-    try {
-        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
-            return input;
-        }
-        return Intl.getCanonicalLocales(input)[0];
-    }
-    catch {
-        return;
-    }
-}
-
-export { canonicalizeLocale };

package/dist/svelte/src/core/locale/match-locale.js

@@ -1,57 +0,0 @@
-import { canonicalizeLocale } from './canonicalize-locale.js';
-import { parseLocale } from './parse-locale.js';
-
-/**
- * Matches a locale candidate against a list of supported locales.
- *
- * Resolution order:
- * 1. Exact canonical match
- * 2. Same language + same script
- * 3. Same language only (only if candidate has no script)
- *
- * Returns `undefined` if no match is found.
- *
- * Notes:
- * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to default locale.
- * - Does not cross script boundaries.
- */
-function matchLocale(locale, supportedLocales = []) {
-    if (!locale || supportedLocales.length === 0)
-        return;
-    const canonicalCandidate = canonicalizeLocale(locale);
-    if (!canonicalCandidate)
-        return;
-    const candidateParts = parseLocale(canonicalCandidate);
-    const supportedCanonical = supportedLocales.flatMap((original) => {
-        const canonical = canonicalizeLocale(original);
-        if (!canonical)
-            return [];
-        return [{ original, canonical, parts: parseLocale(canonical) }];
-    });
-    // 1. Exact match
-    for (const s of supportedCanonical) {
-        if (s.canonical === canonicalCandidate) {
-            return s.original;
-        }
-    }
-    // 2. Same language + same script
-    if (candidateParts.script) {
-        for (const s of supportedCanonical) {
-            if (s.parts.language === candidateParts.language &&
-                s.parts.script === candidateParts.script) {
-                return s.original;
-            }
-        }
-        return;
-    }
-    // 3. Same language only
-    for (const s of supportedCanonical) {
-        if (s.parts.language === candidateParts.language) {
-            return s.original;
-        }
-    }
-    return;
-}
-
-export { matchLocale };

package/dist/svelte/src/core/locale/parse-locale.js

@@ -1,27 +0,0 @@
-/**
- * Parses a canonical locale tag into structural components.
- *
- * - Uses `Intl.Locale` when available.
- * - Falls back to minimal parsing (language only) if unavailable.
- *
- * This function does not validate or match locales.
- */
-function parseLocale(tag) {
-    try {
-        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
-            const locale = new Intl.Locale(tag);
-            return {
-                language: locale.language,
-                script: locale.script,
-                region: locale.region,
-            };
-        }
-    }
-    catch {
-        // fallback below
-    }
-    const parts = tag.split("-");
-    return { language: parts[0].toLowerCase() };
-}
-
-export { parseLocale };

package/dist/svelte-kit/src/core/error/intor-error.js

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

package/dist/svelte-kit/src/routing/inbound/resolve-path/resolve-path.js

@@ -1,42 +0,0 @@
-import { localizePathname } from '../../pathname/localize-pathname.js';
-import { all } from './strategies/all.js';
-import { exceptDefault } from './strategies/except-default.js';
-import { none } from './strategies/none.js';
-
-const assertNever = (x) => {
-    throw new Error(`Unhandled prefix strategy: ${x}`);
-};
-/**
- * Resolves the canonical pathname based on locale prefix behavior.
- *
- * The resolved pathname represents the final, normalized form
- * used for routing and navigation.
- */
-const resolvePath = (config, rawPathname, context) => {
-    const { localePrefix } = config.routing;
-    let directive;
-    switch (localePrefix) {
-        case "all": {
-            directive = all(config, context);
-            break;
-        }
-        case "except-default": {
-            directive = exceptDefault(config, context);
-            break;
-        }
-        case "none": {
-            directive = none();
-            break;
-        }
-        default: {
-            return assertNever(localePrefix);
-        }
-    }
-    const { pathname } = localizePathname(rawPathname, config, context.locale);
-    return {
-        pathname,
-        shouldRedirect: directive.type === "redirect",
-    };
-};
-
-export { resolvePath };

package/dist/svelte-kit/src/routing/inbound/resolve-path/strategies/all.js

@@ -1,28 +0,0 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "all".
- */
-function all(config, context) {
-    const { hasPathLocale, hasPersisted} = context;
-    const { redirect } = config.routing.inbound.firstVisit;
-    const isFirstVisit = !hasPersisted;
-    // ----------------------------------------------------------
-    // URL already canonical
-    // ----------------------------------------------------------
-    if (hasPathLocale) {
-        return { type: "pass" };
-    }
-    // ----------------------------------------------------------
-    // Apply first-visit redirect policy
-    // ----------------------------------------------------------
-    if (isFirstVisit) {
-        if (!redirect)
-            return { type: "pass" };
-        return { type: "redirect" };
-    }
-    // ----------------------------------------------------------
-    // Redirect to the locale-prefixed URL
-    // ----------------------------------------------------------
-    return { type: "redirect" };
-}
-
-export { all };