@digitaldefiance/express-suite-react-components 2.1.42 → 2.1.47

package/src/contexts/AuthProvider.js

@@ -0,0 +1,406 @@
+"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 react_1 = require("react");
+const react_router_dom_1 = require("react-router-dom");
+const I18nProvider_1 = require("./I18nProvider");
+const authService_1 = require("../services/authService");
+const authenticatedApi_1 = require("../services/authenticatedApi");
+const useExpiringValue_1 = require("../hooks/useExpiringValue");
+const useLocalStorage_1 = require("../hooks/useLocalStorage");
+const suite_core_lib_1 = require("@digitaldefiance/suite-core-lib");
+exports.AuthContext = (0, react_1.createContext)({});
+const AuthProviderInner = ({ children, baseUrl, constants, eciesConfig }) => {
+    const { changeLanguage, currentLanguage, t, tComponent } = (0, I18nProvider_1.useI18n)();
+    const authService = (0, react_1.useMemo)(() => (0, authService_1.createAuthService)(constants, baseUrl, eciesConfig), [constants, baseUrl, eciesConfig]);
+    // 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);
+    const navigate = (0, react_router_dom_1.useNavigate)();
+    const [currencyCode, setCurrencyCode] = (0, react_1.useState)(() => {
+        return new i18n_lib_1.CurrencyCode(localStorage.getItem('currencyCode') ?? i18n_lib_1.DefaultCurrencyCode);
+    });
+    // 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.
+    // Important: do NOT depend on currentLanguage here, or we'll run when the UI
+    // language changes and inadvertently revert to the older user.siteLanguage,
+    // causing a second update request with English US.
+    (0, react_1.useEffect)(() => {
+        if (user?.siteLanguage && user.siteLanguage !== currentLanguage) {
+            void changeLanguage(user.siteLanguage);
+        }
+        // We intentionally only react to changes in the user's saved language.
+        // 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);
+    }, [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);
+    }, [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);
+            clearMnemonic();
+            clearWallet();
+            return;
+        }
+        try {
+            const userData = await authService.verifyToken(token);
+            if ('error' in userData && typeof userData.error === 'string') {
+                setIsAuthenticated(false);
+                setToken(null);
+            }
+            else {
+                setUser(userData);
+                setIsGlobalAdmin(userData.roles.some((r) => r.admin));
+                setIsAuthenticated(true);
+                setToken(token);
+            }
+        }
+        catch (error) {
+            console.error('Token verification failed:', error);
+            setUser(null);
+            setIsAuthenticated(false);
+            localStorage.removeItem('authToken');
+        }
+        finally {
+            setLoading(false);
+            setIsCheckingAuth(false);
+        }
+    }, [authService, clearMnemonic, clearWallet]);
+    (0, react_1.useEffect)(() => {
+        const token = localStorage.getItem('authToken');
+        if (token) {
+            (async () => {
+                await checkAuth();
+            })();
+        }
+        else {
+            setLoading(false);
+            setIsCheckingAuth(false);
+        }
+    }, [checkAuth, authState]);
+    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));
+            return loginResult;
+        }
+        return loginResult;
+    }, [authService, setMnemonic, setWallet]);
+    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));
+            return loginResult;
+        }
+        return loginResult;
+    }, [authService, setMnemonic, setWallet]);
+    const getPasswordLoginService = (0, react_1.useCallback)(() => {
+        const eciesService = new ecies_lib_1.ECIESService(eciesConfig);
+        return new ecies_lib_1.PasswordLoginService(eciesService, new ecies_lib_1.Pbkdf2Service(ecies_lib_1.Constants.PBKDF2_PROFILES, ecies_lib_1.Constants.ECIES, ecies_lib_1.Constants.PBKDF2));
+    }, [eciesConfig]);
+    const isPasswordLoginAvailable = (0, react_1.useCallback)(() => {
+        const storedEncryptedPassword = localStorage.getItem('encryptedPassword');
+        return !!storedEncryptedPassword;
+    }, []);
+    const passwordLogin = (0, react_1.useCallback)(async (password, username, email) => {
+        if (!isPasswordLoginAvailable()) {
+            return { error: t(tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_Setup_NotAvailable)) };
+        }
+        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);
+        return loginResult;
+    }, [authService, getPasswordLoginService, setMnemonic, setWallet, t, tComponent, isPasswordLoginAvailable]);
+    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) => {
+        const registerResult = await authService.register(username, email, timezone, password);
+        return registerResult;
+    }, [baseUrl]);
+    const requestEmailLogin = (0, react_1.useCallback)(async (username, email) => {
+        setLoading(true);
+        const result = await authService.requestEmailLogin(username, email);
+        setLoading(false);
+        return result;
+    }, [baseUrl]);
+    const setUpPasswordLogin = (0, react_1.useCallback)(async (mnemonic, password, username, email) => {
+        setLoading(true);
+        const passwordLoginService = getPasswordLoginService();
+        try {
+            const wallet = await passwordLoginService.setupPasswordLoginLocalStorageBundle(mnemonic, password);
+            setLoading(false);
+            setWallet(wallet);
+            setMnemonic(mnemonic);
+            return { success: true, message: t(tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_Setup_Success)) };
+        }
+        catch {
+            setLoading(false);
+            return { success: false, message: t(tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_Setup_Failure)) };
+        }
+    }, [setMnemonic, setWallet, t, 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);
+            }
+            setAuthState((prev) => prev + 1);
+            return {
+                token: loginResult.token,
+                mnemonic: loginResult.mnemonic,
+                message: loginResult.message,
+                codeCount: loginResult.codeCount,
+            };
+        }
+        return loginResult;
+    }, [baseUrl]);
+    const logout = (0, react_1.useCallback)(async () => {
+        localStorage.removeItem('user');
+        localStorage.removeItem('authToken');
+        clearMnemonic();
+        setUser(null);
+        clearWallet();
+        setIsAuthenticated(false);
+        setAuthState((prev) => prev + 1);
+        navigate('/');
+    }, [navigate, clearMnemonic, clearWallet]);
+    const verifyToken = (0, react_1.useCallback)(async (token) => {
+        const requestUser = await authService.verifyToken(token);
+        if (typeof requestUser === 'object' && 'error' in requestUser) {
+            setIsAuthenticated(false);
+            return false;
+        }
+        else {
+            setUser(requestUser);
+            setIsAuthenticated(true);
+            return true;
+        }
+    }, [baseUrl]);
+    const changePassword = (0, react_1.useCallback)(async (currentPassword, newPassword) => {
+        if (!isPasswordLoginAvailable()) {
+            return { error: t(tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordLogin_Setup_NotAvailable)) };
+        }
+        setLoading(true);
+        try {
+            const passwordLoginService = getPasswordLoginService();
+            const { mnemonic, wallet } = await passwordLoginService.getWalletAndMnemonicFromLocalStorageBundle(new ecies_lib_1.SecureString(currentPassword));
+            if (!mnemonic) {
+                setLoading(false);
+                return { error: t(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: t(tComponent(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.PasswordChange_Success)) };
+        }
+        catch (error) {
+            setLoading(false);
+            return { error: 'Password change failed' };
+        }
+    }, [setMnemonic, setWallet, t, tComponent, isPasswordLoginAvailable]);
+    const contextValue = (0, react_1.useMemo)(() => {
+        const setUserAndLanguage = async (newUser) => {
+            setUser(newUser);
+            setIsAuthenticated(!!newUser);
+        };
+        const setLanguageAndUpdateUser = async (newLanguage) => {
+            changeLanguage(newLanguage);
+        };
+        const setCurrencyCodeAndUpdateStorage = async (code) => {
+            setCurrencyCode(code);
+            localStorage.setItem('currencyCode', code.value);
+        };
+        return {
+            admin: isGlobalAdmin,
+            authState,
+            backupCodeLogin,
+            changePassword,
+            checkAuth,
+            clearMnemonic,
+            clearWallet,
+            currencyCode,
+            directLogin,
+            emailChallengeLogin,
+            getMnemonicRemainingTime,
+            getWalletRemainingTime,
+            isAuthenticated,
+            isCheckingAuth,
+            isPasswordLoginAvailable,
+            language: currentLanguage,
+            loading,
+            logout,
+            mnemonic: mnemonicManager.value,
+            mnemonicExpirationSeconds,
+            passwordLogin,
+            refreshToken,
+            register,
+            requestEmailLogin,
+            serverPublicKey,
+            setCurrencyCode: setCurrencyCodeAndUpdateStorage,
+            setLanguage: setLanguageAndUpdateUser,
+            setMnemonic,
+            setMnemonicExpirationSeconds,
+            setUpPasswordLogin,
+            setUser: setUserAndLanguage,
+            setWallet,
+            setWalletExpirationSeconds,
+            token,
+            user: frontendUser,
+            userData: user,
+            verifyToken,
+            wallet: walletManager.value,
+            walletExpirationSeconds,
+        };
+    }, [
+        authState,
+        backupCodeLogin,
+        changeLanguage,
+        changePassword,
+        checkAuth,
+        clearMnemonic,
+        clearWallet,
+        currencyCode,
+        currentLanguage,
+        directLogin,
+        emailChallengeLogin,
+        frontendUser,
+        getMnemonicRemainingTime,
+        getWalletRemainingTime,
+        isAuthenticated,
+        isCheckingAuth,
+        isGlobalAdmin,
+        isPasswordLoginAvailable,
+        loading,
+        logout,
+        mnemonicManager.value,
+        mnemonicExpirationSeconds,
+        passwordLogin,
+        refreshToken,
+        register,
+        requestEmailLogin,
+        serverPublicKey,
+        setMnemonic,
+        setMnemonicExpirationSeconds,
+        setUpPasswordLogin,
+        setWallet,
+        setWalletExpirationSeconds,
+        token,
+        user,
+        verifyToken,
+        walletManager.value,
+        walletExpirationSeconds,
+    ]);
+    return ((0, jsx_runtime_1.jsx)(exports.AuthContext.Provider, { value: contextValue, children: children }));
+};
+const AuthProvider = ({ children, baseUrl, constants, eciesConfig }) => {
+    const authenticatedApi = (0, react_1.useMemo)(() => (0, authenticatedApi_1.createAuthenticatedApiClient)(baseUrl), [baseUrl]);
+    const handleLanguageChange = async (newLanguage) => {
+        // Only make API call if there's an auth token (user is logged in)
+        const token = localStorage.getItem('authToken');
+        if (!token)
+            return;
+        try {
+            await authenticatedApi.post('/user/language', { language: newLanguage });
+        }
+        catch (error) {
+            console.error('Failed to update user language:', error);
+        }
+    };
+    return ((0, jsx_runtime_1.jsx)(I18nProvider_1.I18nProvider, { i18nEngine: i18n_lib_1.I18nEngine.getInstance(), onLanguageChange: handleLanguageChange, children: (0, jsx_runtime_1.jsx)(AuthProviderInner, { baseUrl: baseUrl, constants: constants, eciesConfig: eciesConfig, children: children }) }));
+};
+exports.AuthProvider = AuthProvider;
+const useAuth = () => {
+    return (0, react_1.useContext)(exports.AuthContext);
+};
+exports.useAuth = useAuth;

package/src/contexts/I18nProvider.d.ts

@@ -1,15 +1,15 @@
-import { CoreLanguageCode, I18nEngine } from '@digitaldefiance/i18n-lib';
+import { I18nEngine } from '@digitaldefiance/i18n-lib';
 import { FC, ReactNode } from 'react';
 export interface I18nProviderProps {
     children: ReactNode;
     i18nEngine: I18nEngine;
-    onLanguageChange?: (language: CoreLanguageCode) => Promise<void>;
+    onLanguageChange?: (language: string) => Promise<void>;
 }
 export interface I18nContextType {
-    t: (key: string, vars?: Record<string, string | number>, language?: CoreLanguageCode) => string;
-    tComponent: <TStringKey extends string>(componentId: string, stringKey: TStringKey) => string;
-    changeLanguage: (language: CoreLanguageCode) => void;
-    currentLanguage: CoreLanguageCode;
+    t: (key: string, 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;

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

@@ -1 +1 @@
-{"version":3,"file":"I18nProvider.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-express-suite-react-components/src/contexts/I18nProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAIhB,UAAU,EACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAiB,EAAE,EAAE,SAAS,EAAqC,MAAM,OAAO,CAAC;AAExF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,SAAS,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,gBAAgB,KAAK,MAAM,CAAC;IAChG,UAAU,EAAE,CAAC,UAAU,SAAS,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,KAAK,MAAM,CAAC;IAC9F,cAAc,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,eAAe,EAAE,gBAAgB,CAAC;CACnC;AAID,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CAoD9C,CAAC;AAEF,eAAO,MAAM,OAAO,uBAMnB,CAAC"}
+{"version":3,"file":"I18nProvider.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-express-suite-react-components/src/contexts/I18nProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,UAAU,EAEX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAiB,EAAE,EAAE,SAAS,EAAqC,MAAM,OAAO,CAAC;AAExF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,SAAS,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACtF,UAAU,EAAE,CAAC,UAAU,SAAS,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACzJ,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,eAAe,EAAE,MAAM,CAAC;CACzB;AAID,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CAoD9C,CAAC;AAEF,eAAO,MAAM,OAAO,uBAMnB,CAAC"}

package/src/contexts/I18nProvider.js

@@ -22,10 +22,10 @@ const I18nProvider = ({ children, i18nEngine, onLanguageChange, }) => {
         }
     }, [onLanguageChange, i18nEngine, context]);
     const t = (0, react_1.useCallback)((key, vars, language) => {
-        return i18nEngine.t(key, vars, language);
-    }, [i18nEngine]);
-    const tComponent = (0, react_1.useCallback)((componentId, stringKey) => {
-        return i18nEngine.translate(componentId, stringKey, undefined, currentLanguage);
+        return i18nEngine.t(key, vars, language ?? currentLanguage);
+    }, [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,

package/src/contexts/MenuContext.d.ts

@@ -0,0 +1,16 @@
+import { FC, ReactNode } from 'react';
+import { IncludeOnMenu } from '../enumerations/IncludeOnMenu';
+import { IMenuOption } from '../interfaces/IMenuOption';
+interface MenuProviderProps {
+    children: ReactNode;
+}
+interface MenuContextType {
+    menuOptions: IMenuOption[];
+    getMenuOptions: (menuType: IncludeOnMenu, includeDividers: boolean) => IMenuOption[];
+    registerMenuOption: (option: IMenuOption) => () => void;
+    registerMenuOptions: (options: IMenuOption[]) => () => void;
+}
+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":"AAeA,OAAO,EACL,EAAE,EACF,SAAS,EAOV,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,UAAU,iBAAiB;IACzB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,eAAe;IACvB,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,cAAc,EAAE,CACd,QAAQ,EAAE,aAAa,EACvB,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;CAC7D;AAID,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CAwN9C,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,eAM1B,CAAC"}