@digitaldefiance/express-suite-react-components 5.0.2 → 5.0.3

package/src/contexts/AuthProvider.js

@@ -0,0 +1,515 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = exports.AuthProvider = exports.AuthContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
+const i18n_lib_1 = require("@digitaldefiance/i18n-lib");
+const suite_core_lib_1 = require("@digitaldefiance/suite-core-lib");
+const react_1 = require("react");
+const useExpiringValue_1 = require("../hooks/useExpiringValue");
+const useLocalStorage_1 = require("../hooks/useLocalStorage");
+const useUserSettings_1 = require("../hooks/useUserSettings");
+const authService_1 = require("../services/authService");
+const authenticatedApi_1 = require("../services/authenticatedApi");
+const I18nProvider_1 = require("./I18nProvider");
+const ThemeProvider_1 = require("./ThemeProvider");
+exports.AuthContext = (0, react_1.createContext)({});
+const AuthProviderInner = ({ children, baseUrl, constants, eciesConfig, onLogout, emailDomain, }) => {
+    const { tComponent, changeLanguage: i18nChangeLanguage } = (0, I18nProvider_1.useI18n)();
+    const { setColorMode: themeSetPaletteMode, mode: colorMode } = (0, ThemeProvider_1.useTheme)();
+    const authService = (0, react_1.useMemo)(() => (0, authService_1.createAuthService)(constants, baseUrl, eciesConfig, emailDomain), [constants, baseUrl, eciesConfig, emailDomain]);
+    const authenticatedApi = (0, react_1.useMemo)(() => (0, authenticatedApi_1.createAuthenticatedApiClient)(baseUrl), [baseUrl]);
+    // Use the custom hooks for expiring values
+    const mnemonicManager = (0, useExpiringValue_1.useExpiringValue)(constants.DefaultExpireMemoryMnemonicSeconds, 'mnemonicExpirationSeconds');
+    const walletManager = (0, useExpiringValue_1.useExpiringValue)(constants.DefaultExpireMemoryWalletSeconds, 'walletExpirationSeconds');
+    // Use localStorage hook for expiration settings
+    const [mnemonicExpirationSeconds, _setMnemonicExpirationSeconds] = (0, useLocalStorage_1.useLocalStorage)('mnemonicExpirationSeconds', constants.DefaultExpireMemoryMnemonicSeconds);
+    const [walletExpirationSeconds, _setWalletExpirationSeconds] = (0, useLocalStorage_1.useLocalStorage)('walletExpirationSeconds', constants.DefaultExpireMemoryWalletSeconds);
+    const [serverPublicKey, setServerPublicKey] = (0, react_1.useState)(null);
+    const [user, setUser] = (0, react_1.useState)(null);
+    const [frontendUser, setFrontendUser] = (0, react_1.useState)(null);
+    const [isAuthenticated, setIsAuthenticated] = (0, react_1.useState)(false);
+    const [isGlobalAdmin, setIsGlobalAdmin] = (0, react_1.useState)(false);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    // Separate flag so route guards don't unmount during actions (e.g., register/login)
+    const [isCheckingAuth, setIsCheckingAuth] = (0, react_1.useState)(true);
+    const [token, setToken] = (0, react_1.useState)(null);
+    const [authState, setAuthState] = (0, react_1.useState)(0);
+    // Use the user settings hook for settings management
+    const { userSettings, setUserSettingAndUpdateSettings } = (0, useUserSettings_1.useUserSettings)({
+        authenticatedApi,
+        isAuthenticated,
+    });
+    // Helper functions to calculate remaining time (now provided by the hooks)
+    const getMnemonicRemainingTime = mnemonicManager.getRemainingTime;
+    const getWalletRemainingTime = walletManager.getRemainingTime;
+    // Wrapper functions to match the interface (the localStorage hook handles storage automatically)
+    const setMnemonicExpirationSeconds = _setMnemonicExpirationSeconds;
+    const setWalletExpirationSeconds = _setWalletExpirationSeconds;
+    // Sync user language with i18n provider when the user's saved language changes.
+    // Only update the i18n engine — do NOT call setUserSettingAndUpdateSettings
+    // here because its merge with defaults can overwrite other settings (e.g.
+    // timezone) with default values when the closure captures stale userSettings.
+    (0, react_1.useEffect)(() => {
+        if (user?.siteLanguage) {
+            i18nChangeLanguage(user.siteLanguage);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [user?.siteLanguage]);
+    const setMnemonic = (0, react_1.useCallback)((mnemonic, durationSeconds) => {
+        const finalDurationSeconds = durationSeconds ?? mnemonicExpirationSeconds;
+        // Store the duration to localStorage if provided
+        if (durationSeconds !== undefined) {
+            _setMnemonicExpirationSeconds(durationSeconds);
+        }
+        // Only save to storage if a custom duration was provided
+        return mnemonicManager.setValue(mnemonic, finalDurationSeconds, durationSeconds !== undefined);
+    }, 
+    // mnemonicManager is intentionally excluded as it's a stable reference from useExpiringValue
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        mnemonicExpirationSeconds,
+        mnemonicManager.setValue,
+        _setMnemonicExpirationSeconds,
+    ]);
+    const setWallet = (0, react_1.useCallback)((wallet, durationSeconds) => {
+        const finalDurationSeconds = durationSeconds ?? walletExpirationSeconds;
+        // Store the duration to localStorage if provided
+        if (durationSeconds !== undefined) {
+            _setWalletExpirationSeconds(durationSeconds);
+        }
+        // Only save to storage if a custom duration was provided
+        return walletManager.setValue(wallet, finalDurationSeconds, durationSeconds !== undefined);
+    }, 
+    // walletManager is intentionally excluded as it's a stable reference from useExpiringValue
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        walletExpirationSeconds,
+        walletManager.setValue,
+        _setWalletExpirationSeconds,
+    ]);
+    const clearMnemonic = mnemonicManager.clearValue;
+    const clearWallet = walletManager.clearValue;
+    const checkAuth = (0, react_1.useCallback)(async () => {
+        const token = localStorage.getItem('authToken');
+        if (!token) {
+            setUser(null);
+            setIsAuthenticated(false);
+            setLoading(false);
+            setIsCheckingAuth(false);
+            setToken(null);
+            setFrontendUser(null);
+            setServerPublicKey(null);
+            await setUserSettingAndUpdateSettings(undefined);
+            themeSetPaletteMode('light');
+            clearMnemonic();
+            clearWallet();
+            return;
+        }
+        try {
+            const userData = await authService.verifyToken(token);
+            if ('error' in userData && typeof userData.error === 'string') {
+                setIsAuthenticated(false);
+                setToken(null);
+            }
+            else if ('id' in userData && 'email' in userData) {
+                const userDataDTO = userData;
+                setUser(userDataDTO);
+                setIsGlobalAdmin(userDataDTO.roles.some((r) => r.admin));
+                setIsAuthenticated(true);
+                setToken(token);
+                await setUserSettingAndUpdateSettings({
+                    darkMode: userDataDTO.darkMode,
+                    currency: new i18n_lib_1.CurrencyCode(userDataDTO.currency),
+                    timezone: new i18n_lib_1.Timezone(userDataDTO.timezone),
+                    siteLanguage: userDataDTO.siteLanguage,
+                    email: new ecies_lib_1.EmailString(userDataDTO.email),
+                    directChallenge: userDataDTO.directChallenge,
+                    ...(userDataDTO.displayName !== undefined
+                        ? { displayName: userDataDTO.displayName }
+                        : {}),
+                });
+            }
+        }
+        catch (error) {
+            console.error('Token verification failed:', error);
+            setUser(null);
+            setIsAuthenticated(false);
+            await setUserSettingAndUpdateSettings(undefined);
+            localStorage.removeItem('authToken');
+        }
+        finally {
+            setLoading(false);
+            setIsCheckingAuth(false);
+        }
+    }, [
+        authService,
+        clearMnemonic,
+        clearWallet,
+        setUserSettingAndUpdateSettings,
+        themeSetPaletteMode,
+    ]);
+    (0, react_1.useEffect)(() => {
+        const token = localStorage.getItem('authToken');
+        if (token) {
+            (async () => {
+                await checkAuth();
+            })();
+        }
+        else {
+            setLoading(false);
+            setIsCheckingAuth(false);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [authState]); // Only run when authState changes (login/logout), not when checkAuth is recreated
+    const directLogin = (0, react_1.useCallback)(async (mnemonic, username, email, expireMnemonicSeconds, expireWalletSeconds) => {
+        setLoading(true);
+        const loginResult = await authService.directLogin(mnemonic, username, email);
+        setLoading(false);
+        if (typeof loginResult === 'object' &&
+            'token' in loginResult &&
+            'user' in loginResult &&
+            'wallet' in loginResult) {
+            setMnemonic(mnemonic, expireMnemonicSeconds);
+            setUser(loginResult.user);
+            setWallet(loginResult.wallet, expireWalletSeconds);
+            setIsAuthenticated(true);
+            setAuthState((prev) => prev + 1);
+            localStorage.setItem('authToken', loginResult.token);
+            localStorage.setItem('user', JSON.stringify(loginResult.user));
+            await setUserSettingAndUpdateSettings({
+                darkMode: loginResult.user.darkMode,
+                currency: new i18n_lib_1.CurrencyCode(loginResult.user.currency),
+                timezone: new i18n_lib_1.Timezone(loginResult.user.timezone),
+                siteLanguage: loginResult.user.siteLanguage,
+                email: new ecies_lib_1.EmailString(loginResult.user.email),
+                directChallenge: loginResult.user.directChallenge,
+                ...(loginResult.user.displayName !== undefined
+                    ? { displayName: loginResult.user.displayName }
+                    : {}),
+            });
+            return loginResult;
+        }
+        return loginResult;
+    }, [authService, setMnemonic, setWallet, setUserSettingAndUpdateSettings]);
+    const emailChallengeLogin = (0, react_1.useCallback)(async (mnemonic, token, username, email, expireMnemonicSeconds, expireWalletSeconds) => {
+        setLoading(true);
+        const loginResult = await authService.emailChallengeLogin(mnemonic, token, username, email);
+        setLoading(false);
+        if (typeof loginResult === 'object' &&
+            'token' in loginResult &&
+            'user' in loginResult &&
+            'wallet' in loginResult) {
+            setMnemonic(mnemonic, expireMnemonicSeconds);
+            setUser(loginResult.user);
+            setWallet(loginResult.wallet, expireWalletSeconds);
+            setIsAuthenticated(true);
+            setAuthState((prev) => prev + 1);
+            localStorage.setItem('authToken', loginResult.token);
+            localStorage.setItem('user', JSON.stringify(loginResult.user));
+            await setUserSettingAndUpdateSettings({
+                darkMode: loginResult.user.darkMode,
+                currency: new i18n_lib_1.CurrencyCode(loginResult.user.currency),
+                timezone: new i18n_lib_1.Timezone(loginResult.user.timezone),
+                siteLanguage: loginResult.user.siteLanguage,
+                email: new ecies_lib_1.EmailString(loginResult.user.email),
+                directChallenge: loginResult.user.directChallenge,
+                ...(loginResult.user.displayName !== undefined
+                    ? { displayName: loginResult.user.displayName }
+                    : {}),
+            });
+            return loginResult;
+        }
+        return loginResult;
+    }, [authService, setMnemonic, setWallet, setUserSettingAndUpdateSettings]);
+    const getPasswordLoginService = (0, react_1.useCallback)(() => {
+        const eciesService = new ecies_lib_1.ECIESService(eciesConfig);
+        const aesGcmService = new ecies_lib_1.AESGCMService();
+        return new ecies_lib_1.PasswordLoginService(aesGcmService, eciesService, new ecies_lib_1.Pbkdf2Service(ecies_lib_1.Constants.PBKDF2_PROFILES, ecies_lib_1.Constants.ECIES, ecies_lib_1.Constants.PBKDF2));
+    }, [eciesConfig]);
+    const isBrowserPasswordLoginAvailable = (0, react_1.useCallback)(() => {
+        const storedEncryptedPrivateKey = localStorage.getItem(ecies_lib_1.PasswordLoginService.privateKeyStorageKey);
+        return !!storedEncryptedPrivateKey;
+    }, []);
+    const passwordLogin = (0, react_1.useCallback)(async (password, username, email) => {
+        if (!isBrowserPasswordLoginAvailable()) {
+            return {
+                error: tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_Login_PasswordLoginNotSetup),
+                errorType: 'PasswordLoginNotSetup',
+            };
+        }
+        setLoading(true);
+        const passwordLoginService = getPasswordLoginService();
+        const { wallet, mnemonic } = await passwordLoginService.getWalletAndMnemonicFromLocalStorageBundle(password);
+        const loginResult = await authService.directLogin(mnemonic, username, email);
+        setLoading(false);
+        setWallet(wallet);
+        setMnemonic(mnemonic);
+        // Set theme based on user's darkMode preference if login succeeded
+        if ('user' in loginResult) {
+            await setUserSettingAndUpdateSettings({
+                darkMode: loginResult.user.darkMode,
+                currency: new i18n_lib_1.CurrencyCode(loginResult.user.currency),
+                timezone: new i18n_lib_1.Timezone(loginResult.user.timezone),
+                siteLanguage: loginResult.user.siteLanguage,
+                email: new ecies_lib_1.EmailString(loginResult.user.email),
+                directChallenge: loginResult.user.directChallenge,
+                ...(loginResult.user.displayName !== undefined
+                    ? { displayName: loginResult.user.displayName }
+                    : {}),
+            });
+        }
+        return loginResult;
+    }, [
+        authService,
+        getPasswordLoginService,
+        setMnemonic,
+        setWallet,
+        tComponent,
+        isBrowserPasswordLoginAvailable,
+        setUserSettingAndUpdateSettings,
+    ]);
+    const refreshToken = (0, react_1.useCallback)(async () => {
+        try {
+            const result = await authService.refreshToken();
+            localStorage.setItem('authToken', result.token);
+            localStorage.setItem('user', JSON.stringify(result.user));
+            setUser(result.user);
+            setIsAuthenticated(true);
+            return result;
+        }
+        catch (error) {
+            setUser(null);
+            setIsAuthenticated(false);
+            localStorage.removeItem('authToken');
+            localStorage.removeItem('user');
+            throw error;
+        }
+    }, [authService]);
+    const register = (0, react_1.useCallback)(async (username, email, timezone, password, mnemonic, displayName, directChallenge) => {
+        const registerResult = await authService.register(username, email, timezone, password, mnemonic, displayName, directChallenge);
+        return registerResult;
+    }, [authService]);
+    const requestEmailLogin = (0, react_1.useCallback)(async (username, email) => {
+        setLoading(true);
+        const result = await authService.requestEmailLogin(username, email);
+        setLoading(false);
+        return result;
+    }, [authService]);
+    const setUpBrowserPasswordLogin = (0, react_1.useCallback)(async (mnemonic, password) => {
+        setLoading(true);
+        const passwordLoginService = getPasswordLoginService();
+        try {
+            const wallet = await passwordLoginService.setupPasswordLoginLocalStorageBundle(mnemonic, password);
+            setLoading(false);
+            setWallet(wallet);
+            setMnemonic(mnemonic);
+            return {
+                success: true,
+                message: tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_Setup_Success),
+            };
+        }
+        catch {
+            setLoading(false);
+            return {
+                success: false,
+                message: tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_Setup_Failure),
+            };
+        }
+    }, [getPasswordLoginService, setMnemonic, setWallet, tComponent]);
+    const backupCodeLogin = (0, react_1.useCallback)(async (identifier, code, isEmail, recoverMnemonic, newPassword) => {
+        setLoading(true);
+        const loginResult = await authService.backupCodeLogin(identifier, code, isEmail, recoverMnemonic, newPassword);
+        setLoading(false);
+        if (typeof loginResult === 'object' && 'token' in loginResult) {
+            localStorage.setItem('authToken', loginResult.token);
+            if (loginResult.user) {
+                setUser(loginResult.user);
+                setIsAuthenticated(true);
+                await setUserSettingAndUpdateSettings({
+                    darkMode: loginResult.user.darkMode,
+                    currency: new i18n_lib_1.CurrencyCode(loginResult.user.currency),
+                    timezone: new i18n_lib_1.Timezone(loginResult.user.timezone),
+                    siteLanguage: loginResult.user.siteLanguage,
+                    email: new ecies_lib_1.EmailString(loginResult.user.email),
+                    directChallenge: loginResult.user.directChallenge,
+                    ...(loginResult.user.displayName !== undefined
+                        ? { displayName: loginResult.user.displayName }
+                        : {}),
+                });
+            }
+            setAuthState((prev) => prev + 1);
+            return {
+                token: loginResult.token,
+                mnemonic: loginResult.mnemonic,
+                message: loginResult.message,
+                codeCount: loginResult.codeCount,
+            };
+        }
+        return loginResult;
+    }, [authService, setUserSettingAndUpdateSettings]);
+    const logout = (0, react_1.useCallback)(async () => {
+        localStorage.removeItem('user');
+        localStorage.removeItem('authToken');
+        clearMnemonic();
+        setUser(null);
+        clearWallet();
+        setIsAuthenticated(false);
+        await setUserSettingAndUpdateSettings(undefined);
+        setAuthState((prev) => prev + 1);
+        // Call the optional navigation callback if provided
+        if (onLogout) {
+            onLogout();
+        }
+    }, [onLogout, clearMnemonic, clearWallet, setUserSettingAndUpdateSettings]);
+    const verifyToken = (0, react_1.useCallback)(async (token) => {
+        const requestUser = await authService.verifyToken(token);
+        if (typeof requestUser === 'object' && 'error' in requestUser) {
+            setIsAuthenticated(false);
+            await setUserSettingAndUpdateSettings(undefined);
+            return false;
+        }
+        else {
+            setUser(requestUser);
+            setIsAuthenticated(true);
+            return true;
+        }
+    }, [authService, setUserSettingAndUpdateSettings]);
+    const changePassword = (0, react_1.useCallback)(async (currentPassword, newPassword) => {
+        if (!isBrowserPasswordLoginAvailable()) {
+            return {
+                error: tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_Login_PasswordLoginNotSetup),
+                errorType: 'PasswordLoginNotSetup',
+            };
+        }
+        setLoading(true);
+        try {
+            const passwordLoginService = getPasswordLoginService();
+            const { mnemonic, wallet } = await passwordLoginService.getWalletAndMnemonicFromLocalStorageBundle(new ecies_lib_1.SecureString(currentPassword));
+            if (!mnemonic) {
+                setLoading(false);
+                return {
+                    error: tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_InvalidCurrentPassword),
+                    errorType: 'InvalidCurrentPassword',
+                };
+            }
+            await passwordLoginService.setupPasswordLoginLocalStorageBundle(mnemonic, new ecies_lib_1.SecureString(newPassword));
+            setLoading(false);
+            setWallet(wallet);
+            setMnemonic(mnemonic);
+            return {
+                success: true,
+                message: tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordChange_Success),
+            };
+        }
+        catch {
+            setLoading(false);
+            return { error: 'Password change failed' };
+        }
+    }, [
+        getPasswordLoginService,
+        setMnemonic,
+        setWallet,
+        tComponent,
+        isBrowserPasswordLoginAvailable,
+    ]);
+    const contextValue = (0, react_1.useMemo)(() => {
+        const setUserAndIsAuthenticated = async (newUser) => {
+            setUser(newUser);
+            setIsAuthenticated(!!newUser);
+        };
+        return {
+            admin: isGlobalAdmin,
+            authState,
+            backupCodeLogin,
+            changePassword,
+            checkAuth,
+            clearMnemonic,
+            clearWallet,
+            colorMode,
+            currencyCode: userSettings?.currency,
+            directLogin,
+            emailChallengeLogin,
+            getMnemonicRemainingTime,
+            getWalletRemainingTime,
+            isAuthenticated,
+            isCheckingAuth,
+            isBrowserPasswordLoginAvailable,
+            loading,
+            logout,
+            mnemonic: mnemonicManager.value,
+            mnemonicExpirationSeconds,
+            passwordLogin,
+            refreshToken,
+            register,
+            requestEmailLogin,
+            serverPublicKey,
+            setMnemonic,
+            setMnemonicExpirationSeconds,
+            setUpBrowserPasswordLogin,
+            setUser: setUserAndIsAuthenticated,
+            setUserSetting: setUserSettingAndUpdateSettings,
+            setWallet,
+            setWalletExpirationSeconds,
+            setupTotp: () => authService.setupTotp(),
+            confirmTotp: (code) => authService.confirmTotp(code),
+            verifyTotpLogin: (pendingTotpToken, code) => authService.verifyTotpLogin(pendingTotpToken, code),
+            token,
+            user: frontendUser,
+            userData: user,
+            userSettings,
+            verifyToken,
+            wallet: walletManager.value,
+            walletExpirationSeconds,
+        };
+        // authenticatedApi is intentionally excluded as it's a stable reference from useMemo
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        authState,
+        backupCodeLogin,
+        changePassword,
+        checkAuth,
+        clearMnemonic,
+        clearWallet,
+        colorMode,
+        directLogin,
+        emailChallengeLogin,
+        frontendUser,
+        getMnemonicRemainingTime,
+        getWalletRemainingTime,
+        isAuthenticated,
+        isCheckingAuth,
+        isGlobalAdmin,
+        isBrowserPasswordLoginAvailable,
+        loading,
+        logout,
+        mnemonicManager.value,
+        mnemonicExpirationSeconds,
+        passwordLogin,
+        refreshToken,
+        register,
+        requestEmailLogin,
+        serverPublicKey,
+        setMnemonic,
+        setMnemonicExpirationSeconds,
+        setUpBrowserPasswordLogin,
+        setUserSettingAndUpdateSettings,
+        setWallet,
+        setWalletExpirationSeconds,
+        token,
+        user,
+        userSettings,
+        verifyToken,
+        walletManager.value,
+        walletExpirationSeconds,
+    ]);
+    return ((0, jsx_runtime_1.jsx)(exports.AuthContext.Provider, { value: contextValue, children: children }));
+};
+const AuthProvider = ({ children, baseUrl, constants, eciesConfig, onLogout, emailDomain, }) => {
+    return ((0, jsx_runtime_1.jsx)(AuthProviderInner, { baseUrl: baseUrl, constants: constants, eciesConfig: eciesConfig, onLogout: onLogout, emailDomain: emailDomain, children: children }));
+};
+exports.AuthProvider = AuthProvider;
+const useAuth = () => {
+    return (0, react_1.useContext)(exports.AuthContext);
+};
+exports.useAuth = useAuth;

package/src/contexts/I18nProvider.d.ts

@@ -0,0 +1,27 @@
+import { FC, ReactNode } from 'react';
+/**
+ * Minimal structural interface accepted by I18nProvider.
+ * Both I18nEngine and PluginI18nEngine satisfy this interface.
+ */
+export interface II18nEngineCompat {
+    setLanguage(language: string): void;
+    translate(componentId: string, stringKey: string, variables?: Record<string, string | number>, language?: string): string;
+    translateStringKey?(key: string, vars?: Record<string, string | number>, language?: string): string;
+    /** Template processor that handles {{component.key}} and {variable} patterns */
+    t?(template: string, variables?: Record<string, string | number>, language?: string): string;
+}
+export interface I18nProviderProps {
+    children: ReactNode;
+    i18nEngine: II18nEngineCompat;
+    onLanguageChange?: (language: string) => Promise<void>;
+}
+export interface I18nContextType {
+    t: (key: string, vars?: Record<string, string | number>, language?: string) => string;
+    tBranded: <TStringKey extends string>(stringKey: TStringKey, vars?: Record<string, string | number>, language?: string) => string;
+    tComponent: <TStringKey extends string>(componentId: string, stringKey: TStringKey, vars?: Record<string, string | number>, language?: string) => string;
+    changeLanguage: (language: string) => void;
+    currentLanguage: string;
+}
+export declare const I18nProvider: FC<I18nProviderProps>;
+export declare const useI18n: () => I18nContextType;
+//# sourceMappingURL=I18nProvider.d.ts.map

package/src/contexts/I18nProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"I18nProvider.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-express-suite-react-components/src/contexts/I18nProvider.tsx"],"names":[],"mappings":"AAKA,OAAO,EAEL,EAAE,EACF,SAAS,EAIV,MAAM,OAAO,CAAC;AAEf;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3C,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAAC;IACV,kBAAkB,CAAC,CACjB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAAC;IACV,gFAAgF;IAChF,CAAC,CAAC,CACA,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3C,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAAC;CACX;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,SAAS,CAAC;IACpB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,CACD,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EACtC,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC;IACZ,QAAQ,EAAE,CAAC,UAAU,SAAS,MAAM,EAClC,SAAS,EAAE,UAAU,EACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EACtC,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC;IACZ,UAAU,EAAE,CAAC,UAAU,SAAS,MAAM,EACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,UAAU,EACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EACtC,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAC;IACZ,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,eAAe,EAAE,MAAM,CAAC;CACzB;AAID,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CAuF9C,CAAC;AAEF,eAAO,MAAM,OAAO,uBAMnB,CAAC"}

package/src/contexts/I18nProvider.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useI18n = exports.I18nProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const i18n_lib_1 = require("@digitaldefiance/i18n-lib");
+const react_1 = require("react");
+const I18nContext = (0, react_1.createContext)(undefined);
+const I18nProvider = ({ children, i18nEngine, onLanguageChange, }) => {
+    const context = i18n_lib_1.GlobalActiveContext.getInstance();
+    const [currentLanguage, setCurrentLanguage] = (0, react_1.useState)(context.userLanguage);
+    const changeLanguage = (0, react_1.useCallback)(async (language) => {
+        const languageDetails = i18n_lib_1.LanguageRegistry.getLanguageByCode(language);
+        if (language && languageDetails) {
+            context.userLanguage = language;
+            i18nEngine.setLanguage(language);
+            localStorage.setItem('language', languageDetails.name);
+            localStorage.setItem('languageCode', language);
+            setCurrentLanguage(language);
+            if (onLanguageChange) {
+                await onLanguageChange(language);
+            }
+        }
+    }, [onLanguageChange, i18nEngine, context]);
+    const tBranded = (0, react_1.useCallback)((key, vars, language) => {
+        if (!i18nEngine.translateStringKey)
+            return `[${key}]`;
+        return i18nEngine.translateStringKey(key, vars, language ?? currentLanguage);
+    }, [i18nEngine, currentLanguage]);
+    const t = (0, react_1.useCallback)((key, vars, language) => {
+        // If the engine has a template processor and the key looks like a template
+        // (contains {{...}} or {variable} patterns), use t() for template resolution
+        if (i18nEngine.t && (/\{\{/.test(key) || /\{[A-Za-z]/.test(key))) {
+            return i18nEngine.t(key, vars, language ?? currentLanguage);
+        }
+        if (i18nEngine.translateStringKey) {
+            return i18nEngine.translateStringKey(key, vars, language ?? currentLanguage);
+        }
+        return `[${key}]`;
+    }, [i18nEngine, currentLanguage]);
+    const tComponent = (0, react_1.useCallback)((componentId, stringKey, vars, language) => {
+        return i18nEngine.translate(componentId, stringKey, vars, language ?? currentLanguage);
+    }, [currentLanguage, i18nEngine]);
+    const value = {
+        t,
+        tComponent,
+        tBranded,
+        changeLanguage,
+        currentLanguage,
+    };
+    return (0, jsx_runtime_1.jsx)(I18nContext.Provider, { value: value, children: children });
+};
+exports.I18nProvider = I18nProvider;
+const useI18n = () => {
+    const context = (0, react_1.useContext)(I18nContext);
+    if (context === undefined) {
+        throw new Error('useI18n must be used within an I18nProvider');
+    }
+    return context;
+};
+exports.useI18n = useI18n;

package/src/contexts/MenuContext.d.ts

@@ -0,0 +1,28 @@
+import { FC, ReactNode } from 'react';
+import { IMenuConfig } from '../interfaces/IMenuConfig';
+import { IMenuOption } from '../interfaces/IMenuOption';
+import { MenuType } from '../types/MenuType';
+interface MenuProviderProps {
+    children: ReactNode;
+    menuConfigs?: IMenuConfig[];
+    enableBackupCodes?: boolean;
+    /**
+     * IDs of menu options to suppress from every menu. Matches both the built-in
+     * options (e.g. 'change-password', 'user-settings', 'logout') and any option
+     * registered via `menuConfigs`. Dividers left orphaned by the removal are
+     * cleaned up automatically. Defaults to none hidden, so existing consumers are
+     * unaffected.
+     */
+    hiddenMenuIds?: readonly string[];
+}
+interface MenuContextType {
+    menuOptions: IMenuOption[];
+    getMenuOptions: (menuType: MenuType, includeDividers: boolean) => IMenuOption[];
+    registerMenuOption: (option: IMenuOption) => () => void;
+    registerMenuOptions: (options: IMenuOption[]) => () => void;
+    getTopMenus: () => Array<IMenuConfig>;
+}
+export declare const MenuProvider: FC<MenuProviderProps>;
+export declare const useMenu: () => MenuContextType;
+export {};
+//# sourceMappingURL=MenuContext.d.ts.map

package/src/contexts/MenuContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuContext.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-express-suite-react-components/src/contexts/MenuContext.tsx"],"names":[],"mappings":"AAqBA,OAAO,EACL,EAAE,EACF,SAAS,EAQV,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAa,MAAM,mBAAmB,CAAC;AAMxD,UAAU,iBAAiB;IACzB,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,EAAE,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,UAAU,eAAe;IACvB,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,cAAc,EAAE,CACd,QAAQ,EAAE,QAAQ,EAClB,eAAe,EAAE,OAAO,KACrB,WAAW,EAAE,CAAC;IACnB,kBAAkB,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,IAAI,CAAC;IACxD,mBAAmB,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,MAAM,IAAI,CAAC;IAC5D,WAAW,EAAE,MAAM,KAAK,CAAC,WAAW,CAAC,CAAC;CACvC;AAID,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CA4V9C,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,eAM1B,CAAC"}