minitest2.0 0.0.0

package/src/core/mxApi/index.ts

@@ -0,0 +1,451 @@
+/**
+ * 敏行 AJAX 支持的 HTTP 请求类型。
+ *
+ * 该枚举范围来自 MXCommon.ajax 文档；未包含 PATCH，
+ * 调用方如需 PATCH 应在业务请求中提前处理。
+ */
+export type MXAjaxType = 'GET' | 'POST' | 'PUT' | 'DELETE'
+
+/**
+ * MXCommon.ajax 入参。
+ *
+ * 这里只保留敏行 AJAX 文档中明确支持的公共字段：
+ * - type: 请求方式，默认 GET
+ * - url: 请求地址
+ * - dataType: 返回数据格式
+ * - async: 是否异步请求，默认 true
+ * - data: 请求数据，兼容实际宿主能力透传
+ * - headers: 请求头，兼容实际宿主能力透传
+ * - success/error/complete: 宿主回调
+ */
+export interface MXAjaxParams {
+  /** 请求方式，未传时按敏行文档默认 GET。 */
+  type?: MXAjaxType
+  /** 请求地址，可以是完整 URL，也可以由调用方传入业务接口路径。 */
+  url: string
+  /** 返回数据格式，例如 text/json，具体支持范围以敏行宿主为准。 */
+  dataType?: string
+  /** 是否异步请求，未传时默认 true。 */
+  async?: boolean
+  /** 请求数据，原样透传给敏行宿主。 */
+  data?: unknown
+  /** 请求头，原样透传给敏行宿主。 */
+  headers?: Record<string, string>
+  /** 请求成功回调，收到的是宿主原始返回值。 */
+  success?: (data: unknown) => void
+  /** 请求失败回调，收到的是宿主原始错误值。 */
+  error?: (data: unknown) => void
+  /** 请求完成回调，无论成功或失败都由宿主触发。 */
+  complete?: () => void
+}
+
+/**
+ * Promise 化后的 AJAX 返回结构。
+ *
+ * 敏行宿主以回调返回原始数据；封装层会尝试 JSON.parse，
+ * 成功则返回解析后的对象，失败则保留原始数据。
+ */
+export interface MXAjaxResponse<T = unknown> {
+  data: T
+}
+
+/**
+ * 获取 APP token 成功回调。
+ */
+export type MXAppTokenSuccess = (token: string) => void
+
+/**
+ * 获取 APP token 失败回调。
+ */
+export type MXAppTokenError = (error: unknown) => void
+
+/**
+ * MXCommon.getEncryptString 入参。
+ */
+interface MXGetEncryptStringOptions {
+  onSuccess: MXAppTokenSuccess
+  onError?: MXAppTokenError
+}
+
+/**
+ * MXCommon 宿主能力。
+ */
+interface MXCommonHost {
+  ajax?: (options: MXAjaxParams) => void
+  getEncryptString?: (options: MXGetEncryptStringOptions) => void
+}
+
+/**
+ * NXCommon 宿主能力。
+ *
+ * 当前只用于 AJAX 兜底，不用于获取 APP token。
+ */
+interface NXCommonHost {
+  ajax?: (options: MXAjaxParams) => void
+}
+
+export type MXWebuiSideSlot = {
+  default?: boolean
+  hidden?: boolean
+  disable?: boolean
+  content?: string | 'default'
+  action?: (() => void) | 'default' | 'custom' | 'native' | 'both'
+  preventDefault?: boolean
+}
+
+export type MXWebuiTitleSlot = {
+  default?: boolean
+  hidden?: boolean
+  title?: string
+  subtitle?: string
+}
+
+export type MXWebuiInteractiveSlot = {
+  default?: boolean
+  hidden?: boolean
+  title: string[]
+  action?: (idx: number) => void
+  active?: number
+}
+
+export type MXWebuiHeaderSlot = {
+  left?: MXWebuiSideSlot
+  left_1?: MXWebuiSideSlot
+  left_2?: MXWebuiSideSlot
+  middle?: MXWebuiTitleSlot | MXWebuiInteractiveSlot
+  right_1?: MXWebuiSideSlot
+  right_2?: MXWebuiSideSlot
+}
+
+export type MXWebuiCustomHeaderOptions = {
+  slot: MXWebuiHeaderSlot
+  onSuccess?: () => void
+  onFail?: (error: unknown) => void
+}
+
+interface MXWebuiHost {
+  hideWebViewTitle?: () => void
+  showWebViewTitle?: (title?: string) => void
+  setWebViewTitle?: (title: string) => void
+  setNavBgColor?: (bgColor: string) => void
+  closeWindow?: () => void
+  setCustomHeader?: (options: MXWebuiCustomHeaderOptions) => void
+  updateCustomHeader?: (options: MXWebuiCustomHeaderOptions) => void
+}
+
+const DEFAULT_NATIVE_TIMEOUT = 5000
+const NATIVE_POLL_INTERVAL = 100
+
+declare global {
+  /** 敏行旧宿主命名空间。 */
+  const MXCommon: MXCommonHost | undefined
+  /** 敏行新宿主命名空间，部分客户端使用 NXCommon。 */
+  const NXCommon: NXCommonHost | undefined
+  /** 敏行原生 UI 宿主命名空间。 */
+  const MXWebui: MXWebuiHost | undefined
+
+  interface Window {
+    /** 敏行旧宿主命名空间。 */
+    MXCommon?: MXCommonHost
+    /** 敏行新宿主命名空间，部分客户端使用 NXCommon。 */
+    NXCommon?: NXCommonHost
+    /** 敏行原生 UI 宿主命名空间。 */
+    MXWebui?: MXWebuiHost
+  }
+}
+
+/**
+ * 获取当前可用的敏行公共宿主对象。
+ *
+ * 优先使用 MXCommon；如果客户端只注入 NXCommon，则回退到 NXCommon。
+ * 使用 typeof 判断是为了避免全局变量未注入时产生运行时错误。
+ */
+const getHostCommon = () => {
+  return getMXCommon() || getNXCommon()
+}
+
+const getMXCommon = () => (typeof MXCommon !== 'undefined' ? MXCommon : undefined)
+
+const getNXCommon = () => (typeof NXCommon !== 'undefined' ? NXCommon : undefined)
+
+const getMXWebui = () => (typeof MXWebui !== 'undefined' ? MXWebui : undefined)
+
+const getNativeSnapshot = () => ({
+  是否存在MXCommon: typeof MXCommon !== 'undefined',
+  是否存在NXCommon: typeof NXCommon !== 'undefined',
+  是否存在MXWebui: typeof MXWebui !== 'undefined',
+  是否存在MXCommonAjax: typeof MXCommon !== 'undefined' && typeof MXCommon.ajax === 'function',
+  是否存在NXCommonAjax: typeof NXCommon !== 'undefined' && typeof NXCommon.ajax === 'function',
+  是否存在隐藏原生标题栏方法:
+    typeof MXWebui !== 'undefined' && typeof MXWebui.hideWebViewTitle === 'function',
+  是否存在获取Token方法:
+    typeof MXCommon !== 'undefined' && typeof MXCommon.getEncryptString === 'function',
+})
+
+/**
+ * 安全解析宿主返回的数据。
+ *
+ * 敏行 AJAX 示例中 dataType 常使用 text，业务响应可能是 JSON 字符串。
+ * 这里仅在字符串非空且 JSON.parse 成功时转换；否则保持原值，避免吞掉
+ * 文本响应或宿主返回的非 JSON 数据。
+ */
+const safeJsonParse = (data: unknown) => {
+  if (typeof data !== 'string') return data
+
+  const text = data.trim()
+  if (!text) return data
+
+  try {
+    return JSON.parse(text)
+  } catch {
+    return data
+  }
+}
+
+/**
+ * 发起敏行 AJAX 请求。
+ *
+ * 该方法做三件事：
+ * 1. 判断当前环境是否存在 MXCommon.ajax / NXCommon.ajax。
+ * 2. 补齐敏行文档默认值，例如 type=GET、async=true。
+ * 3. 将宿主回调包装成 Promise，同时保留调用方传入的回调。
+ *
+ * @param options 敏行 AJAX 请求参数
+ * @returns Promise 化后的请求结果
+ */
+export function ajax<T = unknown>(options: MXAjaxParams): Promise<MXAjaxResponse<T>> {
+  return new Promise((resolve, reject) => {
+    const hostCommon = getHostCommon()
+
+    // 非敏行宿主环境无法调用 MXCommon.ajax，直接进入失败链路。
+    if (!hostCommon?.ajax) {
+      const error = new Error('当前环境不支持 MXCommon.ajax')
+      options.error?.(error)
+      options.complete?.()
+      reject(error)
+      return
+    }
+
+    // 透传调用方参数，并补齐敏行文档中的默认请求配置。
+    const requestOptions: MXAjaxParams = {
+      ...options,
+      type: options.type || 'GET',
+      async: options.async ?? true,
+      success(data) {
+        console.log('[敏行AJAX] 原生请求成功返回', {
+          url: requestOptions.url,
+          data: safeJsonParse(data),
+        })
+        // 先保留原始回调行为，再 resolve Promise，避免破坏旧调用方。
+        options.success?.(data)
+        resolve({ data: safeJsonParse(data) as T })
+      },
+      error(data) {
+        const errorData = safeJsonParse(data)
+        console.error('[敏行AJAX] 原生请求失败返回', {
+          url: requestOptions.url,
+          data: errorData,
+        })
+        // error 同样保留调用方回调，再 reject 给 await/catch 使用。
+        options.error?.(errorData)
+        reject(errorData)
+      },
+      complete() {
+        options.complete?.()
+      },
+    }
+
+    // 每次调用敏行 AJAX 前打印完整关键参数，方便原生联调定位问题。
+    console.log('[敏行AJAX] 发起原生请求', {
+      type: requestOptions.type,
+      url: requestOptions.url,
+      dataType: requestOptions.dataType,
+      async: requestOptions.async,
+      data: requestOptions.data,
+      headers: requestOptions.headers,
+      hasSuccessCallback: Boolean(options.success),
+      hasErrorCallback: Boolean(options.error),
+      hasCompleteCallback: Boolean(options.complete),
+    })
+
+    hostCommon.ajax(requestOptions)
+  })
+}
+
+/**
+ * 获取敏行宿主提供的 APP token。
+ *
+ * 宿主文档方法名为 MXCommon.getEncryptString({ onSuccess, onError })，
+ * 这里只做 Promise 化薄封装。
+ *
+ * @returns Promise 化后的 APP token 字符串
+ */
+export function getAppToken(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (typeof MXCommon === 'undefined' || typeof MXCommon.getEncryptString !== 'function') {
+      const error = new Error('当前环境不支持 MXCommon.getEncryptString')
+      console.error('[敏行Token] 获取失败：方法不存在', error)
+      reject(error)
+      return
+    }
+
+    const onSuccess: MXAppTokenSuccess = (token) => {
+      console.log('[敏行Token] 获取成功', {
+        token,
+        是否返回Token: Boolean(token),
+        Token长度: token?.length || 0,
+      })
+      resolve(token)
+    }
+
+    const onError: MXAppTokenError = (error) => {
+      console.error('[敏行Token] 获取失败', error)
+      reject(error)
+    }
+
+    MXCommon.getEncryptString({
+      onSuccess,
+      onError,
+    })
+  })
+}
+
+/**
+ * MXCommon.getEncryptString 的同名封装。
+ *
+ * 保留宿主方法名，方便调用方按敏行文档搜索和使用。
+ */
+export const getEncryptString = getAppToken
+
+function callMXWebui(method: keyof MXWebuiHost, ...args: unknown[]) {
+  const host = getMXWebui()
+  const api = host?.[method]
+
+  if (typeof api !== 'function') {
+    return false
+  }
+
+  try {
+    ;(api as (...params: unknown[]) => unknown)(...args)
+    return true
+  } catch (error) {
+    console.error(`[敏行UI] ${String(method)} 调用失败`, error)
+    return false
+  }
+}
+
+export function hideWebViewTitle() {
+  return callMXWebui('hideWebViewTitle')
+}
+
+export function showWebViewTitle(title?: string) {
+  return typeof title === 'string'
+    ? callMXWebui('showWebViewTitle', title)
+    : callMXWebui('showWebViewTitle')
+}
+
+export function setWebViewTitle(title: string) {
+  return callMXWebui('setWebViewTitle', title)
+}
+
+export function setNavBgColor(bgColor: string) {
+  return callMXWebui('setNavBgColor', bgColor)
+}
+
+export function closeWindow() {
+  return callMXWebui('closeWindow')
+}
+
+export function setCustomHeader(options: MXWebuiCustomHeaderOptions) {
+  return callMXWebui('setCustomHeader', options)
+}
+
+export function updateCustomHeader(options: MXWebuiCustomHeaderOptions) {
+  return callMXWebui('updateCustomHeader', options)
+}
+
+/**
+ * 判断当前页面是否运行在敏行宿主环境中。
+ *
+ * 只要宿主注入了 MXCommon 或 NXCommon，就认为是原生环境。
+ */
+export const isNativeApp = (): boolean =>
+  typeof MXCommon !== 'undefined' ||
+  typeof NXCommon !== 'undefined' ||
+  typeof MXWebui !== 'undefined'
+
+/**
+ * 等待敏行宿主完成注入后再判断是否为 APP 环境。
+ *
+ * 部分客户端会在 deviceready 后才注入 MXCommon/NXCommon。如果页面启动时
+ * 立即同步判断，容易误判为浏览器环境。这里先做一次即时判断；如果还没有
+ * 宿主对象，则等待 deviceready，超过 timeout 后按浏览器环境处理。
+ */
+export function waitNativeReady(timeout = DEFAULT_NATIVE_TIMEOUT): Promise<boolean> {
+  return waitForNativeCapability('原生环境检测', isNativeApp, timeout)
+}
+
+function waitForNativeCapability(
+  label: string,
+  hasCapability: () => boolean,
+  timeout: number,
+): Promise<boolean> {
+  const initialReady = hasCapability()
+
+  console.log('[敏行环境] 开始检测', {
+    检测目标: label,
+    超时时间: timeout,
+    初始是否就绪: initialReady,
+    ...getNativeSnapshot(),
+  })
+
+  if (initialReady) {
+    console.log('[敏行环境] 启动时已就绪', {
+      检测目标: label,
+      ...getNativeSnapshot(),
+    })
+    return Promise.resolve(true)
+  }
+
+  return new Promise((resolve) => {
+    let settled = false
+
+    const finish = (value: boolean, reason: string) => {
+      if (settled) return
+
+      settled = true
+      document.removeEventListener('deviceready', onDeviceReady, false)
+      clearTimeout(timer)
+      clearInterval(interval)
+      console.log('[敏行环境] 检测完成', {
+        检测目标: label,
+        是否就绪: value,
+        完成原因: reason,
+        ...getNativeSnapshot(),
+        结果说明: value ? '敏行能力已就绪' : '敏行能力未就绪',
+      })
+      resolve(value)
+    }
+
+    const onDeviceReady = () => {
+      console.log('[敏行环境] 收到 deviceready 事件', {
+        检测目标: label,
+        ...getNativeSnapshot(),
+      })
+
+      if (hasCapability()) {
+        finish(true, 'deviceready')
+      }
+    }
+
+    const interval = setInterval(() => {
+      if (hasCapability()) {
+        finish(true, 'polling')
+      }
+    }, NATIVE_POLL_INTERVAL)
+
+    const timer = setTimeout(() => finish(false, 'timeout'), timeout)
+
+    document.addEventListener('deviceready', onDeviceReady, false)
+  })
+}

package/src/core/request/index.ts

@@ -0,0 +1,135 @@
+import { ajax, isNativeApp } from '@/core/mxApi'
+import type { MXAjaxType } from '@/core/mxApi'
+import { request as axiosRequest } from '@/utils/request'
+import type { RequestConfig } from '@/utils/request'
+import { appendQuery } from '@/utils/query'
+import { apiConfig } from '@/config/env'
+import type { ApiResponse } from '@/types/api'
+import router from '@/router'
+import {
+  clearAuthTokens,
+  getAuthHeaders,
+  getStoredRefreshToken,
+  REFRESH_TOKEN_URL,
+  refreshAccessToken,
+  type AuthTokenResponse,
+} from '@/utils/auth-token'
+
+export type { RequestConfig } from '@/utils/request'
+
+export function request<R = unknown, T = unknown>(
+  config: RequestConfig<T>,
+): Promise<ApiResponse<R>> {
+  if (isNativeApp()) {
+    return nativeRequest<R, T>(config)
+  }
+
+  return axiosRequest<R, T>(config)
+}
+
+async function nativeRequest<R = unknown, T = unknown>(
+  config: RequestConfig<T>,
+  retried = false,
+): Promise<ApiResponse<R>> {
+  const method = (config.method || 'GET').toUpperCase()
+
+  if (!isMXAjaxType(method)) {
+    throw new Error(`敏行 AJAX 不支持 ${method} 请求`)
+  }
+
+  try {
+    const response = await ajax<ApiResponse<R>>({
+      type: method,
+      url: appendQuery(resolveNativeUrl(config.url), config.params),
+      data: config.data,
+      dataType: 'text',
+      async: true,
+      headers: getCommonHeaders(config.headers, config.skipAuth),
+    })
+
+    return response.data
+  } catch (error) {
+    if (isUnauthorized(error) && !config.skipAuth && !retried) {
+      try {
+        await refreshAccessToken(requestRefreshTokenByNative)
+        return nativeRequest(config, true)
+      } catch (refreshError) {
+        handleRefreshTokenFailed()
+        throw refreshError
+      }
+    }
+
+    throw error
+  }
+}
+
+function getCommonHeaders(headers?: Record<string, string>, skipAuth = false) {
+  return getAuthHeaders(headers, skipAuth)
+}
+
+function isUnauthorized(error: unknown) {
+  const result = error as {
+    status?: number | string
+    statusCode?: number | string
+    code?: number | string
+    response?: {
+      status?: number | string
+      statusCode?: number | string
+    }
+  }
+
+  return (
+    isUnauthorizedCode(result.status) ||
+    isUnauthorizedCode(result.statusCode) ||
+    isUnauthorizedCode(result.code) ||
+    isUnauthorizedCode(result.response?.status) ||
+    isUnauthorizedCode(result.response?.statusCode)
+  )
+}
+
+function isUnauthorizedCode(code: number | string | undefined) {
+  return code === 401 || code === '401' || code === '0401'
+}
+
+async function requestRefreshTokenByNative() {
+  const refreshToken = getStoredRefreshToken()
+
+  if (!refreshToken) {
+    throw new Error('本地不存在 refresh token')
+  }
+
+  const response = await ajax<ApiResponse<AuthTokenResponse> & AuthTokenResponse>({
+    type: 'POST',
+    url: resolveNativeUrl(REFRESH_TOKEN_URL),
+    data: {
+      refreshToken,
+    },
+    dataType: 'text',
+    async: true,
+    headers: getCommonHeaders(undefined, true),
+  })
+
+  if (typeof response.data.code === 'number' && response.data.code !== 0) {
+    throw new Error(response.data.message || '刷新 token 失败')
+  }
+
+  return response.data.data || response.data
+}
+
+function handleRefreshTokenFailed() {
+  clearAuthTokens()
+  router.push('/login')
+}
+
+function isMXAjaxType(method: string): method is MXAjaxType {
+  return method === 'GET' || method === 'POST' || method === 'PUT' || method === 'DELETE'
+}
+
+function resolveNativeUrl(url: string) {
+  if (/^[a-z][a-z\d+\-.]*:\/\//i.test(url)) return url
+
+  const baseURL = apiConfig.baseURL || ''
+  if (!baseURL) return url
+
+  return `${baseURL.replace(/\/+$/, '')}/${url.replace(/^\/+/, '')}`
+}

package/src/main.ts

@@ -0,0 +1,40 @@
+import { createApp } from 'vue'
+import { createPinia } from 'pinia'
+import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'
+import 'vant/lib/index.css'
+import './styles/vant-overrides.css'
+
+import App from './App.vue'
+import router from './router'
+import { useAppStore } from '@/stores/app'
+import { apiConfig, appEnv } from '@/config/env'
+
+const app = createApp(App)
+const pinia = createPinia()
+
+pinia.use(piniaPluginPersistedstate)
+
+app.use(pinia)
+app.use(router)
+
+// 等待原生环境检测完成后再挂载，确保所有组件读到的 isNative 都是正确值
+const appStore = useAppStore()
+await appStore.initNativeDetection()
+
+console.log('[应用启动] 当前运行环境', {
+  当前环境: appEnv,
+  是否原生环境: appStore.isNative,
+  环境说明: appStore.isNative ? '当前是敏行原生环境' : '当前不是敏行原生环境',
+  运行模式: import.meta.env.MODE,
+  接口BaseUrl: apiConfig.baseURL,
+  请求超时时间: apiConfig.timeout,
+  应用版本: __APP_VERSION__,
+})
+
+// 测试环境 + 原生设备：加载 vConsole 调试面板
+if (appStore.isNative) {
+  const { default: VConsole } = await import('vconsole')
+  new VConsole()
+}
+
+app.mount('#app')