generator-mico-cli 0.2.31 → 0.2.32

package/generators/h5-react/templates/packages/js-bridge/src/getUserInfo.ts

@@ -0,0 +1,96 @@
+import { apiBaseUrl } from '<%= packageScope %>/domain';
+import { isDebug } from '<%= packageScope %>/utils/env';
+import { getURLParams } from '<%= packageScope %>/utils/url';
+import { callJSBridgeMethods } from './call';
+
+export interface GetUserInfoResponse {
+  accessToken: string;
+  uid: number;
+  nickname: string;
+  avatar: string;
+  lang: Lang;
+}
+
+export type Lang = 'en' | 'zh-hant';
+
+interface CallingCache {
+  resolve: (userInfo: GetUserInfoResponse) => void;
+  reject: (error: Error) => void;
+  callback?: (userInfo: GetUserInfoResponse) => void;
+}
+
+async function fetchUserInfo(email: string): Promise<GetUserInfoResponse> {
+  const response = await fetch(`${apiBaseUrl}/v2/api/auth/email/code_login`, {
+    method: 'POST',
+    body: JSON.stringify({
+      email,
+      appId: 'omigo',
+      code: '9999',
+    }),
+    headers: {
+      source: 'web',
+    },
+  });
+  const data = await response.json();
+  const { token, userInfo } = data.content;
+  return {
+    accessToken: token.accessToken,
+    uid: userInfo.uid,
+    nickname: userInfo.nickname,
+    avatar: userInfo.avatar,
+    lang: (getURLParams().get('lang') as Lang) || 'zh-hant',
+  };
+}
+
+/**
+ * 用户信息
+ */
+let _userInfo: GetUserInfoResponse | null = null;
+const callingCache = new Set<CallingCache>();
+export default async function getUserInfo(
+  callback?: (userInfo: GetUserInfoResponse) => void,
+) {
+  if (_userInfo) {
+    callback?.(_userInfo);
+    return _userInfo;
+  }
+  if (!callingCache.size) {
+    callJSBridgeMethods<GetUserInfoResponse>('getUserInfo', null, {
+      showToast: false,
+    })
+      .then((response) => {
+        return response.data;
+      })
+      .catch((error) => {
+        if (isDebug) {
+          // 本地和测试环境使用，线上不要开放！！！
+          return fetchUserInfo(
+            getURLParams().get('email') ?? 'tianyu@micous.com',
+          );
+        }
+        throw error;
+      })
+      .then((userInfo) => {
+        userInfo.lang = userInfo.lang.toLowerCase() as Lang;
+        if (userInfo.lang.startsWith('zh')) {
+          // 临时把中文全部转换为繁体
+          userInfo.lang = 'zh-hant';
+        }
+        _userInfo = userInfo;
+        callingCache.forEach(({ resolve, callback }) => {
+          resolve(userInfo);
+          callback?.(userInfo);
+        });
+        callingCache.clear();
+      })
+      .catch((error) => {
+        callingCache.forEach(({ reject }) => {
+          reject(error);
+        });
+        callingCache.clear();
+      });
+  }
+  return new Promise<GetUserInfoResponse>((resolve, reject) => {
+    callingCache.add({ resolve, reject, callback });
+  });
+}

package/generators/h5-react/templates/packages/js-bridge/src/index.ts

@@ -0,0 +1,15 @@
+import { isAndroid, isIOS } from '<%= packageScope %>/utils/env';
+
+/**
+ * 是否可以使用JSBridge
+ */
+export function canUseJSBridge() {
+  if (isAndroid) {
+    return !!window.Omigo && typeof window.Omigo.post === 'function';
+  } else if (isIOS) {
+    return (
+      !!window.MCAIJsBridge && typeof window.MCAIJsBridge.post === 'function'
+    );
+  }
+  return false;
+}

package/generators/h5-react/templates/packages/js-bridge/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "<%= packageScope %>/typescript/react"
+}

package/generators/h5-react/templates/packages/js-bridge/type.d.ts

@@ -0,0 +1,24 @@
+declare global {
+  interface Window {
+    MCAIJsBridge?: {
+      post?: <D = unknown, T = null>(
+        method: string,
+        payload: T,
+        callback: (response: JSBridgeResponse<D>) => void,
+      ) => void;
+    };
+    Omigo?: {
+      post?: (method: string, payload: T, postID: string) => void;
+    };
+    AndroidJSBridgeCallback?: (
+      postID: string,
+      response: JSBridgeResponse<unknown>,
+    ) => void;
+  }
+}
+
+export interface JSBridgeResponse<D = unknown> {
+  code: number;
+  message: string;
+  data: D;
+}

package/generators/h5-react/templates/packages/request/axios.d.ts

@@ -0,0 +1,42 @@
+export type AxiosRequestConfig<D = any> = {
+  url?: string;
+  method?: string;
+  baseURL?: string;
+  headers?: Record<string, any>;
+  params?: any;
+  data?: D;
+  timeout?: number;
+  responseType?: string;
+  [key: string]: any;
+};
+
+export type AxiosResponse<T = any, D = any> = {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, any>;
+  config: AxiosRequestConfig<D>;
+  request?: any;
+  [key: string]: any;
+};
+
+export type AxiosError<T = any, D = any> = Error & {
+  config?: AxiosRequestConfig<D>;
+  request?: any;
+  response?: AxiosResponse<T, D>;
+  code?: string;
+  status?: number;
+  message?: string;
+  isAxiosError?: boolean;
+  toJSON?: () => Record<string, any>;
+  [key: string]: any;
+};
+
+export type AxiosInstance = {
+  request<T = any, R = AxiosResponse<T>, D = any>(
+    config: AxiosRequestConfig<D>,
+  ): Promise<R>;
+  [key: string]: any;
+};
+
+export type RequestError = AxiosError | Error;

package/generators/h5-react/templates/packages/request/eslint.config.ts

@@ -0,0 +1,17 @@
+import baseConfig from '<%= packageScope %>/eslint';
+import { defineConfig } from 'eslint/config';
+export default defineConfig([
+  ...baseConfig,
+  {
+    languageOptions: {
+      parserOptions: {
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
+  },
+]);

package/generators/h5-react/templates/packages/request/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "<%= packageScope %>/request",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "<%= packageScope %>/domain": "workspace:^",
+    "<%= packageScope %>/js-bridge": "workspace:^"
+  },
+  "devDependencies": {
+    "<%= packageScope %>/eslint": "workspace:^",
+    "<%= packageScope %>/typescript": "workspace:^"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "lint:fix": "eslint --fix"
+  }
+}

package/generators/h5-react/templates/packages/request/src/index.ts

@@ -0,0 +1,165 @@
+/**
+ * 统一请求模块
+ *
+ * 职责：
+ * - 提供统一的 request 函数
+ * - 导出配置和拦截器相关方法
+ *
+ * 模块拆分：
+ * - types.ts: 类型定义
+ * - interceptors.ts: 拦截器管理
+ * - url-resolver.ts: URL 解析
+ */
+
+import { request as rawRequest } from 'umi';
+import { isAxiosError, isNormalResponseError } from './utils';
+
+// 拦截器相关
+import {
+  addRequestInterceptor,
+  addResponseInterceptor,
+  initDefaultInterceptors,
+  runRequestInterceptors,
+  runResponseInterceptors,
+} from './interceptors';
+
+// 类型导出
+import type {
+  NormalResponseData,
+  RequestContext,
+  RequestInterceptor,
+  RequestParams,
+  ResponseData,
+  ResponseError,
+  ResponseInterceptor,
+  UnifiedRequestOptions,
+} from './types';
+
+// URL 解析
+import { resolveRequestUrl } from './url-resolver';
+
+initDefaultInterceptors();
+
+/**
+ * 请求池
+ */
+const requestPool = new Set<UnifiedRequestOptions>();
+
+/**
+ * 统一请求函数
+ */
+export const request = async <
+  T extends ResponseData = NormalResponseData,
+  P extends RequestParams = RequestParams,
+>(
+  url: string,
+  options?: UnifiedRequestOptions<P>,
+): Promise<T> => {
+  const resolvedUrl = resolveRequestUrl(url, options);
+  const {
+    skipRequestInterceptors,
+    skipResponseInterceptors,
+    isShowLoading = true,
+    ...restOptions
+  } = options ?? {};
+
+  if (isShowLoading) {
+    if (requestPool.size === 0) {
+      // 显示loading
+      console.log('显示loading');
+    }
+    requestPool.add(options!);
+  }
+
+  try {
+    const ctx: RequestContext = {
+      url: resolvedUrl,
+      options: restOptions ?? {},
+    };
+
+    let next = ctx;
+    if (skipRequestInterceptors !== true) {
+      next = await runRequestInterceptors(ctx);
+    }
+
+    const mergedHeaders: Record<string, string> = {
+      ...(next.options.headers || {}),
+    };
+
+    const normalizedOptions = {
+      ...next.options,
+      headers: mergedHeaders,
+    };
+
+    const response = await rawRequest<T>(next.url, normalizedOptions);
+    if (skipResponseInterceptors === true) {
+      return response;
+    }
+    return await runResponseInterceptors(response, {
+      url: next.url,
+      options: normalizedOptions,
+    });
+  } catch (err) {
+    const error = err as ResponseError;
+    let message = '';
+    if (isAxiosError(error)) {
+      const axiosResponse = error.response;
+      message =
+        axiosResponse?.data?.message || error.message || axiosResponse?.data;
+    } else if (isNormalResponseError(error)) {
+      message = error.message;
+    } else {
+      message = error.message;
+    }
+    alert(message);
+    throw error;
+  } finally {
+    if (isShowLoading) {
+      requestPool.delete(options!);
+      if (requestPool.size === 0) {
+        // 隐藏loading
+        console.log('隐藏loading');
+      }
+    }
+  }
+};
+
+/**
+ * 使用临时拦截器执行请求
+ */
+export const withTemporaryInterceptors = async <T>(
+  runner: () => Promise<T>,
+  interceptors: {
+    request?: RequestInterceptor;
+    response?: ResponseInterceptor;
+  },
+): Promise<T> => {
+  const ejectors: Array<() => void> = [];
+
+  if (interceptors.request) {
+    ejectors.push(addRequestInterceptor(interceptors.request));
+  }
+  if (interceptors.response) {
+    ejectors.push(addResponseInterceptor(interceptors.response));
+  }
+
+  try {
+    return await runner();
+  } finally {
+    for (const eject of ejectors) {
+      eject();
+    }
+  }
+};
+
+// 导出拦截器注册方法
+export const registerRequestInterceptor = addRequestInterceptor;
+export const registerResponseInterceptor = addResponseInterceptor;
+
+// 导出类型
+export type {
+  RequestContext,
+  RequestInterceptor,
+  ResponseInterceptor,
+  UnifiedRequestOptions,
+};

package/generators/h5-react/templates/packages/request/src/interceptors.ts

@@ -0,0 +1,126 @@
+/**
+ * 请求/响应拦截器管理
+ */
+// import getUserInfo from '<%= packageScope %>/js-bridge/getUserInfo';
+
+import type {
+  NormalResponseError,
+  RequestContext,
+  RequestInterceptor,
+  ResponseData,
+  ResponseInterceptor,
+} from './types';
+
+const requestInterceptors: Array<{ id: number; handler: RequestInterceptor }> =
+  [];
+const responseInterceptors: Array<{
+  id: number;
+  handler: ResponseInterceptor;
+}> = [];
+
+let interceptorSeed = 0;
+
+export const addRequestInterceptor = (
+  handler: RequestInterceptor,
+): (() => void) => {
+  const id = ++interceptorSeed;
+  requestInterceptors.push({ id, handler });
+  return () => {
+    const index = requestInterceptors.findIndex((item) => item.id === id);
+    if (index >= 0) {
+      requestInterceptors.splice(index, 1);
+    }
+  };
+};
+
+export const addResponseInterceptor = (
+  handler: ResponseInterceptor,
+): (() => void) => {
+  const id = ++interceptorSeed;
+  responseInterceptors.push({ id, handler });
+  return () => {
+    const index = responseInterceptors.findIndex((item) => item.id === id);
+    if (index >= 0) {
+      responseInterceptors.splice(index, 1);
+    }
+  };
+};
+
+export const runRequestInterceptors = async (
+  ctx: RequestContext,
+): Promise<RequestContext> => {
+  let current = ctx;
+  for (const { handler } of requestInterceptors) {
+    current = await handler(current);
+  }
+  return current;
+};
+
+export const runResponseInterceptors = async <T extends ResponseData>(
+  response: T,
+  ctx: RequestContext,
+): Promise<T> => {
+  let current = response;
+  for (const { handler } of responseInterceptors) {
+    current = (await handler(current, ctx)) as T;
+  }
+  return current;
+};
+
+/**
+ * 构建默认请求头
+ */
+export const buildDefaultHeaders = async () => {
+  const headers: Record<string, string> = {};
+  // 获取用户信息，添加token，具体实现请根据客户端的JSBridge规则修改
+  // const userInfo = await getUserInfo();
+  // headers['Authorization'] = userInfo.accessToken;
+  return headers;
+};
+
+/**
+ * 初始化默认拦截器
+ */
+export const initDefaultInterceptors = (): void => {
+  // 添加默认请求头
+  addRequestInterceptor(async (ctx) => {
+    const defaultHeaders = await buildDefaultHeaders();
+    return {
+      url: ctx.url,
+      options: {
+        ...ctx.options,
+        headers: {
+          ...defaultHeaders,
+          ...(ctx.options.headers || {}),
+        },
+      },
+    };
+  });
+
+  // 处理业务错误码（{ code, message } 格式）
+  addResponseInterceptor(async (data) => {
+    if (data && typeof data === 'object' && 'code' in data) {
+      const code = Number(data.code);
+      if (!isNaN(code) && code !== 200 && code !== 0) {
+        let message = '';
+        if ('message' in data) {
+          message = data.message;
+        } else {
+          message = data.msg;
+        }
+        const error = new Error(
+          message || `请求失败 (${code})`,
+        ) as NormalResponseError;
+        error.code = code;
+        error.response = data;
+        throw error;
+      }
+    } else {
+      const error = new Error(data || '请求失败') as NormalResponseError;
+      error.code = 1;
+      error.response = data;
+      throw error;
+    }
+    return data;
+  });
+};

package/generators/h5-react/templates/packages/request/src/types.ts

@@ -0,0 +1,101 @@
+/**
+ * 请求模块类型定义
+ */
+
+import type { RequestError } from '../axios.d';
+
+export type Method =
+  | 'get'
+  | 'GET'
+  | 'delete'
+  | 'DELETE'
+  | 'head'
+  | 'HEAD'
+  | 'options'
+  | 'OPTIONS'
+  | 'post'
+  | 'POST'
+  | 'put'
+  | 'PUT'
+  | 'patch'
+  | 'PATCH'
+  | 'purge'
+  | 'PURGE'
+  | 'link'
+  | 'LINK'
+  | 'unlink'
+  | 'UNLINK';
+
+export type ResponseType =
+  | 'arraybuffer'
+  | 'blob'
+  | 'document'
+  | 'json'
+  | 'text'
+  | 'stream';
+
+export type UnifiedRequestOptions<P extends RequestParams = any> = {
+  method?: Method;
+  headers?: Record<string, string>;
+  data?: P;
+  params?: P;
+  useCache?: boolean;
+  validateCache?: (url: string, options: UnifiedRequestOptions<P>) => boolean;
+  onUploadProgress?: (progressEvent: any) => void;
+  onDownloadProgress?: (progressEvent: any) => void;
+  /** 自定义 baseURL，覆盖全局配置 */
+  baseURL?: string;
+  /** 使用原始 URL，跳过所有 URL 处理 */
+  rawUrl?: boolean;
+  isShowLoading?: boolean;
+  responseType?: ResponseType;
+  skipResponseInterceptors?: boolean;
+  skipRequestInterceptors?: boolean;
+  [key: string]: unknown;
+};
+
+export type RequestParams = Record<string, any>;
+
+export type ResponseData = NormalResponseData | MsgResponseData | string;
+
+/**
+ * 普通接口响应数据类型，根据自身业务接口，自定义调整
+ */
+export type NormalResponseData = {
+  code: number;
+  message: string;
+  [key: string]: any;
+};
+
+export type MsgResponseData = {
+  msg: string;
+  code: number;
+};
+
+export type RequestContext = {
+  url: string;
+  options: UnifiedRequestOptions;
+};
+
+export type RequestInterceptor = (
+  ctx: RequestContext,
+) => Promise<RequestContext> | RequestContext;
+
+export type ResponseInterceptor<T extends ResponseData = ResponseData> = (
+  response: T,
+  ctx: RequestContext,
+) => Promise<T> | T;
+
+export interface PendingRequest {
+  ctx: RequestContext;
+  resolve: (ctx: RequestContext) => void;
+  reject: (error: Error) => void;
+}
+
+export type NormalResponseError = Error & {
+  code: number;
+  message: string;
+  response: ResponseData;
+};
+
+export type ResponseError = NormalResponseError | RequestError;

package/generators/h5-react/templates/packages/request/src/url-resolver.ts

@@ -0,0 +1,66 @@
+/**
+ * URL 解析与拼接工具
+ */
+
+import { apiBaseUrl } from '<%= packageScope %>/domain';
+import type { UnifiedRequestOptions } from './types';
+
+/**
+ * 判断是否为绝对 URL
+ */
+const isAbsoluteUrl = (url: string): boolean => {
+  return (
+    url.startsWith('http://') ||
+    url.startsWith('https://') ||
+    url.startsWith('//')
+  );
+};
+
+/**
+ * 解析最终请求 URL
+ *
+ * 配置优先级：
+ * 1. rawUrl: true → 直接返回原始 url
+ * 2. 绝对 URL → 直接返回
+ * 3. 拼接 apiBaseUrl + url
+ *
+ */
+export const resolveRequestUrl = (
+  url: string,
+  options?: UnifiedRequestOptions,
+): string => {
+  // rawUrl: 完全透传，不做任何处理
+  if (options?.rawUrl) {
+    return url;
+  }
+
+  // 绝对 URL 直接返回
+  if (isAbsoluteUrl(url)) {
+    return url;
+  }
+
+  const baseURL = options?.baseURL ?? apiBaseUrl;
+
+  if (baseURL) {
+    delete options?.baseURL;
+    // 有 baseURL 时，拼接完整的绝对路径
+    const normalizedBase = baseURL.endsWith('/')
+      ? baseURL.slice(0, -1)
+      : baseURL;
+    const normalizedPath = url.startsWith('/') ? url : `/${url}`;
+    return `${normalizedBase}${normalizedPath}`;
+  }
+
+  return url;
+};
+
+/**
+ * 从 URL 中移除指定参数
+ */
+export const removeParamFromUrl = (param: string): void => {
+  if (typeof window === 'undefined') return;
+  const current = new URL(window.location.href);
+  current.searchParams.delete(param);
+  const nextUrl = current.toString();
+  window.history.replaceState(null, '', nextUrl);
+};

package/generators/h5-react/templates/packages/request/src/utils.ts

@@ -0,0 +1,12 @@
+import type { AxiosError } from '../axios.d';
+import type { NormalResponseError, ResponseError } from './types';
+
+export const isAxiosError = (error: ResponseError): error is AxiosError => {
+  return 'config' in error && 'response' in error;
+};
+
+export const isNormalResponseError = (
+  error: ResponseError,
+): error is NormalResponseError => {
+  return 'code' in error && 'message' in error && 'response' in error;
+};

package/generators/h5-react/templates/packages/request/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "<%= packageScope %>/typescript"
+}