nfx-ui 0.34.0 → 0.36.0

package/src/hooks/auth.ts

@@ -25,11 +25,11 @@ import {
   useAuthStore,
 } from "nfx-ui/stores/auth";
 import { ensureDeviceIdStorage } from "nfx-ui/stores/system";
-import { getApiErrorMessage } from "nfx-ui/utils/apiError";
 import { pickProfile } from "nfx-ui/utils/domain/account";
 import { useUnifiedQuery } from "nfx-ui/utils/factory";
 import { safeOr, safeStringable } from "nfx-ui/utils/safe";
-import { useTranslation } from "react-i18next";
+
+import { emitHookError, emitHookSuccess, type HookToastMessages } from "./toast";
 
 export function useAuthQueryScope() {
   const aID = useAuthStore((s) => s.currentAccountId);
@@ -68,21 +68,20 @@ export function useCurrentProfile(): CurrentProfileResult {
   } as CurrentProfileResult;
 }
 
-export const useSendVerificationCode = () => {
+export const useSendVerificationCode = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (params: Signup.Request.SendVerificationCode) => auth.SendVerificationCode(params),
     onSuccess: () => {
-      systemEventEmitter.showSuccess(t("sendVerificationCodeSuccess", { defaultValue: "Code sent" }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSendVerificationCode] error"));
+      emitHookError(error, options, "[useSendVerificationCode] error");
     },
   });
 };
 
-export const useSignupWithEmail = () => {
+export const useSignupWithEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   return useMutation({
     mutationFn: async ({
@@ -117,12 +116,12 @@ export const useSignupWithEmail = () => {
       }
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSignup] error"));
+      emitHookError(error, options, "[useSignup] error");
     },
   });
 };
 
-export const useLoginWithEmail = () => {
+export const useLoginWithEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   return useMutation({
     mutationFn: async ({ rememberMe, ...params }: { email: string; password: string; rememberMe: boolean }) =>
@@ -144,12 +143,12 @@ export const useLoginWithEmail = () => {
       if (result.accountId) setCurrentAccountId(result.accountId);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useLogin] error"));
+      emitHookError(error, options, "[useLogin] error");
     },
   });
 };
 
-export const useLoginWithPhone = () => {
+export const useLoginWithPhone = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   return useMutation({
     mutationFn: async ({ rememberMe, ...params }: { phone: string; password: string; rememberMe: boolean }) =>
@@ -171,12 +170,14 @@ export const useLoginWithPhone = () => {
       if (result.accountId) setCurrentAccountId(result.accountId);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useLoginWithPhone] error"));
+      emitHookError(error, options, "[useLoginWithPhone] error");
     },
   });
 };
 
-export type SelectProfileOptions = {
+export type SelectProfileOptions = HookToastMessages & {
+  /** 已翻译的加载文案。Host-translated loading copy. */
+  switchingMsg?: string;
   /** 与 token、档案同一次提交里执行（例如跳到该档案的首页）。Runs in the same commit as the token and profile. */
   onCommit?: () => void;
 };
@@ -191,68 +192,74 @@ export const useSelectProfile = (options?: SelectProfileOptions) => {
         kind,
         deviceId: await ensureDeviceIdStorage(),
       }),
+    onMutate: () => {
+      if (options?.switchingMsg) systemEventEmitter.showLoading(options.switchingMsg);
+    },
     onSuccess: (result, variables) => {
-      if (!result?.accessToken) return;
-      // 同一次提交写入新 token 和档案，旧角色的请求在重拉前先停用。
-      flushSync(() => {
-        setTokens({
-          accessToken: result.accessToken,
-          refreshToken: safeStringable(result.refreshToken),
+      try {
+        if (!result?.accessToken) return;
+        // 同一次提交写入新 token 和档案，旧角色的请求在重拉前先停用。
+        flushSync(() => {
+          setTokens({
+            accessToken: result.accessToken,
+            refreshToken: safeStringable(result.refreshToken),
+          });
+          setCurrentProfileKind(variables.kind);
+          if (result.profileId) setCurrentProfileId(result.profileId);
+          options?.onCommit?.();
         });
-        setCurrentProfileKind(variables.kind);
-        if (result.profileId) setCurrentProfileId(result.profileId);
-        options?.onCommit?.();
-      });
-      authEventEmitter.emit(authEvents.LOGIN_SUCCESS, result.accountId);
+        authEventEmitter.emit(authEvents.LOGIN_SUCCESS, result.accountId);
+      } finally {
+        systemEventEmitter.hideLoading();
+      }
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSelectProfile] error"));
+      systemEventEmitter.hideLoading();
+      emitHookError(error, options, "[useSelectProfile] error");
     },
   });
 };
 
-export const usePatchProfile = (options?: { silent?: boolean }) => {
+export const usePatchProfile = (options?: { silent?: boolean } & HookToastMessages) => {
   const auth = useAuthRepository();
   const { kind } = useAuthQueryScope();
   const silent = safeOr(options?.silent, false);
-  const { t } = useTranslation("pages.User.Profile.Edit");
   return useMutation({
     mutationFn: (body: Profile.Request.PatchProfile) => auth.PatchProfile(kind, body),
     onSuccess: () => {
-      if (!silent) systemEventEmitter.showSuccess(t("saveSuccess", { defaultValue: "Saved" }));
+      if (!silent) emitHookSuccess(options);
       const aID = AuthStore.getState().currentAccountId;
       authEventEmitter.invalidateProfiles({ aID, kind });
     },
     onError: (error: AxiosError) => {
-      if (!silent) systemEventEmitter.showError(getApiErrorMessage(error, "[usePatchProfile] error"));
+      emitHookError(error, options, "[usePatchProfile] error", silent);
     },
   });
 };
 
-export const useUpdateProfileSettings = () => {
+export const useUpdateProfileSettings = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const { kind } = useAuthQueryScope();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (body: Profile.Request.PatchProfileSettings) => auth.PatchProfileSettings(kind, body),
     onSuccess: () => {
       const aID = AuthStore.getState().currentAccountId;
       authEventEmitter.emit(authEvents.UPDATE_ACCOUNT_SUCCESS, aID);
-      systemEventEmitter.showSuccess(t("updateSettingsSuccess", { defaultValue: "Settings updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useUpdateProfileSettings] error"));
+      emitHookError(error, options, "[useUpdateProfileSettings] error");
     },
   });
 };
 
-export const useUpdatePreference = () => {
+export const useUpdatePreference = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const { kind } = useAuthQueryScope();
   return useMutation({
     mutationFn: (preference: string) => auth.UpdatePreference(kind, preference),
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useUpdatePreference] error"));
+      emitHookError(error, options, "[useUpdatePreference] error");
     },
   });
 };
@@ -268,7 +275,7 @@ export const useListProfiles = <K extends ProfileKindEnum>(kind: K) => {
   );
 };
 
-export const useCreateForgerProfile = () => {
+export const useCreateForgerProfile = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   return useMutation({
     mutationFn: (body: Login.Request.CreateForgerProfile) => auth.CreateForgerProfile(body),
@@ -277,12 +284,12 @@ export const useCreateForgerProfile = () => {
       authEventEmitter.invalidateProfiles({ aID, kind: ProfileKindEnum.COMMUNITY });
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useCreateForgerProfile] error"));
+      emitHookError(error, options, "[useCreateForgerProfile] error");
     },
   });
 };
 
-export const useCreateAuthorityProfile = () => {
+export const useCreateAuthorityProfile = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   return useMutation({
     mutationFn: (body: Login.Request.CreateAuthorityProfile) => auth.CreateAuthorityProfile(body),
@@ -291,12 +298,12 @@ export const useCreateAuthorityProfile = () => {
       authEventEmitter.invalidateProfiles({ aID, kind: ProfileKindEnum.AUTHORITY });
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useCreateAuthorityProfile] error"));
+      emitHookError(error, options, "[useCreateAuthorityProfile] error");
     },
   });
 };
 
-export const useDeleteProfile = () => {
+export const useDeleteProfile = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   return useMutation({
     mutationFn: ({ kind, profileId }: { kind: ProfileKindEnum; profileId: string }) => auth.DeleteProfile(kind, profileId),
@@ -305,12 +312,12 @@ export const useDeleteProfile = () => {
       authEventEmitter.invalidateProfiles({ aID, kind: variables.kind });
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useDeleteProfile] error"));
+      emitHookError(error, options, "[useDeleteProfile] error");
     },
   });
 };
 
-export const useConfirmProfileAvatar = () => {
+export const useConfirmProfileAvatar = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const { kind } = useAuthQueryScope();
   return useMutation({
@@ -320,24 +327,23 @@ export const useConfirmProfileAvatar = () => {
       authEventEmitter.emit(authEvents.UPDATE_ACCOUNT_SUCCESS, aID);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useConfirmProfileAvatar] error"));
+      emitHookError(error, options, "[useConfirmProfileAvatar] error");
     },
   });
 };
 
-export const useClearProfileAvatar = () => {
+export const useClearProfileAvatar = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const { kind } = useAuthQueryScope();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: () => auth.ClearProfileAvatar(kind),
     onSuccess: () => {
       const aID = AuthStore.getState().currentAccountId;
       authEventEmitter.emit(authEvents.UPDATE_ACCOUNT_SUCCESS, aID);
-      systemEventEmitter.showSuccess(t("clearAvatarSuccess", { defaultValue: "Avatar removed." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useClearProfileAvatar] error"));
+      emitHookError(error, options, "[useClearProfileAvatar] error");
     },
   });
 };
@@ -358,131 +364,123 @@ export const useListPhones = () => {
   });
 };
 
-export const useCreateEmail = () => {
+export const useCreateEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (body: Login.Request.CreateEmail) => auth.CreateEmail(body),
     onSuccess: () => {
       authEventEmitter.invalidateEmails(accountId);
-      systemEventEmitter.showSuccess(t("createEmailSuccess", { defaultValue: "Email added." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useCreateEmail] error"));
+      emitHookError(error, options, "[useCreateEmail] error");
     },
   });
 };
 
-export const useSendEmailVerificationCode = () => {
+export const useSendEmailVerificationCode = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: ({ emailId, lang }: { emailId: string; lang?: LanguageEnum }) => auth.SendEmailVerificationCode(emailId, { lang }),
     onSuccess: () => {
-      systemEventEmitter.showSuccess(t("sendVerificationCodeSuccess", { defaultValue: "Code sent" }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSendEmailVerificationCode] error"));
+      emitHookError(error, options, "[useSendEmailVerificationCode] error");
     },
   });
 };
 
-export const useVerifyEmail = () => {
+export const useVerifyEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: ({ emailId, verificationCode }: { emailId: string; verificationCode: string }) =>
       auth.VerifyEmail(emailId, { verificationCode }),
     onSuccess: () => {
       authEventEmitter.invalidateEmails(accountId);
-      systemEventEmitter.showSuccess(t("verifyEmailSuccess", { defaultValue: "Email verified." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useVerifyEmail] error"));
+      emitHookError(error, options, "[useVerifyEmail] error");
     },
   });
 };
 
-export const useUpdateEmail = () => {
+export const useUpdateEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: ({ emailId, email }: { emailId: string; email: string }) => auth.UpdateEmail(emailId, { email }),
     onSuccess: () => {
       authEventEmitter.invalidateEmails(accountId);
-      systemEventEmitter.showSuccess(t("updateEmailSuccess", { defaultValue: "Email updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useUpdateEmail] error"));
+      emitHookError(error, options, "[useUpdateEmail] error");
     },
   });
 };
 
-export const useSetPrimaryEmail = () => {
+export const useSetPrimaryEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (emailId: string) => auth.SetPrimaryEmail(emailId),
     onSuccess: () => {
       authEventEmitter.invalidateEmails(accountId);
       authEventEmitter.emit(authEvents.UPDATE_ACCOUNT_SUCCESS, accountId);
-      systemEventEmitter.showSuccess(t("setPrimaryEmailSuccess", { defaultValue: "Primary email updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSetPrimaryEmail] error"));
+      emitHookError(error, options, "[useSetPrimaryEmail] error");
     },
   });
 };
 
-export const useDeleteEmail = () => {
+export const useDeleteEmail = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (emailId: string) => auth.DeleteEmail(emailId),
     onSuccess: () => {
       authEventEmitter.invalidateEmails(accountId);
-      systemEventEmitter.showSuccess(t("deleteEmailSuccess", { defaultValue: "Email removed." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useDeleteEmail] error"));
+      emitHookError(error, options, "[useDeleteEmail] error");
     },
   });
 };
 
-export const useSendChangePasswordVerificationCode = () => {
+export const useSendChangePasswordVerificationCode = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (body: Login.Request.SendChangePasswordVerificationCode = {}) => auth.SendChangePasswordVerificationCode(body),
     onSuccess: () => {
-      systemEventEmitter.showSuccess(t("sendVerificationCodeSuccess", { defaultValue: "Code sent" }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSendChangePasswordVerificationCode] error"));
+      emitHookError(error, options, "[useSendChangePasswordVerificationCode] error");
     },
   });
 };
 
-export const useChangePassword = () => {
+export const useChangePassword = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (body: Login.Request.ChangePassword) => auth.ChangePassword(body),
     onSuccess: () => {
-      systemEventEmitter.showSuccess(t("changePasswordSuccess", { defaultValue: "Password updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useChangePassword] error"));
+      emitHookError(error, options, "[useChangePassword] error");
     },
   });
 };
 
-export const useConfirmProfileBackgrounds = () => {
+export const useConfirmProfileBackgrounds = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const { kind } = useAuthQueryScope();
   return useMutation({
@@ -492,103 +490,97 @@ export const useConfirmProfileBackgrounds = () => {
       authEventEmitter.emit(authEvents.UPDATE_ACCOUNT_SUCCESS, aID);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useConfirmProfileBackgrounds] error"));
+      emitHookError(error, options, "[useConfirmProfileBackgrounds] error");
     },
   });
 };
 
-export const useCreatePhone = () => {
+export const useCreatePhone = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (body: Login.Request.CreatePhone) => auth.CreatePhone(body),
     onSuccess: () => {
       authEventEmitter.invalidatePhones(accountId);
-      systemEventEmitter.showSuccess(t("createPhoneSuccess", { defaultValue: "Phone added." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useCreatePhone] error"));
+      emitHookError(error, options, "[useCreatePhone] error");
     },
   });
 };
 
-export const useSendPhoneVerificationCode = () => {
+export const useSendPhoneVerificationCode = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (phoneId: string) => auth.SendPhoneVerificationCode(phoneId),
     onSuccess: () => {
-      systemEventEmitter.showSuccess(t("sendVerificationCodeSuccess", { defaultValue: "Code sent" }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSendPhoneVerificationCode] error"));
+      emitHookError(error, options, "[useSendPhoneVerificationCode] error");
     },
   });
 };
 
-export const useVerifyPhone = () => {
+export const useVerifyPhone = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: ({ phoneId, verificationCode }: { phoneId: string; verificationCode: string }) =>
       auth.VerifyPhone(phoneId, { verificationCode }),
     onSuccess: () => {
       authEventEmitter.invalidatePhones(accountId);
-      systemEventEmitter.showSuccess(t("verifyPhoneSuccess", { defaultValue: "Phone verified." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useVerifyPhone] error"));
+      emitHookError(error, options, "[useVerifyPhone] error");
     },
   });
 };
 
-export const useUpdatePhone = () => {
+export const useUpdatePhone = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: ({ phoneId, phone }: { phoneId: string; phone: string }) => auth.UpdatePhone(phoneId, { phone }),
     onSuccess: () => {
       authEventEmitter.invalidatePhones(accountId);
-      systemEventEmitter.showSuccess(t("updatePhoneSuccess", { defaultValue: "Phone updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useUpdatePhone] error"));
+      emitHookError(error, options, "[useUpdatePhone] error");
     },
   });
 };
 
-export const useSetPrimaryPhone = () => {
+export const useSetPrimaryPhone = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (phoneId: string) => auth.SetPrimaryPhone(phoneId),
     onSuccess: () => {
       authEventEmitter.invalidatePhones(accountId);
       authEventEmitter.emit(authEvents.UPDATE_ACCOUNT_SUCCESS, accountId);
-      systemEventEmitter.showSuccess(t("setPrimaryPhoneSuccess", { defaultValue: "Primary phone updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useSetPrimaryPhone] error"));
+      emitHookError(error, options, "[useSetPrimaryPhone] error");
     },
   });
 };
 
-export const useDeletePhone = () => {
+export const useDeletePhone = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: (phoneId: string) => auth.DeletePhone(phoneId),
     onSuccess: () => {
       authEventEmitter.invalidatePhones(accountId);
-      systemEventEmitter.showSuccess(t("deletePhoneSuccess", { defaultValue: "Phone removed." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useDeletePhone] error"));
+      emitHookError(error, options, "[useDeletePhone] error");
     },
   });
 };
@@ -652,19 +644,18 @@ export const useListOwnerAuthorityProfiles = (query = "") => {
   );
 };
 
-export const useUpdateAuthorityProfileRoles = () => {
+export const useUpdateAuthorityProfileRoles = (options?: HookToastMessages) => {
   const auth = useAuthRepository();
   const accountId = AuthStore.getState().currentAccountId;
-  const { t } = useTranslation("hooks", { keyPrefix: "account" });
   return useMutation({
     mutationFn: ({ profileId, authorityRoles }: { profileId: string; authorityRoles: Profile.Request.UpdateAuthorityProfileRoles["authorityRoles"] }) =>
       auth.UpdateAuthorityProfileRoles(profileId, { authorityRoles }),
     onSuccess: () => {
       authEventEmitter.invalidateOwner(accountId);
-      systemEventEmitter.showSuccess(t("updateRolesSuccess", { defaultValue: "Roles updated." }));
+      emitHookSuccess(options);
     },
     onError: (error: AxiosError) => {
-      systemEventEmitter.showError(getApiErrorMessage(error, "[useUpdateAuthorityProfileRoles] error"));
+      emitHookError(error, options, "[useUpdateAuthorityProfileRoles] error");
     },
   });
 };

package/src/hooks/index.ts

@@ -1,4 +1,5 @@
 export * from "./preference";
+export * from "./toast";
 export * from "../utils/factory/hooks";
 export * from "./auth";
 export * from "./asset";

package/src/hooks/toast.ts

@@ -0,0 +1,23 @@
+import type { AxiosError } from "axios";
+
+import { systemEventEmitter } from "nfx-ui/events/system";
+import { getApiErrorMessage } from "nfx-ui/utils/apiError";
+
+/**
+ * Host resolves copy with its own `t`, then passes ready-to-show strings.
+ * Package mutation hooks never call `useTranslation`.
+ */
+export type HookToastMessages = {
+  successMsg?: string;
+  failMsg?: string;
+};
+
+export function emitHookSuccess(toasts?: HookToastMessages, silent = false) {
+  if (silent || !toasts?.successMsg) return;
+  systemEventEmitter.showSuccess(toasts.successMsg);
+}
+
+export function emitHookError(error: AxiosError, toasts?: HookToastMessages, fallback = "Request failed", silent = false) {
+  if (silent) return;
+  systemEventEmitter.showError(getApiErrorMessage(error, toasts?.failMsg ?? fallback));
+}

package/src/languages/hooks/useLanguageLabel.ts

@@ -1,5 +1,4 @@
 import i18n from "i18next";
-import { useTranslation } from "react-i18next";
 
 import { BaseEnum } from "nfx-ui/enums/theme";
 import { LanguageEnum } from "../types";
@@ -16,9 +15,9 @@ function getLanguageI18nKey(lang: LanguageEnum): string {
 export function useLanguageLabel(): {
   getLanguageDisplayName: (lang: LanguageEnum) => string;
 } {
-  const { t } = useTranslation("language");
   const getLanguageDisplayName = (lang: LanguageEnum): string =>
-    t(getLanguageI18nKey(lang), {
+    i18n.t(getLanguageI18nKey(lang), {
+      ns: "language",
       defaultValue: lang,
     });
 

package/src/languages/index.ts

@@ -4,6 +4,5 @@
 export * from "./hooks";
 export * from "./languages";
 export { default as i18n } from "./languages/i18n";
-export * from "./resources";
 export * from "./types";
 export * from "./utils";

package/src/languages/languages/i18n.ts

@@ -1,6 +1,6 @@
 /**
- * i18n 初始化与实例：initI18n 由 LanguageProvider 调用。
- * 默认合并 NFX-UI 自带的 theme / language / layout / preference 命名空间。
+ * Shared i18n init — host injects builtin bundles via `getBuiltinBundles`.
+ * Product JSON stays in each console's language folder.
  */
 import type { CreateI18nResourcesResult, ExtraBundleItem, InitI18nOptions } from "../types";
 
@@ -12,8 +12,6 @@ import { LanguageEnum, LANGUAGE_VALUES } from "nfx-ui/enums/language";
 import { PreferenceStore, setPreference } from "nfx-ui/stores/preference";
 import { safeEnum, safeStringable } from "nfx-ui/utils/safe";
 
-import { getDefaultNfxBundles } from "../resources";
-
 export function toSupportedLanguage(lng: string, fallbackLng: LanguageEnum): LanguageEnum {
   const prefix = safeStringable(lng.split("-")[0]?.toLowerCase());
   return safeEnum<LanguageEnum>(prefix || undefined, LANGUAGE_VALUES, fallbackLng);
@@ -43,19 +41,7 @@ export function initI18n(options: InitI18nOptions): void {
     return;
   }
 
-  const nfx = getDefaultNfxBundles();
-  const user: CreateI18nResourcesResult = options.getBuiltinBundles();
-  const RESOURCES = ([LanguageEnum.EN, LanguageEnum.ZH, LanguageEnum.FR] as const).reduce(
-    (acc, lang) => ({
-      ...acc,
-      [lang]: {
-        ...(nfx.RESOURCES[lang] ?? {}),
-        ...(user.RESOURCES[lang] ?? {}),
-      },
-    }),
-    {} as typeof user.RESOURCES,
-  );
-  const NAME_SPACES = [...user.NAME_SPACES, ...nfx.NAME_SPACES.filter((n) => !user.NAME_SPACES.includes(n))];
+  const { RESOURCES, NAME_SPACES }: CreateI18nResourcesResult = options.getBuiltinBundles();
   const initialLng = PreferenceStore.getState().language;
 
   const persistLanguage = (lng: string) => {