@wildo-ai/saas-frontend-lib 1.0.1

package/dist/esm/core/i18n/I18nContext.js

@@ -0,0 +1,822 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useState, useEffect, useMemo, useRef, useCallback, useContext } from 'react';
+import { DirectionProvider } from '@radix-ui/react-direction';
+import { LOCAL_STORAGE_KEYS } from '../../core/commons/local-storage.frontend.schemas.js';
+import { LabellingTypes, AvailableLanguage, LANGUAGE_INFO_MAP, SYSTEM_ENUM_NAMES, DateFormat, TimeFormat, TextDirection, RegionalFormattingUtils, EAGER_I18N_SECTIONS, } from '@wildo-ai/presets-components-models';
+import { getManualCallsHttpClient } from '../../core/requests/wildo-http-client-manual-calls.frontend.service.js';
+import { MainContextInitComponents } from '../../core/runtime/runtime.frontend.schemas.js';
+import { useApplication } from '../../core/runtime/useApplication.js';
+import { ErrorContext } from '../../core/errors/ErrorContext.js';
+import { useEventBus } from '../../core/events/useEventBus.js';
+import { FrontendEvents } from '../../core/events/events.frontend.schemas.js';
+import { LoadingTier, AppLoadingIdentifier } from '../../core/loading/loading-types.frontend.schemas.js';
+import { envLoader } from '../../core/runtime/env-variable-loader.frontend.service.js';
+import { ActivationCriterionType } from '@wildo-ai/saas-models';
+import { AutomatedLayoutFrontendUtils } from '../../core/automated-layout/automated-layout.frontend.utils.js';
+export { TextDirection } from '@wildo-ai/presets-components-models';
+/**
+ * Convert a snake_case or kebab-case key to a human-readable display name.
+ * Used as fallback when a billing translation key has no i18n label.
+ * Example: 'ai_assistant' → 'Ai Assistant', 'max-projects' → 'Max Projects'
+ */
+function humanizeKey(key) {
+    return key
+        .replace(/[_-]+/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+/**
+ * I18n Context
+ * Exported for use in separate hook file (Fast Refresh compatibility)
+ * @internal - Use useI18n() hook instead of accessing this directly
+ */
+export const I18nContext = createContext(undefined);
+const allAvailableLanguages = Object.values(AvailableLanguage);
+const replayPendingLazyKeys = new Set();
+export const I18nProvider = ({ children }) => {
+    const isDebugging = false;
+    const { appConfig, markComponentInitialized, isInitialized: appIsInitialized, logger } = useApplication();
+    const errorContext = useContext(ErrorContext);
+    const { on, emit } = useEventBus();
+    // Extract language configuration from appConfig
+    // Note: allowOrganizationOverride is not consumed here because I18nProvider sits above
+    // UserOrgsProvider in the component tree. Org-level language enforcement would need to be
+    // handled via the USER_PREFERENCES_CHANGED event listener below.
+    const languageConfig = appConfig?.appPreferences?.languages;
+    const configDefaultLanguage = languageConfig?.defaultLanguage ?? AvailableLanguage.EN;
+    const configEnabledLanguages = languageConfig?.enabledLanguages ?? allAvailableLanguages;
+    const configAutoDetect = languageConfig?.autoDetectFromBrowser ?? true;
+    const configAllowUserOverride = languageConfig?.allowUserOverride ?? true;
+    const configEnableLanguageSwitcher = languageConfig?.enableLanguageSwitcher ?? true;
+    // TODO: implement fallback language loading — when a key is missing from the primary language,
+    // load translations from fallbackLanguage and merge them as a base layer.
+    // const configFallbackLanguage = languageConfig?.fallbackLanguage ?? AvailableLanguage.EN;
+    const [currentLanguage, setCurrentLanguage] = useState(configDefaultLanguage);
+    const currentLanguageRef = useRef(configDefaultLanguage);
+    const [translations, setTranslations] = useState({});
+    const [isLoading, setIsLoading] = useState(false);
+    // Preferences state (synced from UserOrgsContext via events)
+    const [languagePreferences, setLanguagePreferences] = useState(null);
+    const [regionalPreferences, setRegionalPreferences] = useState(null);
+    const logDebug = logger.debugByType('I18nContext');
+    logger.setDebugTypeLogging('I18nContext', isDebugging);
+    const reportError = useCallback((error, customMessage, additionalContext) => {
+        if (errorContext) {
+            errorContext.handleError(error, customMessage, additionalContext);
+            return;
+        }
+        logger.error(customMessage, {
+            originalError: error instanceof Error ? error.message : String(error),
+            ...additionalContext,
+        });
+    }, [errorContext, logger]);
+    // Guards to prevent duplicate API calls
+    const loadingLanguageRef = useRef(null);
+    const loadedLanguagesRef = useRef(new Set());
+    const isInitializedRef = useRef(false);
+    // --- Per-key lazy loading state ---
+    /** Keys that have been fetched and merged for the current language. */
+    const loadedKeysRef = useRef(new Set());
+    /**
+     * In-flight key requests: key path → Promise.
+     * Allows deduplication: if two components request the same key simultaneously,
+     * the second one joins the first's pending promise instead of firing a new API call.
+     */
+    const pendingKeysRef = useRef(new Map());
+    /**
+     * Micro-batch timer. Calls to `requestKeys` within this window are coalesced
+     * into a single API request to avoid per-component HTTP chatter.
+     */
+    const batchTimerRef = useRef(null);
+    const batchQueueRef = useRef([]);
+    /**
+     * Legacy flag — kept `false` to activate per-component lazy loading.
+     * With eager-core loading, `loadTranslations` only fetches `EAGER_I18N_SECTIONS`
+     * and marks each section individually in `loadedKeysRef`. The microbatch system
+     * handles all other sections via `requestKeys`.
+     * Reset on language change.
+     */
+    const fullLoadCompletedRef = useRef(false);
+    // Initialize language on mount (respects appConfig language preferences)
+    useEffect(() => {
+        const savedLanguage = localStorage.getItem(LOCAL_STORAGE_KEYS.LANGUAGE);
+        // Priority: saved preference → browser detection (if enabled) → config default → config fallback
+        let initialLanguage;
+        if (savedLanguage && isLanguageSupported(savedLanguage)) {
+            initialLanguage = savedLanguage;
+        }
+        else if (configAutoDetect) {
+            const browserLanguage = navigator.language.split('-')[0];
+            initialLanguage = isLanguageSupported(browserLanguage) ? browserLanguage : configDefaultLanguage;
+        }
+        else {
+            initialLanguage = configDefaultLanguage;
+        }
+        if (initialLanguage !== currentLanguage) {
+            setCurrentLanguage(initialLanguage);
+            currentLanguageRef.current = initialLanguage;
+        }
+        document.documentElement.lang = initialLanguage;
+    }, [configAutoDetect, configDefaultLanguage]);
+    // Load translations when app config is ready and language is set
+    useEffect(() => {
+        logDebug('useEffect triggered', { appIsInitialized, currentLanguage, isCurrentlyLoading: loadingLanguageRef.current, alreadyLoaded: loadedLanguagesRef.current.has(currentLanguage), isInitialized: isInitializedRef.current });
+        if (appIsInitialized && currentLanguage) {
+            logDebug(`Attempting to load translations for ${currentLanguage} (triggered by useEffect)`);
+            loadTranslations(currentLanguage);
+        }
+    }, [appIsInitialized, currentLanguage]);
+    // Cleanup batch timer and resolve dangling promises on unmount
+    useEffect(() => {
+        return () => {
+            if (batchTimerRef.current !== null) {
+                clearTimeout(batchTimerRef.current);
+                batchTimerRef.current = null;
+            }
+            batchQueueRef.current.forEach(b => b.resolve());
+            batchQueueRef.current = [];
+        };
+    }, []);
+    const getLanguageName = (language, native = true) => {
+        const languageInfo = LANGUAGE_INFO_MAP[language];
+        if (!languageInfo)
+            return language;
+        return native
+            ? languageInfo.nativeName
+            : languageInfo.name;
+    };
+    const isLanguageSupported = (language) => {
+        return configEnabledLanguages.includes(language);
+    };
+    const changeLanguage = async (language) => {
+        if (language === currentLanguage)
+            return;
+        if (!configAllowUserOverride) {
+            logDebug(`Language change blocked — allowUserOverride is disabled`);
+            return;
+        }
+        if (!isLanguageSupported(language)) {
+            logDebug(`Language change blocked — ${language} is not in enabledLanguages`);
+            return;
+        }
+        logDebug(`Language change requested: ${currentLanguage} → ${language}`);
+        if (batchTimerRef.current !== null) {
+            clearTimeout(batchTimerRef.current);
+            batchTimerRef.current = null;
+        }
+        batchQueueRef.current.forEach(b => b.resolve());
+        batchQueueRef.current = [];
+        loadedKeysRef.current.clear();
+        pendingKeysRef.current.clear();
+        fullLoadCompletedRef.current = false;
+        loadedLanguagesRef.current.clear();
+        setTranslations({});
+        currentLanguageRef.current = language;
+        setCurrentLanguage(language);
+        localStorage.setItem(LOCAL_STORAGE_KEYS.LANGUAGE, language);
+        document.documentElement.lang = language;
+    };
+    // Listen to preference changes from UserOrgsContext
+    useEffect(() => {
+        const unsubscribe = on(FrontendEvents.USER_PREFERENCES_CHANGED, (payload) => {
+            // Store language preferences
+            if (payload.languagePreferences) {
+                setLanguagePreferences(payload.languagePreferences);
+                // Apply language preference
+                if (payload.languagePreferences.primaryLanguage) {
+                    const preferredLanguage = payload.languagePreferences.primaryLanguage;
+                    logDebug('Applying language preference from UserOrgsContext event', { preferredLanguage });
+                    changeLanguage(preferredLanguage).catch((error) => {
+                        logger.warn('Failed to apply language preference from event', { preferredLanguage, error });
+                    });
+                }
+            }
+            // Store regional preferences
+            if (payload.regionalPreferences) {
+                setRegionalPreferences(payload.regionalPreferences);
+                logDebug('Regional preferences updated from UserOrgsContext event', {
+                    locale: payload.regionalPreferences.locale,
+                    timezone: payload.regionalPreferences.timezone,
+                });
+            }
+        });
+        return unsubscribe;
+    }, [on, changeLanguage, logDebug, logger]);
+    // Preference getters
+    const getLanguagePreferences = useCallback(() => {
+        return languagePreferences;
+    }, [languagePreferences]);
+    const getRegionalPreferences = useCallback(() => {
+        return regionalPreferences;
+    }, [regionalPreferences]);
+    // -------------------------------------------------------
+    // Per-key lazy loading
+    // -------------------------------------------------------
+    /**
+     * Deep-merge `source` into `target`, returning a new object.
+     * String leaves in `source` overwrite `target`; nested objects are merged recursively.
+     */
+    const deepMergeTranslations = (target, source) => {
+        const result = { ...target };
+        for (const key of Object.keys(source)) {
+            const sv = source[key];
+            const tv = result[key];
+            if (typeof sv === 'object' && sv !== null && typeof tv === 'object' && tv !== null) {
+                result[key] = deepMergeTranslations(tv, sv);
+            }
+            else {
+                result[key] = sv;
+            }
+        }
+        return result;
+    };
+    /**
+     * Check if a key is implicitly loaded because an ancestor key was already fetched.
+     * E.g. if `components.my_widget` is loaded, then `components.my_widget.label` is
+     * implicitly loaded (it's a sub-path of an already-fetched tree).
+     * Also: if `components` was loaded, then `components.my_widget` is implicitly loaded.
+     */
+    const isKeyImplicitlyLoaded = (key) => {
+        if (fullLoadCompletedRef.current)
+            return true;
+        if (loadedKeysRef.current.has(key))
+            return true;
+        const segments = key.split('.');
+        for (let i = segments.length - 1; i >= 1; i--) {
+            const ancestor = segments.slice(0, i).join('.');
+            if (loadedKeysRef.current.has(ancestor))
+                return true;
+        }
+        return false;
+    };
+    /** Same ancestor check but against `pendingKeysRef`. */
+    const isKeyImplicitlyPending = (key) => {
+        if (pendingKeysRef.current.has(key))
+            return true;
+        const segments = key.split('.');
+        for (let i = segments.length - 1; i >= 1; i--) {
+            const ancestor = segments.slice(0, i).join('.');
+            if (pendingKeysRef.current.has(ancestor))
+                return true;
+        }
+        return false;
+    };
+    /**
+     * Flush the micro-batch queue: collect all queued keys, fire one API call,
+     * deep-merge the result, resolve all pending promises.
+     */
+    const flushBatch = async () => {
+        const batch = batchQueueRef.current;
+        batchQueueRef.current = [];
+        batchTimerRef.current = null;
+        if (batch.length === 0)
+            return;
+        if (fullLoadCompletedRef.current) {
+            batch.forEach(b => b.resolve());
+            return;
+        }
+        const allKeys = [...new Set(batch.flatMap(b => b.keys))];
+        const missing = allKeys.filter(k => !isKeyImplicitlyLoaded(k));
+        logDebug(`flushBatch allKeys=[${allKeys.join(', ')}] missing=[${missing.join(', ')}]`);
+        if (missing.length === 0) {
+            batch.forEach(b => b.resolve());
+            return;
+        }
+        const language = currentLanguageRef.current;
+        logDebug('Flushing lazy i18n batch', { keys: missing, language });
+        const MAX_KEYS_PER_REQUEST = 30;
+        const chunks = [];
+        for (let i = 0; i < missing.length; i += MAX_KEYS_PER_REQUEST) {
+            chunks.push(missing.slice(i, i + MAX_KEYS_PER_REQUEST));
+        }
+        try {
+            const httpClient = getManualCallsHttpClient();
+            logDebug(`getI18nLabelsByKeys language=${language} chunks=${chunks.map(chunk => `[${chunk.join(', ')}]`).join(', ')}`);
+            const responses = await Promise.all(chunks.map(chunk => httpClient.getI18nLabelsByKeys(language, chunk)));
+            if (language !== currentLanguageRef.current) {
+                logDebug('Discarding stale lazy i18n response', { fetchedFor: language, currentLanguage: currentLanguageRef.current });
+                batch.forEach(b => b.resolve());
+                return;
+            }
+            let merged = {};
+            for (const response of responses) {
+                merged = deepMergeTranslations(merged, response.labels);
+            }
+            setTranslations(prev => deepMergeTranslations(prev, merged));
+            for (const key of missing) {
+                loadedKeysRef.current.add(key);
+                pendingKeysRef.current.delete(key);
+                replayPendingLazyKeys.delete(key);
+            }
+            batch.forEach(b => b.resolve());
+        }
+        catch (error) {
+            for (const key of missing) {
+                pendingKeysRef.current.delete(key);
+            }
+            batch.forEach(b => b.reject(error));
+            reportError(error, `Failed to load translation keys: ${missing.join(', ')}`, { keys: missing, language });
+        }
+    };
+    /**
+     * Find the pending promise for a key, checking the key itself then its ancestors.
+     * Returns the promise if the key (or an ancestor) is in-flight, undefined otherwise.
+     */
+    const findPendingPromise = (key) => {
+        const direct = pendingKeysRef.current.get(key);
+        if (direct)
+            return direct;
+        const segments = key.split('.');
+        for (let i = segments.length - 1; i >= 1; i--) {
+            const ancestor = segments.slice(0, i).join('.');
+            const ancestorPromise = pendingKeysRef.current.get(ancestor);
+            if (ancestorPromise)
+                return ancestorPromise;
+        }
+        return undefined;
+    };
+    const requestKeys = useCallback((keys) => {
+        if (fullLoadCompletedRef.current)
+            return Promise.resolve();
+        const keyArray = typeof keys === 'string' ? [keys] : keys;
+        const needed = keyArray.filter(k => !isKeyImplicitlyLoaded(k));
+        logDebug(`requestKeys keyArray=[${keyArray.join(', ')}] needed=[${needed.join(', ')}]`);
+        if (needed.length === 0)
+            return Promise.resolve();
+        const alreadyPending = needed.filter(k => isKeyImplicitlyPending(k));
+        const brandNew = needed.filter(k => !isKeyImplicitlyPending(k));
+        logDebug(`requestKeys pending=[${alreadyPending.join(', ')}] brandNew=[${brandNew.join(', ')}]`);
+        for (const key of brandNew) {
+            replayPendingLazyKeys.add(key);
+        }
+        if (brandNew.length === 0) {
+            return Promise.all(alreadyPending.map(k => findPendingPromise(k))).then(() => { });
+        }
+        const promise = new Promise((resolve, reject) => {
+            batchQueueRef.current.push({ keys: brandNew, resolve, reject });
+            if (batchTimerRef.current === null) {
+                batchTimerRef.current = setTimeout(flushBatch, 16);
+            }
+        });
+        for (const k of brandNew) {
+            pendingKeysRef.current.set(k, promise);
+        }
+        if (envLoader.isDevelopment()) {
+            logDebug(`DEV immediate lazy flush [${brandNew.join(', ')}]`);
+            void flushBatch();
+        }
+        if (alreadyPending.length > 0) {
+            const pendingPromises = alreadyPending.map(k => findPendingPromise(k));
+            return Promise.all([promise, ...pendingPromises]).then(() => { });
+        }
+        return promise;
+    }, [currentLanguage, reportError]);
+    useEffect(() => {
+        if (replayPendingLazyKeys.size === 0)
+            return;
+        const keys = Array.from(replayPendingLazyKeys);
+        logDebug(`Replaying pending lazy keys after remount [${keys.join(', ')}]`);
+        void requestKeys(keys);
+    }, [requestKeys]);
+    const isKeyLoaded = useCallback((key) => {
+        return isKeyImplicitlyLoaded(key);
+    }, []);
+    const getKeyStatus = useCallback((key) => {
+        if (isKeyImplicitlyLoaded(key))
+            return 'loaded';
+        if (isKeyImplicitlyPending(key))
+            return 'pending';
+        return 'not-requested';
+    }, []);
+    const requestComponentKeys = useCallback((componentType) => {
+        const types = Array.isArray(componentType) ? componentType : [componentType];
+        return requestKeys(types.map(ct => `${LabellingTypes.COMPONENTS}.${ct}`));
+    }, [requestKeys]);
+    const requestResourceKeys = useCallback((resourceType) => {
+        const types = Array.isArray(resourceType) ? resourceType : [resourceType];
+        return requestKeys(types.map(rt => `${LabellingTypes.RESOURCES}.${rt}`));
+    }, [requestKeys]);
+    // -------------------------------------------------------
+    const loadTranslations = async (language) => {
+        if (!appIsInitialized) {
+            logDebug('Waiting for app config to be ready before loading translations');
+            return;
+        }
+        if (loadingLanguageRef.current === language) {
+            logDebug(`Already loading translations for ${language}, skipping duplicate call`);
+            return;
+        }
+        if (loadedLanguagesRef.current.has(language)) {
+            logDebug(`Translations for ${language} already loaded, skipping duplicate call`);
+            return;
+        }
+        const loadingIdentifier = isInitializedRef.current
+            ? AppLoadingIdentifier.I18N_LANGUAGE_CHANGE
+            : AppLoadingIdentifier.INIT_I18N;
+        logDebug(`Starting translation loading for ${language}`);
+        loadingLanguageRef.current = language;
+        setIsLoading(true);
+        emit(FrontendEvents.LOADING_CUSTOM_START, {
+            identifier: loadingIdentifier,
+            data: { language },
+            tier: LoadingTier.APPLICATION,
+        });
+        try {
+            const response = await getManualCallsHttpClient().getI18nLabels(language, EAGER_I18N_SECTIONS);
+            if (language !== currentLanguageRef.current) {
+                logDebug('Discarding stale translation response', { fetchedFor: language, currentLanguage: currentLanguageRef.current });
+                return;
+            }
+            // Deep-merge, not replace. During language change, lazy batch requests
+            // (via useI18n deps effects) may resolve concurrently with this eager
+            // load. Using replace would wipe lazy data that arrived first.
+            setTranslations(prev => deepMergeTranslations(prev, response.labels));
+            loadedLanguagesRef.current.add(language);
+            for (const section of EAGER_I18N_SECTIONS) {
+                loadedKeysRef.current.add(section);
+            }
+            // Do NOT set fullLoadCompletedRef.current = true.
+            // With fullLoadCompleted = false, requestKeys no longer short-circuits,
+            // isKeyLoaded returns false for unloaded sections, and the microbatch
+            // system becomes the primary loader for per-component translations.
+            logDebug('Eager i18n sections loaded', { language: response.language, sections: EAGER_I18N_SECTIONS });
+            if (!isInitializedRef.current) {
+                isInitializedRef.current = true;
+                markComponentInitialized(MainContextInitComponents.I18N);
+            }
+        }
+        catch (error) {
+            reportError(error, `Failed to load translations for language: ${language}`, { language });
+            loadedKeysRef.current.clear();
+            pendingKeysRef.current.clear();
+            setTranslations({});
+        }
+        finally {
+            loadingLanguageRef.current = null;
+            setIsLoading(false);
+            emit(FrontendEvents.LOADING_CUSTOM_END, {
+                identifier: loadingIdentifier,
+                data: { language },
+                tier: LoadingTier.APPLICATION,
+            });
+        }
+    };
+    const t = (key, params) => {
+        const keys = key.split('.');
+        let value = translations;
+        // Navigate through nested translation object
+        for (const k of keys) {
+            value = value?.[k];
+            if (value === undefined)
+                break;
+        }
+        let result = typeof value === 'string' ? value : key;
+        // Replace parameters if provided
+        if (params) {
+            Object.entries(params).forEach(([paramKey, paramValue]) => {
+                result = result.replace(new RegExp(`{{${paramKey}}}`, 'g'), String(paramValue));
+            });
+        }
+        return result;
+    };
+    // ------------------------------
+    // Labelling-based helper builders
+    // ------------------------------
+    const tResourceHeader = (resource, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.header.${key}`;
+        return t(base, params);
+    };
+    const tResourceEmptyState = (resource, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.emptyState.${key}`;
+        const result = t(base, params);
+        // Return empty string when translation is missing (key path returned as-is) so callers can fall back gracefully
+        if (result === base)
+            return '';
+        return result;
+    };
+    const tResourceOperation = (resource, operation, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.${operation}.${key}`;
+        return t(base, params);
+    };
+    const tResourceFieldDisplay = (resource, fieldPath, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.fields.${fieldPath}.display.${key}`;
+        const result = t(base, params);
+        // Fallback: if translation not found, return formatted field name for 'label', empty for description/tooltip
+        if (result === base) {
+            return key === 'label' ? AutomatedLayoutFrontendUtils.formatFieldLabelFallback(fieldPath) : '';
+        }
+        return result;
+    };
+    const tResourceFieldEdit = (resource, fieldPath, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.fields.${fieldPath}.edit.${key}`;
+        const result = t(base, params);
+        // Fallback: if translation not found, return formatted field name for 'label', empty for description/placeholder/tooltip
+        if (result === base) {
+            return key === 'label' ? AutomatedLayoutFrontendUtils.formatFieldLabelFallback(fieldPath) : '';
+        }
+        return result;
+    };
+    const tResourceFieldEnumValue = (resource, fieldPath, enumValue) => {
+        // 1. Try resource-field-specific label (allows per-resource overrides)
+        const resourceKey = `${LabellingTypes.RESOURCES}.${resource}.fields.${fieldPath}.enum.${enumValue}`;
+        const resourceResult = t(resourceKey);
+        if (resourceResult !== resourceKey)
+            return resourceResult;
+        // 2. Auto-cascade: when resource-field key is missing, check system enum labels.
+        //    Backend skips generating per-resource keys for system enum fields, so the
+        //    resource key will be missing → we transparently resolve via system_enums.
+        for (const enumName of SYSTEM_ENUM_NAMES) {
+            const systemKey = `${LabellingTypes.SYSTEM_ENUMS}.${enumName}.${enumValue}`;
+            const systemResult = t(systemKey);
+            if (systemResult !== systemKey)
+                return systemResult;
+        }
+        // 3. Fallback to raw enum value
+        return enumValue;
+    };
+    const tErrorValidation = (zodIssueCode, ref, params) => {
+        const base = `${LabellingTypes.ERRORS_VALIDATION}.${zodIssueCode}.${ref}`;
+        return t(base, params);
+    };
+    const tComponent = (componentType, key, params) => {
+        const base = `${LabellingTypes.COMPONENTS}.${componentType}.${key}`;
+        return t(base, params);
+    };
+    const tErrorMessage = (errorRef, key = 'msg', params) => {
+        const base = `${LabellingTypes.ERRORS_MESSAGES}.${errorRef}.${key}`;
+        return t(base, params);
+    };
+    /**
+     * Resolve error guidance label from `errors_guidance.{guidanceKey}.{field}`.
+     * Returns empty string when the label is missing (unlike `t` which returns the key path).
+     */
+    const tErrorGuidance = (guidanceKey, field, params) => {
+        const base = `${LabellingTypes.ERRORS_GUIDANCE}.${guidanceKey}.${field}`;
+        const result = t(base, params);
+        return result === base ? '' : result;
+    };
+    const tNotificationCustom = (notificationRef, key = 'msg', params) => {
+        const base = `${LabellingTypes.NOTIFICATIONS_CUSTOM}.${notificationRef}.${key}`;
+        return t(base, params);
+    };
+    const tSystemEnum = (enumName, enumValue) => {
+        const base = `${LabellingTypes.SYSTEM_ENUMS}.${enumName}.${enumValue}`;
+        const result = t(base);
+        // If translation not found, fallback to enum value
+        return result === base ? enumValue : result;
+    };
+    // Form section labels (for AutomatedForm)
+    // Path: resources.{resourceType}.operations.{operationId}.sections.{index}.{title|description}
+    const tResourceSection = (resource, operation, index, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.operations.${operation}.sections.${index}.${key}`;
+        const result = t(base, params);
+        // Fallback: if translation not found, return empty string (section renders without title)
+        return result === base ? '' : result;
+    };
+    // Path: resources.{resourceType}.operations.{operationId}.wizardsteps.{index}.{title|description}
+    const tResourceWizardStep = (resource, operation, index, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.operations.${operation}.wizardsteps.${index}.${key}`;
+        const result = t(base, params);
+        // Fallback: if translation not found, return empty string (step renders without title)
+        return result === base ? '' : result;
+    };
+    // Path: sidebar_sections.{sectionRef}.{title|description}
+    // Falls back to sectionRef if translation not found
+    const tSidebarSection = (sectionRef, key = 'title', params) => {
+        const base = `${LabellingTypes.SIDEBAR_SECTIONS}.${sectionRef}.${key}`;
+        const result = t(base, params);
+        // If translation not found, fallback to humanized section ref
+        return result === base ? sectionRef.charAt(0).toUpperCase() + sectionRef.slice(1).replace(/_/g, ' ') : result;
+    };
+    // ------------------------------
+    // Guidance helpers
+    // ------------------------------
+    const tGuidanceFlow = (flowRef, key, params) => t(`guidance.${flowRef}.${key}`, params);
+    const tGuidanceElement = (flowRef, elementRef, key, params) => {
+        const fullKey = `guidance.${flowRef}.elements.${elementRef}.${key}`;
+        const result = t(fullKey, params);
+        return result === fullKey ? undefined : result;
+    };
+    const tGuidanceTourStep = (flowRef, elementRef, stepRef, key, params) => {
+        const fullKey = `guidance.${flowRef}.elements.${elementRef}.tour_steps.${stepRef}.${key}`;
+        const result = t(fullKey, params);
+        return result === fullKey ? undefined : result;
+    };
+    const tGuidanceSurveyQuestion = (flowRef, elementRef, questionId, key, params) => {
+        const fullKey = `guidance.${flowRef}.elements.${elementRef}.survey_questions.${questionId}.${key}`;
+        const result = t(fullKey, params);
+        return result === fullKey ? undefined : result;
+    };
+    const makeTrGuidanceElement = (flowRef, elementRef) => (key, params) => tGuidanceElement(flowRef, elementRef, key, params);
+    // ------------------------------
+    // Milestone helpers
+    // ------------------------------
+    const tMilestone = (milestoneRef, key, params) => t(`milestones.${milestoneRef}.${key}`, params);
+    const tMilestoneReward = (milestoneRef, key, params) => t(`milestones.${milestoneRef}.reward.${key}`, params);
+    const makeTrMilestone = (milestoneRef) => (key, params) => tMilestone(milestoneRef, key, params);
+    // ------------------------------
+    // Lifecycle helpers
+    // ------------------------------
+    const tLifecycle = (key, params) => t(`lifecycle.${key}`, params);
+    const tLifecycleStage = (stage) => t(`lifecycle.stage.${stage}.label`);
+    const tActivationCriterion = (criterion) => {
+        switch (criterion.criterionType) {
+            case ActivationCriterionType.MILESTONE:
+                return tMilestone(criterion.milestoneRef, 'title');
+            case ActivationCriterionType.GUIDANCE_COMPLETED:
+                return tGuidanceFlow(criterion.guidanceFlowRef, 'title');
+        }
+    };
+    const tMilestoneCategory = (category) => {
+        const base = `${LabellingTypes.MILESTONES}.categories.${category}.label`;
+        const result = t(base);
+        return result === base ? humanizeKey(category) : result;
+    };
+    // ------------------------------
+    // Billing helpers
+    // ------------------------------
+    const tBillingProduct = (productKey, subKey) => {
+        const base = `${LabellingTypes.BILLING_PRODUCTS}.${productKey}.${subKey}`;
+        const result = t(base);
+        return result === base ? (subKey === 'name' ? humanizeKey(productKey) : '') : result;
+    };
+    const tBillingFeature = (featureKey, subKey) => {
+        const base = `${LabellingTypes.BILLING_FEATURES}.${featureKey}.${subKey}`;
+        const result = t(base);
+        return result === base ? (subKey === 'label' ? humanizeKey(featureKey) : '') : result;
+    };
+    const tBillingLimit = (limitKey, subKey) => {
+        const base = `${LabellingTypes.BILLING_LIMITS}.${limitKey}.${subKey}`;
+        const result = t(base);
+        return result === base ? (subKey === 'label' ? humanizeKey(limitKey) : '') : result;
+    };
+    const tBillingCreditPool = (poolKey, subKey) => {
+        const base = `${LabellingTypes.BILLING_CREDIT_POOLS}.${poolKey}.${subKey}`;
+        const result = t(base);
+        return result === base ? (subKey === 'name' ? humanizeKey(poolKey) : '') : result;
+    };
+    // ------------------------------
+    // Curried resource helpers
+    // ------------------------------
+    const makeTrResourceHeader = (resource) => (key = 'title', params) => {
+        return tResourceHeader(resource, key, params);
+    };
+    const makeTrResourceEmptyState = (resource) => (key = 'title', params) => {
+        return tResourceEmptyState(resource, key, params);
+    };
+    const makeTrResourceOperation = (resource) => (operation, key = 'title', params) => {
+        return tResourceOperation(resource, operation, key, params);
+    };
+    const makeTrResourceFieldDisplay = (resource) => (fieldPath, key = 'label', params) => {
+        return tResourceFieldDisplay(resource, fieldPath, key, params);
+    };
+    // Back-compat alias removed; use makeTrResourceFieldEdit instead
+    const makeTrResourceFieldEnum = (resource) => (fieldPath, enumValue) => {
+        return tResourceFieldEnumValue(resource, fieldPath, enumValue);
+    };
+    // ------------------------------
+    // Curried helpers for other LabellingTypes
+    // ------------------------------
+    const makeTrErrorMessage = (errorRef) => (key = 'msg', params) => {
+        return tErrorMessage(errorRef, key, params);
+    };
+    const makeTrErrorGuidance = (guidanceKey) => (field, params) => {
+        return tErrorGuidance(guidanceKey, field, params);
+    };
+    const makeTrNotificationCustom = (notificationRef) => (key = 'msg', params) => {
+        return tNotificationCustom(notificationRef, key, params);
+    };
+    const makeTrErrorValidation = (zodIssueCode) => (ref, params) => {
+        return tErrorValidation(zodIssueCode, ref, params);
+    };
+    const makeTrComponent = (componentType) => (key, params) => {
+        return tComponent(componentType, key, params);
+    };
+    const makeTrResourceFieldEdit = (resource) => (fieldPath, key = 'label', params) => {
+        return tResourceFieldEdit(resource, fieldPath, key, params);
+    };
+    const makeTrSystemEnum = (enumName) => (enumValue) => {
+        return tSystemEnum(enumName, enumValue);
+    };
+    // Text direction from current language (for RTL layout)
+    const dir = useMemo(() => {
+        const info = LANGUAGE_INFO_MAP[currentLanguage];
+        return info?.direction ?? TextDirection.LTR;
+    }, [currentLanguage]);
+    useEffect(() => {
+        document.documentElement.dir = dir;
+    }, [dir]);
+    // Regional formatting (absorbed from ComponentsLabellingContext)
+    const resolvedRegionalPreferences = useMemo(() => ({
+        locale: regionalPreferences?.locale ?? currentLanguage ?? 'en',
+        timezone: regionalPreferences?.timezone ?? 'UTC',
+        dateFormat: regionalPreferences?.dateFormat ?? DateFormat.ISO_8601,
+        timeFormat: regionalPreferences?.timeFormat ?? TimeFormat.TWENTY_FOUR_HOUR,
+    }), [regionalPreferences, currentLanguage]);
+    const formatDate = useCallback((value) => RegionalFormattingUtils.formatDate(value, resolvedRegionalPreferences), [resolvedRegionalPreferences]);
+    const formatTime = useCallback((value) => RegionalFormattingUtils.formatTime(value, resolvedRegionalPreferences), [resolvedRegionalPreferences]);
+    const formatDateTime = useCallback((value) => RegionalFormattingUtils.formatDateTime(value, resolvedRegionalPreferences), [resolvedRegionalPreferences]);
+    const formatNumber = useCallback((value, options) => RegionalFormattingUtils.formatNumber(value, resolvedRegionalPreferences, options), [resolvedRegionalPreferences]);
+    const hasComponentTranslations = useCallback((componentType) => {
+        const componentPath = `${LabellingTypes.COMPONENTS}.${componentType}`;
+        const keys = componentPath.split('.');
+        let value = translations;
+        for (const k of keys) {
+            value = value?.[k];
+            if (value === undefined)
+                return false;
+        }
+        return typeof value === 'object' && value !== null && Object.keys(value).length > 0;
+    }, [translations]);
+    const getComponentKeys = useCallback((componentType) => {
+        const componentPath = `${LabellingTypes.COMPONENTS}.${componentType}`;
+        const keys = componentPath.split('.');
+        let value = translations;
+        for (const k of keys) {
+            value = value?.[k];
+            if (value === undefined)
+                return [];
+        }
+        return typeof value === 'object' && value !== null ? Object.keys(value) : [];
+    }, [translations]);
+    const value = {
+        // State
+        currentLanguage,
+        dir,
+        translations,
+        isLoading,
+        availableLanguages: configEnabledLanguages,
+        // Language config flags
+        enableLanguageSwitcher: configEnableLanguageSwitcher,
+        allowUserOverride: configAllowUserOverride,
+        // Preferences
+        languagePreferences,
+        regionalPreferences,
+        // Actions
+        changeLanguage,
+        loadTranslations,
+        // Helpers
+        t,
+        getLanguageName,
+        isLanguageSupported,
+        // Preference getters
+        getLanguagePreferences,
+        getRegionalPreferences,
+        tResourceHeader,
+        tResourceEmptyState,
+        tResourceOperation,
+        tResourceFieldDisplay,
+        tResourceFieldEdit,
+        tResourceFieldEnumValue,
+        tErrorValidation,
+        tComponent,
+        tErrorMessage,
+        tErrorGuidance,
+        tNotificationCustom,
+        tSystemEnum,
+        tResourceSection,
+        tResourceWizardStep,
+        tSidebarSection,
+        makeTrResourceHeader,
+        makeTrResourceEmptyState,
+        makeTrResourceOperation,
+        makeTrResourceFieldDisplay,
+        makeTrResourceFieldEnum,
+        makeTrResourceFieldEdit,
+        makeTrErrorMessage,
+        makeTrErrorGuidance,
+        makeTrNotificationCustom,
+        makeTrErrorValidation,
+        makeTrComponent,
+        makeTrSystemEnum,
+        tGuidanceFlow,
+        tGuidanceElement,
+        tGuidanceTourStep,
+        tGuidanceSurveyQuestion,
+        makeTrGuidanceElement,
+        tMilestone,
+        tMilestoneReward,
+        makeTrMilestone,
+        tLifecycle,
+        tLifecycleStage,
+        tActivationCriterion,
+        tMilestoneCategory,
+        tBillingProduct,
+        tBillingFeature,
+        tBillingLimit,
+        tBillingCreditPool,
+        resolvedRegionalPreferences,
+        formatDate,
+        formatTime,
+        formatDateTime,
+        formatNumber,
+        hasComponentTranslations,
+        getComponentKeys,
+        requestKeys,
+        isKeyLoaded,
+        getKeyStatus,
+        requestComponentKeys,
+        requestResourceKeys,
+    };
+    return (_jsx(DirectionProvider, { dir: dir, children: _jsx(I18nContext.Provider, { value: value, children: children }) }));
+};
+//# sourceMappingURL=I18nContext.js.map