@liujitcn/kratos-taro-app-core 0.0.1

package/src/stores/user.ts

@@ -0,0 +1,152 @@
+import Taro from '@tarojs/taro'
+import { create } from 'zustand'
+import { defLoginService } from '../api/base/login'
+import { defOauthService } from '../api/base/oauth'
+import { defAuthService } from '../api/system/auth'
+import type { LoginRequest, LoginResponse } from '../rpc/base/v1/login'
+import type {
+  BindOauthSessionRequest,
+  CreateOauthSessionRequest,
+  CreateOauthSessionResponse,
+} from '../rpc/base/v1/oauth'
+import type { UserProfileForm } from '../rpc/system/app/v1/auth'
+import {
+  clearToken,
+  getRefreshToken,
+  hasValidToken,
+  setRefreshToken,
+  setToken,
+  setTokenExpiresIn,
+} from '../utils/auth'
+import { AUTH_SILENT_LOGOUT_EVENT } from '../utils/http'
+
+const USER_STORAGE_KEY = 'user'
+
+/** 用户状态扩展生命周期处理器。 */
+export interface UserStoreExtension {
+  /** 登录令牌保存完成后执行。 */
+  onLogin?: () => void | Promise<void>
+  /** 用户主动登出并清理本地状态后执行。 */
+  onLogout?: () => void | Promise<void>
+  /** 令牌失效并静默清理本地状态后执行。 */
+  onSilentLogout?: () => void | Promise<void>
+}
+
+/** 用户状态及操作。 */
+export interface UserStoreState {
+  userInfo?: UserProfileForm
+  hydrated: boolean
+  hydrate: () => void
+  isAuthenticated: () => boolean
+  applyLoginToken: (data: LoginResponse | CreateOauthSessionResponse) => Promise<void>
+  login: (request: LoginRequest) => Promise<void>
+  createOauthSession: (
+    request: CreateOauthSessionRequest,
+  ) => Promise<CreateOauthSessionResponse>
+  bindOauthSession: (request: BindOauthSessionRequest) => Promise<void>
+  getUserProfile: () => Promise<UserProfileForm>
+  logout: () => Promise<void>
+  refreshToken: () => Promise<void>
+  clearUserData: () => Promise<void>
+  silentLogout: () => void
+  ensureAuthenticated: () => boolean
+}
+
+const userStoreExtensions = new Set<UserStoreExtension>()
+let eventBridgeStarted = false
+
+/** 注册用户 Store 的业务扩展，返回注销函数。 */
+export function registerUserStoreExtension(extension: UserStoreExtension): () => void {
+  userStoreExtensions.add(extension)
+  return () => userStoreExtensions.delete(extension)
+}
+
+async function runUserStoreExtensions(event: keyof UserStoreExtension): Promise<void> {
+  for (const extension of userStoreExtensions) {
+    try {
+      await extension[event]?.()
+    } catch (error) {
+      console.warn(`user store ${event} extension failed`, error)
+    }
+  }
+}
+
+function persistUserInfo(userInfo?: UserProfileForm): void {
+  if (userInfo) Taro.setStorageSync(USER_STORAGE_KEY, { userInfo })
+  else Taro.removeStorageSync(USER_STORAGE_KEY)
+}
+
+/** 用户 Zustand Store。 */
+export const useUserStore = create<UserStoreState>((set, get) => ({
+  userInfo: undefined,
+  hydrated: false,
+  hydrate() {
+    const cached = Taro.getStorageSync<{ userInfo?: UserProfileForm }>(USER_STORAGE_KEY)
+    set({ userInfo: cached?.userInfo, hydrated: true })
+  },
+  isAuthenticated() {
+    return Boolean(get().userInfo && hasValidToken())
+  },
+  async applyLoginToken(data) {
+    setToken(`${data.token_type} ${data.access_token}`)
+    setRefreshToken(data.refresh_token)
+    setTokenExpiresIn(data.expires_in)
+    await runUserStoreExtensions('onLogin')
+  },
+  async login(request) {
+    await get().applyLoginToken(await defLoginService.Login(request))
+  },
+  async createOauthSession(request) {
+    const response = await defOauthService.CreateOauthSession(request)
+    if (!response.binding_required) await get().applyLoginToken(response)
+    return response
+  },
+  async bindOauthSession(request) {
+    await get().applyLoginToken(await defOauthService.BindOauthSession(request))
+  },
+  async getUserProfile() {
+    const profile = await defAuthService.GetUserProfile({})
+    if (!profile) throw new Error('Verification failed, please Login again.')
+    set({ userInfo: profile })
+    persistUserInfo(profile)
+    return profile
+  },
+  async logout() {
+    await defLoginService.Logout({})
+    await get().clearUserData()
+  },
+  async refreshToken() {
+    const response = await defLoginService.RefreshToken({ refresh_token: getRefreshToken() })
+    setToken(`${response.token_type} ${response.access_token}`)
+    setRefreshToken(response.refresh_token)
+    setTokenExpiresIn(response.expires_in)
+  },
+  async clearUserData() {
+    clearToken()
+    persistUserInfo()
+    set({ userInfo: undefined })
+    await runUserStoreExtensions('onLogout')
+  },
+  silentLogout() {
+    clearToken()
+    persistUserInfo()
+    set({ userInfo: undefined })
+    void runUserStoreExtensions('onSilentLogout')
+  },
+  ensureAuthenticated() {
+    if (get().isAuthenticated()) return true
+    get().silentLogout()
+    return false
+  },
+}))
+
+/** 启动请求层与用户 Store 之间的静默登出事件桥。 */
+export function startUserStoreEventBridge(): void {
+  if (eventBridgeStarted) return
+  eventBridgeStarted = true
+  Taro.eventCenter.on(AUTH_SILENT_LOGOUT_EVENT, () => {
+    persistUserInfo()
+    useUserStore.setState({ userInfo: undefined })
+    void runUserStoreExtensions('onSilentLogout')
+  })
+}

package/src/styles/base.scss

@@ -0,0 +1,45 @@
+page,
+body {
+  min-height: 100%;
+  color: #333;
+  font-size: 16PX;
+  line-height: normal;
+  background: #f7f7f8;
+  font-family:
+    -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Hiragino Sans GB',
+    'Microsoft YaHei', sans-serif;
+}
+
+view,
+scroll-view,
+swiper,
+button,
+input,
+textarea,
+label,
+navigator,
+image {
+  box-sizing: border-box;
+}
+
+button::after {
+  border: 0;
+}
+
+// Taro H5 的默认确认色与 uni-app H5 不同，统一为基线平台色。
+.taro-model__confirm {
+  color: #007aff !important;
+}
+
+// H5 路由页和 ScrollView 同时滚动，隐藏滚动条避免重复占用内容宽度。
+.taro_page,
+.taro-scroll-view__scroll-y {
+  scrollbar-width: none;
+}
+
+.taro_page::-webkit-scrollbar,
+.taro-scroll-view__scroll-y::-webkit-scrollbar {
+  display: none;
+  width: 0;
+  height: 0;
+}

package/src/types/assets.d.ts

@@ -0,0 +1,9 @@
+declare module '*.png' {
+  const source: string
+  export default source
+}
+
+declare module '*.jpg' {
+  const source: string
+  export default source
+}

package/src/utils/auth.ts

@@ -0,0 +1,55 @@
+import Taro from '@tarojs/taro'
+
+const ACCESS_TOKEN_KEY = 'access_token'
+const ACCESS_TOKEN_EXPIRES_IN = 'expiresIn'
+const REFRESH_TOKEN_KEY = 'refresh_token'
+const TOKEN_REFRESH_THRESHOLD = 5 * 60 * 1000
+
+/** 读取访问令牌。 */
+export function getToken(): string {
+  return Taro.getStorageSync<string>(ACCESS_TOKEN_KEY) || ''
+}
+
+/** 保存访问令牌。 */
+export function setToken(token: string): void {
+  Taro.setStorageSync(ACCESS_TOKEN_KEY, token)
+}
+
+/** 读取访问令牌过期时间戳。 */
+export function getTokenExpiresIn(): number {
+  return Number(Taro.getStorageSync<string>(ACCESS_TOKEN_EXPIRES_IN) || '')
+}
+
+/** 按后端返回的秒数保存访问令牌过期时间。 */
+export function setTokenExpiresIn(expiresIn: number): void {
+  Taro.setStorageSync(ACCESS_TOKEN_EXPIRES_IN, String(Date.now() + expiresIn * 1000))
+}
+
+/** 读取刷新令牌。 */
+export function getRefreshToken(): string {
+  return Taro.getStorageSync<string>(REFRESH_TOKEN_KEY) || ''
+}
+
+/** 保存刷新令牌。 */
+export function setRefreshToken(token: string): void {
+  Taro.setStorageSync(REFRESH_TOKEN_KEY, token)
+}
+
+/** 清理本地认证令牌。 */
+export function clearToken(): void {
+  Taro.removeStorageSync(ACCESS_TOKEN_KEY)
+  Taro.removeStorageSync(REFRESH_TOKEN_KEY)
+  Taro.removeStorageSync(ACCESS_TOKEN_EXPIRES_IN)
+}
+
+/** 判断本地访问令牌是否仍在有效期内。 */
+export function hasValidToken(): boolean {
+  const expiresIn = getTokenExpiresIn()
+  return Boolean(getToken() && expiresIn && expiresIn > Date.now())
+}
+
+/** 判断访问令牌是否即将过期，供请求层提前刷新。 */
+export function shouldRefreshToken(): boolean {
+  const expiresIn = getTokenExpiresIn()
+  return Boolean(getToken() && expiresIn && expiresIn - Date.now() <= TOKEN_REFRESH_THRESHOLD)
+}

package/src/utils/file.ts

@@ -0,0 +1,48 @@
+import Taro from '@tarojs/taro'
+import type { FileInfo, MultiUploadFileResponse } from '../rpc/base/v1/file'
+import { formatSrc } from './index'
+import { getRequestAccessToken, requestBaseURL } from './http'
+
+/** 上传单个文件。 */
+export async function uploadFile(fileType: string, filePath: string): Promise<FileInfo> {
+  const token = await getRequestAccessToken()
+  const response = await Taro.uploadFile({
+    url: `${requestBaseURL}/v1/base/file`,
+    name: 'file',
+    filePath,
+    formData: { fileType },
+    header: token ? { Authorization: token, 'source-client': 'miniapp' } : {},
+  })
+  if (response.statusCode !== 200) throw new Error('上传失败')
+  return JSON.parse(response.data) as FileInfo
+}
+
+/** 并发上传文件列表。 */
+export async function uploadFileList(fileType: string, filePaths: string[]): Promise<FileInfo[]> {
+  const results = await Promise.allSettled(filePaths.map((filePath) => uploadFile(fileType, filePath)))
+  return results.flatMap((result) => (result.status === 'fulfilled' ? [result.value] : []))
+}
+
+/** 使用微信小程序 files 参数上传多个文件。 */
+export async function multiUploadFile(
+  fileType: string,
+  files: Array<{ path: string; name?: string }> = [],
+): Promise<FileInfo[]> {
+  const uploaded = await uploadFileList(
+    fileType,
+    files.map((file) => file.path),
+  )
+  const response: MultiUploadFileResponse = { files: uploaded }
+  return response.files
+}
+
+/** 从 URL 构建文件元信息。 */
+export function getFileInfo(url: string): FileInfo {
+  const fullName = url.split(/[\\/]/).pop() || ''
+  if (!fullName) return { name: '', extname: '', url }
+  const dotIndex = fullName.lastIndexOf('.')
+  if (dotIndex > 0) {
+    return { name: fullName, extname: fullName.slice(dotIndex), url: formatSrc(url) }
+  }
+  return { name: fullName, extname: '', url }
+}

package/src/utils/http.ts

@@ -0,0 +1,262 @@
+import Taro from '@tarojs/taro'
+import {
+  clearToken,
+  getRefreshToken,
+  getToken,
+  hasValidToken,
+  setRefreshToken,
+  setToken,
+  setTokenExpiresIn,
+  shouldRefreshToken,
+} from './auth'
+import { saveCurrentRoute } from './navigation'
+
+const apiBasePath = process.env.KRATOS_TARO_API_BASE || '/api'
+const apiTargetUrl = process.env.KRATOS_TARO_API_URL || ''
+const normalizedApiBasePath = apiBasePath.startsWith('/') ? apiBasePath : `/${apiBasePath}`
+const requestOrigin = process.env.TARO_ENV === 'h5' ? '' : apiTargetUrl.replace(/\/$/, '')
+/** 请求基础地址。 */
+export const requestBaseURL = `${requestOrigin}${normalizedApiBasePath}`
+
+const SESSION_URL = '/v1/base/session'
+const REFRESH_TOKEN_URL = '/v1/base/token'
+const CAPTCHA_URL = '/v1/base/captcha'
+const CONFIG_URL = '/v1/base/config'
+const PASSWORD_PUBLIC_KEY_URL = '/v1/base/password-public-key'
+const NO_AUTH_URL_SET = new Set([
+  SESSION_URL,
+  REFRESH_TOKEN_URL,
+  CAPTCHA_URL,
+  CONFIG_URL,
+  PASSWORD_PUBLIC_KEY_URL,
+  '/auth',
+  '/login/captcha',
+  '/auth/token',
+])
+const AUTH_EXPIRED_EXCLUDED_URL_SET = new Set([
+  SESSION_URL,
+  CAPTCHA_URL,
+  CONFIG_URL,
+  PASSWORD_PUBLIC_KEY_URL,
+  '/auth',
+  '/login/captcha',
+])
+/** 认证状态被静默清理的事件名。 */
+export const AUTH_SILENT_LOGOUT_EVENT = 'auth:silent-logout'
+
+/** 接口认证模式。 */
+export type AuthMode = 'none' | 'optional' | 'required'
+/** Taro 请求参数扩展。 */
+export type HttpRequestOptions = Taro.request.Option & { authMode?: AuthMode }
+
+type ErrorData = {
+  code?: string | number
+  message?: string
+  reason?: string | number
+}
+
+const authErrorCodeSet = new Set(['401', '403'])
+const authErrorReasonSet = new Set(['UNAUTHENTICATED', 'PERMISSION_DENIED'])
+let refreshTokenPromise: Promise<void> | null = null
+let isPromptingRelogin = false
+
+function isAuthErrorResponse(data: unknown): boolean {
+  if (!data || typeof data !== 'object') return false
+  const response = data as ErrorData
+  const code = response.code === undefined ? '' : String(response.code)
+  const reason = response.reason === undefined ? '' : String(response.reason)
+  return authErrorCodeSet.has(code) || authErrorCodeSet.has(reason) || authErrorReasonSet.has(reason)
+}
+
+function resolveAuthMode(options: HttpRequestOptions, url: string): AuthMode {
+  if (options.authMode) return options.authMode
+  if (options.header?.Authorization === 'no-auth' || NO_AUTH_URL_SET.has(url)) return 'none'
+  return 'required'
+}
+
+function resolveRequestUrl(url: string): string {
+  return /^https?:\/\//.test(url) ? url : `${requestBaseURL}${url.startsWith('/') ? url : `/${url}`}`
+}
+
+/** 发送经过认证、刷新令牌和统一错误处理的 Taro 请求。 */
+export async function http<T>(options: HttpRequestOptions): Promise<T> {
+  return sendRequest<T>(options, false)
+}
+
+async function sendRequest<T>(
+  options: HttpRequestOptions,
+  retriedAsAnonymous: boolean,
+): Promise<T> {
+  const requestUrl = String(options.url)
+  const authMode = resolveAuthMode(options, requestUrl)
+  let accessToken = ''
+  try {
+    accessToken = await getAccessTokenByMode(
+      retriedAsAnonymous && authMode === 'optional' ? 'none' : authMode,
+    )
+  } catch (error) {
+    if (authMode === 'optional' && !retriedAsAnonymous) {
+      silentClearAuthData()
+      return sendRequest<T>(options, true)
+    }
+    throw error
+  }
+
+  try {
+    const response = await Taro.request({
+      ...options,
+      url: resolveRequestUrl(requestUrl),
+      timeout: options.timeout || 10000,
+      header: {
+        ...options.header,
+        'source-client': 'miniapp',
+        ...(accessToken ? { Authorization: accessToken } : {}),
+      },
+    })
+    const responseData = response.data as ErrorData
+    if (response.statusCode >= 200 && response.statusCode < 300 && !isAuthErrorResponse(responseData)) {
+      return response.data as T
+    }
+    if (
+      response.statusCode === 401 ||
+      response.statusCode === 403 ||
+      isAuthErrorResponse(responseData)
+    ) {
+      if (authMode === 'optional' && !retriedAsAnonymous) {
+        silentClearAuthData()
+        return sendRequest<T>(options, true)
+      }
+      handleAuthExpiredByMode(authMode, requestUrl, responseData)
+      throw response
+    }
+    await Taro.showToast({ icon: 'none', title: responseData.message || '请求错误' })
+    throw response
+  } catch (error) {
+    if (
+      typeof error === 'object' &&
+      error &&
+      ('statusCode' in error || String((error as { errMsg?: string }).errMsg).includes('abort'))
+    ) {
+      throw error
+    }
+    await Taro.showToast({ icon: 'none', title: '网络错误，换个网络试试' })
+    throw error
+  }
+}
+
+/** 获取请求可用访问令牌，供流式请求复用。 */
+export async function getRequestAccessToken(authMode: AuthMode = 'required'): Promise<string> {
+  return getAccessTokenByMode(authMode)
+}
+
+/** 触发登录失效处理，供流式请求复用。 */
+export function handleAuthExpired(authMode: AuthMode = 'required'): void {
+  if (authMode === 'required') void promptRelogin()
+  else silentClearAuthData()
+}
+
+async function getAccessTokenByMode(authMode: AuthMode): Promise<string> {
+  if (authMode === 'none') return ''
+  if (!getToken()) {
+    if (authMode === 'required') {
+      await promptRelogin()
+      throw new Error('auth required')
+    }
+    return ''
+  }
+  if (shouldRefreshToken()) await handleTokenRefresh(authMode)
+  if (hasValidToken()) return getToken()
+  if (authMode === 'required') {
+    await promptRelogin()
+    throw new Error('auth expired')
+  }
+  silentClearAuthData()
+  return ''
+}
+
+function handleTokenRefresh(authMode: AuthMode): Promise<void> {
+  if (refreshTokenPromise) return refreshTokenPromise
+  refreshTokenPromise = refreshAccessToken()
+    .catch(async (error) => {
+      if (authMode === 'required') await promptRelogin()
+      else silentClearAuthData()
+      throw error
+    })
+    .finally(() => {
+      refreshTokenPromise = null
+    })
+  return refreshTokenPromise
+}
+
+async function refreshAccessToken(): Promise<void> {
+  const refreshToken = getRefreshToken()
+  if (!refreshToken) throw new Error('refresh token missing')
+  const response = await Taro.request({
+    url: resolveRequestUrl(REFRESH_TOKEN_URL),
+    method: 'POST',
+    data: { refresh_token: refreshToken },
+    header: { 'source-client': 'miniapp' },
+  })
+  const data = response.data as ErrorData & {
+    token_type?: string
+    access_token?: string
+    refresh_token?: string
+    expires_in?: number
+  }
+  if (
+    response.statusCode < 200 ||
+    response.statusCode >= 300 ||
+    isAuthErrorResponse(data) ||
+    !data.token_type ||
+    !data.access_token ||
+    !data.refresh_token ||
+    !data.expires_in
+  ) {
+    throw response
+  }
+  setToken(`${data.token_type} ${data.access_token}`)
+  setRefreshToken(data.refresh_token)
+  setTokenExpiresIn(data.expires_in)
+}
+
+async function promptRelogin(): Promise<void> {
+  if (isPromptingRelogin) return
+  isPromptingRelogin = true
+  try {
+    const modal = await Taro.showModal({
+      title: '提示',
+      content: '当前页面已失效，请重新登录',
+      showCancel: false,
+      confirmText: '重新登录',
+    })
+    if (!modal.confirm) return
+    await new Promise((resolve) => setTimeout(resolve, 80))
+    clearToken()
+    Taro.removeStorageSync('user')
+    saveCurrentRoute()
+    await Taro.reLaunch({ url: '/pages/login/login' })
+  } finally {
+    isPromptingRelogin = false
+  }
+}
+
+function handleAuthExpiredByMode(
+  authMode: AuthMode,
+  url: string,
+  responseData: ErrorData,
+): void {
+  if (authMode === 'required' && !AUTH_EXPIRED_EXCLUDED_URL_SET.has(url)) {
+    void promptRelogin()
+    return
+  }
+  silentClearAuthData()
+  if (authMode !== 'optional') {
+    void Taro.showToast({ icon: 'none', title: responseData.message || '请求错误' })
+  }
+}
+
+function silentClearAuthData(): void {
+  clearToken()
+  Taro.removeStorageSync('user')
+  Taro.eventCenter.trigger(AUTH_SILENT_LOGOUT_EVENT)
+}

package/src/utils/index.ts

@@ -0,0 +1,35 @@
+const configuredStaticUrl = process.env.KRATOS_TARO_STATIC_URL || ''
+
+/** 日期格式化函数。 */
+export function formatDate(date: Date, format = 'YYYY-MM-DD HH:mm:ss'): string {
+  const year = String(date.getFullYear())
+  const month = String(date.getMonth() + 1).padStart(2, '0')
+  const day = String(date.getDate()).padStart(2, '0')
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  const seconds = String(date.getSeconds()).padStart(2, '0')
+  return format
+    .replace('YYYY', year)
+    .replace('MM', month)
+    .replace('DD', day)
+    .replace('HH', hours)
+    .replace('mm', minutes)
+    .replace('ss', seconds)
+}
+
+/** 将分单位金额格式化为元。 */
+export function formatPrice(price: number): string {
+  return price ? (price / 100).toFixed(2) : '0.00'
+}
+
+/** 格式化后端静态资源地址。 */
+export function formatSrc(src: string): string {
+  if (!src || /^https?:\/\//.test(src)) return src
+  const browserOrigin =
+    typeof window !== 'undefined' && window.location?.origin ? window.location.origin : ''
+  const staticOrigin = browserOrigin || configuredStaticUrl.replace(/\/$/, '')
+  if (!staticOrigin) return src
+  return src.startsWith('/')
+    ? `${staticOrigin}${src}`
+    : `${staticOrigin}/${src.replace(/^\/+/, '')}`
+}

package/src/utils/navigation.ts

@@ -0,0 +1,72 @@
+import Taro, { getCurrentPages } from '@tarojs/taro'
+
+const LAST_ROUTE_KEY = 'lastRoute'
+const LOGIN_PAGE = '/pages/login/login'
+/** 首页 tab 页面路径。 */
+export const homeTabPage = '/pages/index/index'
+
+type RouteQueryValue = string | number | boolean | null | undefined
+
+function buildRouteUrl(path: string, query: Record<string, RouteQueryValue> = {}): string {
+  const queryString = Object.entries(query)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+    .join('&')
+  return queryString ? `${path}?${queryString}` : path
+}
+
+function getCurrentRouteUrl(): string {
+  const pages = getCurrentPages()
+  const currentPage = pages[pages.length - 1] as
+    | {
+        route?: string
+        options?: Record<string, RouteQueryValue>
+        $taroParams?: Record<string, RouteQueryValue>
+      }
+    | undefined
+  if (!currentPage?.route) return ''
+  return buildRouteUrl(
+    `/${currentPage.route}`,
+    currentPage.options ?? currentPage.$taroParams ?? {},
+  )
+}
+
+/** 保存当前页面路由，登录成功后恢复到用户原来的页面。 */
+export function saveCurrentRoute(): void {
+  const currentRoute = getCurrentRouteUrl()
+  if (!currentRoute || currentRoute.startsWith(LOGIN_PAGE)) {
+    Taro.removeStorageSync(LAST_ROUTE_KEY)
+    return
+  }
+  Taro.setStorageSync(LAST_ROUTE_KEY, currentRoute)
+}
+
+/** 保存指定页面路由，供登录成功后继续原访问目标。 */
+export function saveLoginRedirectUrl(url: string): void {
+  const normalizedUrl = url.startsWith('/') ? url : `/${url}`
+  if (!normalizedUrl.startsWith(LOGIN_PAGE)) Taro.setStorageSync(LAST_ROUTE_KEY, normalizedUrl)
+}
+
+/** 读取并清理登录成功后的回跳地址。 */
+export function consumeLoginRedirectUrl(): string {
+  const url = Taro.getStorageSync<string>(LAST_ROUTE_KEY) || ''
+  Taro.removeStorageSync(LAST_ROUTE_KEY)
+  return url
+}
+
+/** 跳转到登录页，并在跳转前记录当前页面。 */
+export function navigateToLogin(redirectUrl?: string): void {
+  if (typeof redirectUrl === 'string' && redirectUrl) saveLoginRedirectUrl(redirectUrl)
+  else saveCurrentRoute()
+  void Taro.navigateTo({
+    url: LOGIN_PAGE,
+    fail: () => {
+      void Taro.reLaunch({ url: LOGIN_PAGE })
+    },
+  })
+}
+
+/** 返回首页。 */
+export function switchTabToHome(): Promise<TaroGeneral.CallbackResult> {
+  return Taro.reLaunch({ url: homeTabPage })
+}