@jetlinks-web/core 2.1.6 → 2.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetlinks-web/core",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "main": "index.ts",
   "module": "index.ts",
   "keywords": [

package/src/axios.ts

@@ -47,7 +47,6 @@ interface RequestOptions {
 }
 
 let instance: AxiosInstance
-
 let _options: Options = {
   filter_url: [],
   code: 200,
@@ -61,20 +60,21 @@ let _options: Options = {
   tokenExpiration: () => {},
 }
 
+const isApp = (window as any).__MICRO_APP_ENVIRONMENT__
 const controller = new AbortController();
 
 const handleRequest = (config: InternalAxiosRequestConfig) => {
   const token = getToken()
   const lang = localStorage.getItem(_options.langKey)
-  const env = localStorage.getItem(LOCAL_BASE_API)
+  const localBaseApi = localStorage.getItem(LOCAL_BASE_API)
 
   if (lang) {
     config.headers[_options.langKey] = lang
   }
 
-  if (env && !config.url.startsWith(env)) {
+  if (localBaseApi && !config.baseURL) {
     const _url = config.url.startsWith('/') ? config.url : `/${config.url}`
-    config.url = env + _url
+    config.url = localBaseApi + _url
   }
 
   // 没有token，并且该接口需要token校验

package/src/websocket.ts

@@ -1,7 +1,10 @@
+import { wsClient } from '@/utils/websocket';
 import { webSocket, WebSocketSubject } from 'rxjs/webSocket';
 import { Observable, Subject, timer, Subscription, EMPTY } from 'rxjs';
 import { retry, catchError } from 'rxjs/operators';
 import { notification } from 'ant-design-vue';
+import app from '@micro-zoe/micro-app'
+import { log } from 'console';
 
 interface WebSocketMessage {
   type: string;
@@ -14,24 +17,32 @@ interface WebSocketMessage {
 }
 
 type WS_Options = {
-    onError?: (message: WebSocketMessage) => void
+  onError?: (message: WebSocketMessage) => void
 }
 
+const isApp = (window as any).__MICRO_APP_ENVIRONMENT__
+
 export class WebSocketClient {
   private ws: WebSocketSubject<WebSocketMessage> | null = null;
   private subscriptions = new Map<string, Subject<WebSocketMessage>>();
   private pendingSubscriptions = new Map<string, Subject<WebSocketMessage>>();
   private heartbeatSubscription: Subscription | null = null;
   private reconnectAttempts = 0;
-  private readonly maxReconnectAttempts = 100;
+  private readonly maxReconnectAttempts = 2;
   private isConnected = false;
   private tempQueue: WebSocketMessage[] = []; // 缓存消息队列
   private url: string = '';
   private options: WS_Options = {}
+  private wsClient: WebSocketClient | undefined
 
   constructor(options?: WS_Options) {
     this.options = options || {};
     this.setupConnectionMonitor();
+    if (isApp) {
+      (window as any).microApp.addGlobalDataListener((data) => {
+        this.wsClient = data.wsClient
+      })
+    }
   }
 
   public initWebSocket(url: string) {
@@ -39,19 +50,21 @@ export class WebSocketClient {
   }
 
   private setupConnectionMonitor() {
-    window.addEventListener('online', () => {
-      console.log('Network is online, attempting to reconnect...');
-      this.reconnect();
-    });
+    if (!isApp) {
+      window.addEventListener('online', () => {
+        console.log('Network is online, attempting to reconnect...');
+        this.reconnect();
+      });
 
-    window.addEventListener('offline', () => {
-      console.log('Network is offline, caching subscriptions...');
-      this.cacheSubscriptions();
-    });
+      window.addEventListener('offline', () => {
+        console.log('Network is offline, caching subscriptions...');
+        this.cacheSubscriptions();
+      });
 
-    window.addEventListener('beforeunload', () => {
-      this.disconnect();
-    });
+      window.addEventListener('beforeunload', () => {
+        this.disconnect();
+      });
+    }
   }
 
   private getReconnectDelay(): number {
@@ -64,6 +77,12 @@ export class WebSocketClient {
   }
 
   private setupWebSocket() {
+
+    if (isApp && this.wsClient) {
+      this.wsClient.setupWebSocket()
+      return
+    }
+
     if (this.ws || !this.url) {
       return;
     }
@@ -84,9 +103,17 @@ export class WebSocketClient {
         next: () => {
           console.log('WebSocket disconnected');
           this.isConnected = false;
-          this.cacheSubscriptions();
-          this.stopHeartbeat();
-          this.reconnect();
+          const time = this.getReconnectDelay()
+          setTimeout(() => {
+            this.reconnectAttempts += 1;
+            if (this.reconnectAttempts > this.maxReconnectAttempts) {
+              return
+            }
+            this.cacheSubscriptions();
+            this.stopHeartbeat();
+            this.reconnect();
+          }, time)
+
         }
       }
     });
@@ -112,6 +139,10 @@ export class WebSocketClient {
   }
 
   private startHeartbeat() {
+    if (isApp && this.wsClient) {
+      this.wsClient.startHeartbeat()
+      return
+    }
     this.stopHeartbeat();
     this.heartbeatSubscription = timer(0, 2000).subscribe(() => {
       this.send({ type: 'ping' });
@@ -119,6 +150,11 @@ export class WebSocketClient {
   }
 
   private stopHeartbeat() {
+    if (isApp && this.wsClient) {
+      this.wsClient.stopHeartbeat()
+      return
+    }
+
     if (this.heartbeatSubscription) {
       this.heartbeatSubscription.unsubscribe();
       this.heartbeatSubscription = null;
@@ -126,16 +162,22 @@ export class WebSocketClient {
   }
 
   private handleMessage(message: WebSocketMessage) {
+
+    if (isApp && this.wsClient) {
+      this.wsClient.handleMessage(message)
+      return
+    }
+
     if (message.type === 'pong') {
       return;
     }
 
     if (message.type === 'error') {
-        if (this.options.onError) {
-            this.options.onError(message)
-        } else {
-            notification.error({ key: 'error', message: message.message });
-        }
+      if (this.options.onError) {
+        this.options.onError(message)
+      } else {
+        notification.error({ key: 'error', message: message.message });
+      }
       return;
     }
 
@@ -151,6 +193,11 @@ export class WebSocketClient {
   }
 
   private processTempQueue() {
+    if (isApp && this.wsClient) {
+      this.wsClient.processTempQueue()
+      return
+    }
+
     while (this.tempQueue.length > 0) {
       const message = this.tempQueue.shift();
       if (message) {
@@ -160,11 +207,19 @@ export class WebSocketClient {
   }
 
   private cacheSubscriptions() {
+    if (isApp && this.wsClient) {
+      this.wsClient.cacheSubscriptions()
+      return
+    }
     this.pendingSubscriptions = new Map(this.subscriptions);
     this.subscriptions.clear();
   }
 
   private restoreSubscriptions() {
+    if (isApp && this.wsClient) {
+      this.wsClient.restoreSubscriptions()
+      return
+    }
     this.pendingSubscriptions.forEach((subject, id) => {
       this.subscriptions.set(id, subject);
     });
@@ -172,6 +227,10 @@ export class WebSocketClient {
   }
 
   private reconnect() {
+    if (isApp && this.wsClient) {
+      this.wsClient.reconnect()
+      return
+    }
     if (!this.isConnected && navigator.onLine) {
       this.ws = null;
       this.setupWebSocket();
@@ -179,10 +238,18 @@ export class WebSocketClient {
   }
 
   public connect() {
+    if (isApp && this.wsClient) {
+      this.wsClient.connect()
+      return
+    }
     this.setupWebSocket();
   }
 
   public disconnect() {
+    if (isApp && this.wsClient) {
+      this.wsClient.disconnect()
+      return
+    }
     if (this.ws) {
       this.ws.complete();
       this.ws = null;
@@ -194,6 +261,10 @@ export class WebSocketClient {
   }
 
   public send(message: WebSocketMessage) {
+    if (isApp && this.wsClient) {
+      this.wsClient.send(message)
+      return
+    }
     if (this.ws && this.isConnected) {
       this.ws.next(message);
     } else {
@@ -202,6 +273,15 @@ export class WebSocketClient {
   }
 
   public getWebSocket(id: string, topic: string, parameter: Record<string, any> = {}): Observable<WebSocketMessage> {
+    console.log('getWebSocket', this.wsClient, id)
+    if (isApp && this.wsClient) {
+      return this.wsClient.getWebSocket(
+        id,
+        topic,
+        parameter
+      )
+    }
+
     const subject = new Subject<WebSocketMessage>();
     this.subscriptions.set(id, subject);
 
@@ -235,9 +315,9 @@ export class WebSocketClient {
  *   .subscribe(
  *     message => console.log('Received:', message)
  *   );
- * 
+ *
  * // 清理
  * subscription.unsubscribe();
- * 
+ *
  */
 export const wsClient = new WebSocketClient();

package/src/axios.ts~

@@ -1,359 +0,0 @@
-import { TOKEN_KEY, BASE_API, LOCAL_BASE_API } from '@jetlinks-web/constants'
-import { getToken } from '@jetlinks-web/utils'
-import axios from 'axios'
-import type {
-  AxiosInstance,
-  AxiosResponse,
-  AxiosError,
-  InternalAxiosRequestConfig,
-} from 'axios'
-import type { AxiosResponseRewrite } from '@jetlinks-web/types'
-import {isFunction, isObject} from 'lodash-es'
-
-interface Options {
-
-  tokenExpiration: (err: AxiosError<any>, response: AxiosResponse) => void
-  filter_url?: Array<string>
-  code?: number
-  codeKey?: string
-  timeout?: number
-  handleRequest?: () => void
-  /**
-   * 用以获取localstorage中的lang
-   */
-  langKey?: string
-  /**
-   * response处理函数
-   * @param response AxiosResponse实例
-   */
-  handleResponse?: (response: AxiosResponse) => void
-  /**
-   * 错误处理函数
-   * @param msg 错误消息
-   * @param status 错误code
-   * @param error 错误实例
-   */
-  handleError?: (msg: string, status: string | number, error: AxiosError<any>) => void
-  requestOptions?: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Record<string, any>
-
-}
-
-interface RequestOptions {
-  url?: string
-  method?: string
-  params?: any
-  data?: any
-  [key: string]: any
-}
-
-let instance: AxiosInstance
-
-let _options: Options = {
-  filter_url: [],
-  code: 200,
-  codeKey: 'status',
-  timeout: 1000 * 15,
-  handleRequest: undefined,
-  handleResponse: undefined,
-  handleError: undefined,
-  langKey: 'lang',
-  requestOptions: (config) => ({}),
-  tokenExpiration: () => {},
-}
-
-const controller = new AbortController();
-
-const handleRequest = (config: InternalAxiosRequestConfig) => {
-  const token = getToken()
-  const lang = localStorage.getItem(_options.langKey)
-  const env = localStorage.getItem(LOCAL_BASE_API)
-
-  if (lang) {
-    config.headers[_options.langKey] = lang
-  }
-
-  if (!config.url.startsWith(env)) {
-    const _url = config.url.startsWith('/') ? config.url : `/${config.url}`
-    config.url = env + _url
-  }
-
-  // 没有token，并且该接口需要token校验
-  if (!token && !_options.filter_url?.some((url) => config.url?.includes(url))) {
-    // 跳转登录页
-    _options.tokenExpiration?.()
-    return config
-  }
-
-  if (!config.headers[TOKEN_KEY]) {
-    config.headers[TOKEN_KEY] = token
-  }
-
-  if (_options.requestOptions && isFunction(_options.requestOptions)) {
-    const extraOptions = _options.requestOptions(config)
-    if (extraOptions && isObject(extraOptions)) {
-      for (const key in extraOptions) {
-        config[key] = extraOptions[key]
-      }
-    }
-  }
-
-
-  return config
-}
-
-const handleResponse = (response: AxiosResponse) => {
-
-  if (_options.handleResponse && isFunction(_options.handleResponse)) {
-    return _options.handleResponse(response)
-  }
-
-  if (response.data instanceof ArrayBuffer) {
-    return response
-  }
-
-  const status = response.data[_options.codeKey || 'status']
-
-// 增加业务接口处理成功判断方式，只需要判断返回参数包含：success为true
-  if (
-    typeof response.data === 'object' &&
-    typeof response.data.success === 'undefined'
-  ) {
-    response.data.success = status === _options.code
-  }
-
-  return response.data
-}
-
-const errorHandler = (err: AxiosError<any>) => {
-  let description = err.response?.message || 'Error'
-  let _status: string | number = 0
-  if (err.response) {
-    const {data, status} = err.response
-    _status = status
-    switch (status) {
-      case 400:
-      case 403:
-      case 500:
-        description = (`${data?.message}`).substring(0, 90)
-        break;
-      case 401:
-        description = err.response.data.result.text || '用户未登录'
-        _options.tokenExpiration?.(err, err.response)
-        break;
-      case 404:
-        description = err?.response?.data?.message || `${data?.error} ${data?.path}`
-        break;
-      default:
-        break;
-    }
-  } else if (err.response === undefined) {
-    description = err.message.includes('timeout') ? '接口响应超时' : err.message
-    _status = 'timeout'
-  }
-
-  if (_options.handleError && isFunction(_options.handleError)) {
-    _options.handleError(description, _status, err)
-  }
-
-  return Promise.reject(err)
-}
-
-export const crateAxios = (options: Options) => {
-  if (options) {
-    _options = Object.assign(_options, options)
-  }
-
-  instance = axios.create({
-    withCredentials: false,
-    timeout: _options.timeout,
-    baseURL: BASE_API
-  })
-
-  instance.interceptors.request.use(
-    handleRequest,
-    errorHandler
-  )
-
-  instance.interceptors.response.use(
-    handleResponse,
-    errorHandler
-  )
-}
-
-export const post = <T = any>(url: string, data: any = {}, ext?: any) => {
-  return (instance<any, AxiosResponseRewrite<T>>({
-    method: 'POST',
-    url,
-    data,
-    ...ext,
-  }))
-}
-
-export const get = <T = any>(url: string, params: any = undefined, ext?: any) => {
-  return instance<any, AxiosResponseRewrite<T>>({
-    method: 'GET',
-    url,
-    params,
-    ...ext,
-  })
-}
-
-export const put = <T = any>(url: string, data: any = {}, ext?: any) => {
-  return instance<any, AxiosResponseRewrite<T>>({
-    method: 'PUT',
-    url,
-    data,
-    ...ext,
-  })
-}
-
-export const patch = <T = any>(url: string, data: any = {}, ext?: any) => {
-  return instance<any, AxiosResponseRewrite<T>>({
-    method: 'patch',
-    url,
-    data,
-    ...ext,
-  })
-}
-
-export const remove = <T = any>(url: string, params: any = undefined, ext?: any) => {
-  return instance<any, AxiosResponseRewrite<T>>({
-    method: 'DELETE',
-    url,
-    params,
-    ...ext,
-  })
-}
-
-export const getStream = (url: string, params?: any, ext?: any) => {
-  return get(url, params, { responseType: 'arraybuffer', ...ext })
-}
-
-export const postStream = (url: string, data: any, ext?: any) => {
-  return post(url, data, { responseType: 'arraybuffer', ...ext })
-}
-
-export const request = {
-  post, get, put, patch, remove, getStream, postStream
-}
-
-export class Request {
-  modulePath: string
-
-  constructor(modulePath: string) {
-    this.modulePath = modulePath
-  }
-
-  /**
-   * 分页查询
-   * @param {object} data 查询参数
-   * @param {object} options 请求配置
-   * @returns {Promise<AxiosResponse<any>>} 分页查询结果
-   */
-  page(data: any={}, options: RequestOptions= {
-    url: undefined,
-    method: undefined,
-  }) {
-    const { url='/_query', method = 'post', ...rest } = options
-    return request[method](`${this.modulePath}${url}`, data, rest)
-  }
-
-  /**
-   * 不分页查询
-   * @param {object} data 查询参数
-   * @param {object} options 请求配置
-   * @returns {Promise<AxiosResponse<any>>} 不分页查询结果
-   */
-  noPage(data: any={}, options: RequestOptions = {
-    url: undefined,
-    method: undefined,
-  }) {
-    const { url='/_query/no-page', method = 'post', ...rest } = options
-    return request[method](`${this.modulePath}${url}`, { paging: false, ...data}, rest)
-  }
-
-  /**
-   * 详情查询
-   * @param {string} id 详情ID
-   * @param {object} params 查询参数
-   * @param {object} options 请求配置
-   * @returns {Promise<AxiosResponse<any>>} 详情查询结果
-   */
-  detail(id: string, params?: any, options: RequestOptions= {
-    url: undefined,
-    method: undefined,
-  }) {
-    const { url=`/${id}/detail`, method = 'get', ...rest } = options
-    return request[method](`${this.modulePath}${url}`, params, rest)
-  }
-
-  /**
-   * 保存
-   * @param {object} data 保存参数
-   * @param {object} options 请求配置
-   * @returns {Promise<AxiosResponse<any>>} 保存结果
-   */
-  save(data: any={}, options: RequestOptions = {
-    url: undefined,
-    method: undefined,
-  }) {
-    const { url=``, method = 'post', ...rest } = options
-    return request[method](`${this.modulePath}${url}`, data, rest)
-  }
-
-  /**
-   * 更新
-   * @param {object} data 更新参数
-   * @param {object} options 请求配置
-   * @returns {Promise<AxiosResponse<any>>} 更新结果
-   */
-  update(data: any={}, options: RequestOptions = {
-    url: undefined,
-    method: undefined,
-  }) {
-    const { url=``, method = 'patch', ...rest } = options
-    return patch(`${this.modulePath}${url}`, data, rest)
-  }
-
-  /**
-   * 删除
-   * @param {string} id 删除ID
-   * @param {object} options 请求配置
-   * @returns {Promise<AxiosResponse<any>>} 删除结果
-   */
-  delete(id: string, params?: any, options: RequestOptions = {
-    url: undefined,
-    method: undefined,
-  }) {
-    const { url=`/${id}`, method = 'post', ...rest } = options
-    return remove(`${this.modulePath}${url}`, params, rest)
-  }
-
-  post(...args) {
-    const [url, data, options] = args
-    return post(`${this.modulePath}${url}`, data, options)
-  }
-
-  get(...args) {
-    const [url, params, options] = args
-    return get(`${this.modulePath}${url}`, params, options)
-  }
-
-  put(...args) {
-    const [url, data, options] = args
-    return put(`${this.modulePath}${url}`, data, options)
-  }
-
-  patch(...args) {
-    const [url, data, options] = args
-    return patch(`${this.modulePath}${url}`, data, options)
-  }
-
-  remove(...args) {
-    const [url, params, options] = args
-    return remove(`${this.modulePath}${url}`, params, options)
-  }
-}
-
-
-