@jetlinks-web/core 2.2.18 → 2.3.0

package/src/fetch.ts

@@ -1,241 +1,271 @@
-import {getToken} from "@jetlinks-web/utils";
-import {BASE_API, TOKEN_KEY} from "@jetlinks-web/constants";
-import {isFunction, isObject} from "lodash-es";
-import { Observable, } from 'rxjs'
+import { getToken } from "@jetlinks-web/utils";
+import { BASE_API, TOKEN_KEY } from "@jetlinks-web/constants";
+import { isFunction, isObject } from "lodash-es";
+import { Observable, Subscriber } from 'rxjs';
+
+/**
+ * NdJson 配置选项
+ */
+export interface NdJsonOptions {
+  /** 成功状态码 */
+  code?: number;
+  /** 状态码字段名 */
+  codeKey?: string;
+  /** 不需要 token 的 URL 列表 */
+  filter_url?: string[];
+  /** token 过期回调 */
+  tokenExpiration?: () => void;
+  /** 自定义请求配置 */
+  requestOptions?: (config: RequestInit) => Record<string, unknown>;
+  /** 自定义响应处理 */
+  handleResponse?: <T>(response: T) => T;
+  /** 基础 API 地址，默认使用 BASE_API 常量 */
+  baseURL?: string;
+}
+
+interface RequestContext {
+  controller: AbortController;
+  isActive: boolean;
+}
+
+type HttpMethod = 'GET' | 'POST';
 
 export class NdJson {
-  options: any = {
+  private options: NdJsonOptions = {
     code: 200,
     codeKey: 'status'
-  }
-  isRead = false
-  controller = null
-  constructor() {}
+  };
+
+  private activeRequests = new Set<RequestContext>();
 
-  create(options) {
-    this.options = Object.assign(this.options, options)
+  constructor(options?: NdJsonOptions) {
+    if (options) {
+      this.options = { ...this.options, ...options };
+    }
   }
 
-  getUrl(url) {
-    return BASE_API + url
+  /**
+   * 初始化/更新配置
+   */
+  create(options: NdJsonOptions): void {
+    this.options = { ...this.options, ...options };
   }
 
-  get(url, data = '{}', extra = {}) {
-    const _url = this.getUrl(url)
-    const that = this
-    const controller = this.controller = new AbortController();
-
-    return new Observable(observer => {
-      let reader
-      fetch(
-        _url,
-        {
-          method: 'GET',
-          signal: controller.signal,
-          keepalive: true,
-          ...extra,
-          ...this.handleRequest(_url)
-        }
-      ).then(resp => {
-        reader = resp.body?.getReader();
-        const decoder = new TextDecoder();
-        let data_buf = "";
-
-        if (!reader) {
-          observer.error(new Error('No readable stream available'));
-          return;
-        }
+  /**
+   * 获取完整 URL
+   */
+  private getUrl(url: string): string {
+    const baseURL = this.options.baseURL ?? BASE_API;
+    return baseURL + url;
+  }
 
-        const read = () => {
+  /**
+   * 处理 NDJSON 流的核心逻辑
+   */
+  private processStream<T>(
+    reader: ReadableStreamDefaultReader<Uint8Array>,
+    observer: Subscriber<T>,
+    context: RequestContext
+  ): void {
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    const read = (): void => {
+      if (!context.isActive) {
+        reader.cancel();
+        observer.complete();
+        return;
+      }
 
-          if (!that.isRead) {
-            reader.cancel()
+      reader.read()
+        .then(({ done, value }) => {
+          if (done) {
+            this.flushBuffer(buffer, observer);
             observer.complete();
-            return
+            return;
           }
 
-          reader.read().then(({ done, value }) => {
-            if (done) {
-              if (data_buf.trim().length > 0) {
-                try {
-                  observer.next(JSON.parse(data_buf.trim()));
-                } catch (e) {
-                  observer.error(e);
-                }
-              }
-              observer.complete();
-              return;
-            }
-
-            const data = decoder.decode(value, { stream: true });
-            data_buf += data;
-
-            let lines = data_buf.split('\n');
-            for (let i = 0; i < lines.length - 1; ++i) {
-              const line = lines[i].trim();
-              if (line.length > 0) {
-                try {
-                  observer.next(JSON.parse(line.startsWith('data:') ? line.slice(5) : line));
-                } catch (e) {
-                  observer.error(e);
-                  return;
-                }
-              }
-            }
-            data_buf = lines[lines.length - 1];
-            read();
-          }).catch(err => {
-            if (err.name !== 'AbortError') {
-              observer.error(err);
-            }
-          });
-        };
-        that.isRead = true
-        read();
-      }).catch(e => {
-        observer.error(e)
-      })
+          buffer += decoder.decode(value, { stream: true });
+          buffer = this.parseLines(buffer, observer);
+          read();
+        })
+        .catch(err => {
+          if (err.name !== 'AbortError') {
+            observer.error(err);
+          }
+        });
+    };
 
-      return () => {
-        that.cancel()
-      }
-    })
+    read();
   }
 
-  post(url, data: BodyInit | any ={}, extra = {}) {
-    const _url = this.getUrl(url)
-    const that = this
-    const controller = this.controller = new AbortController();
-
-    return new Observable(observer => {
-      let reader
-      fetch(
-        _url,
-        {
-          method: 'POST',
-          signal: controller.signal,
-          keepalive: true,
-          body: isObject(data) ? JSON.stringify(data) : data,
-          ...extra,
-          ...this.handleRequest(_url)
-        }
-      ).then(async resp => {
-        reader = resp.body?.getReader();
-        const decoder = new TextDecoder();
-        let data_buf = "";
-
-        if (!reader) {
-          observer.error(new Error('No readable stream available'));
-          return;
+  /**
+   * 解析缓冲区中的完整行
+   */
+  private parseLines<T>(buffer: string, observer: Subscriber<T>): string {
+    const lines = buffer.split('\n');
+
+    for (let i = 0; i < lines.length - 1; i++) {
+      const line = lines[i].trim();
+      if (line.length > 0) {
+        try {
+          const data = line.startsWith('data:') ? line.slice(5) : line;
+          observer.next(JSON.parse(data));
+        } catch (e) {
+          observer.error(e);
+          return '';
         }
+      }
+    }
 
-        const read = () => {
+    return lines[lines.length - 1];
+  }
 
-          if (!that.isRead) {
-            reader.cancel()
-            observer.complete();
-            return
+  /**
+   * 刷新剩余缓冲区
+   */
+  private flushBuffer<T>(buffer: string, observer: Subscriber<T>): void {
+    const trimmed = buffer.trim();
+    if (trimmed.length > 0) {
+      try {
+        observer.next(JSON.parse(trimmed));
+      } catch (e) {
+        observer.error(e);
+      }
+    }
+  }
+
+  /**
+   * 创建请求的 Observable
+   */
+  private request<T>(
+    method: HttpMethod,
+    url: string,
+    data?: BodyInit | Record<string, unknown>,
+    extra: RequestInit = {}
+  ): Observable<T> {
+    const fullUrl = this.getUrl(url);
+
+    return new Observable<T>(observer => {
+      const controller = new AbortController();
+      const context: RequestContext = {
+        controller,
+        isActive: true
+      };
+
+      this.activeRequests.add(context);
+
+      const requestInit: RequestInit = {
+        method,
+        signal: controller.signal,
+        keepalive: true,
+        ...extra,
+        ...this.handleRequest(fullUrl, method)
+      };
+
+      // POST 请求添加 body
+      if (method === 'POST' && data !== undefined) {
+        requestInit.body = isObject(data) ? JSON.stringify(data) : data as BodyInit;
+      }
+
+      fetch(fullUrl, requestInit)
+        .then(resp => {
+          const reader = resp.body?.getReader();
+
+          if (!reader) {
+            observer.error(new Error('No readable stream available'));
+            return;
           }
 
-          reader.read().then(({ done, value }) => {
-            if (done) {
-              if (data_buf.trim().length > 0) {
-                try {
-                  observer.next(JSON.parse(data_buf.trim()));
-                } catch (e) {
-                  observer.error(e);
-                }
-              }
-              observer.complete();
-              return;
-            }
-
-            const data = decoder.decode(value, { stream: true });
-            data_buf += data;
-
-            let lines = data_buf.split('\n');
-            for (let i = 0; i < lines.length - 1; ++i) {
-              const line = lines[i].trim();
-              if (line.length > 0) {
-                try {
-                  observer.next(JSON.parse(line.startsWith('data:') ? line.slice(5) : line));
-                } catch (e) {
-                  observer.error(e);
-                  return;
-                }
-              }
-            }
-            data_buf = lines[lines.length - 1];
-            read();
-          }).catch(err => {
-            if (err.name !== 'AbortError') {
-              observer.error(err);
-            }
-          });
-        };
-        that.isRead = true
-        read();
-      }).catch(e => {
-          observer.error(e)
-      })
+          context.isActive = true;
+          this.processStream(reader, observer, context);
+        })
+        .catch(e => {
+          observer.error(e);
+        });
 
+      // 返回清理函数
       return () => {
-        that.cancel()
-      }
-    })
+        context.isActive = false;
+        controller.abort();
+        this.activeRequests.delete(context);
+      };
+    });
   }
-  handleRequest(url): RequestInit {
-    const config: RequestInit = {
-      headers: {
-        'Content-Type': 'application/x-ndjson',
-      }
+
+  get<T = unknown>(url: string, _data = '{}', extra: RequestInit = {}): Observable<T> {
+    return this.request<T>('GET', url, undefined, extra);
+  }
+
+  post<T = unknown>(url: string, data: BodyInit | Record<string, unknown> = {}, extra: RequestInit = {}): Observable<T> {
+    return this.request<T>('POST', url, data, extra);
+  }
+
+  private handleRequest(url: string, method: HttpMethod): RequestInit {
+    const headers: Record<string, string> = {};
+
+    // 只有 POST 请求才设置 Content-Type
+    if (method === 'POST') {
+      headers['Content-Type'] = 'application/x-ndjson';
     }
 
-    const token = getToken()
+    const config: RequestInit = { headers };
+    const token = getToken();
 
-    if (!token && this.options.filter_url?.some(_url => _url.includes(url))) {
-      this.options.tokenExpiration?.()
-      return config
+    if (!token && this.options.filter_url?.some(_url => url.includes(_url))) {
+      this.options.tokenExpiration?.();
+      return config;
     }
 
-    if (!config.headers[TOKEN_KEY]) {
-      config.headers[TOKEN_KEY] = token
+    if (token) {
+      headers[TOKEN_KEY] = token;
     }
 
     if (this.options.requestOptions && isFunction(this.options.requestOptions)) {
-      const extraOptions = this.options.requestOptions(config)
+      const extraOptions = this.options.requestOptions(config);
       if (extraOptions && isObject(extraOptions)) {
-        for (const key in extraOptions) {
-          config[key] = extraOptions[key]
-        }
+        Object.assign(config, extraOptions);
       }
     }
 
-    return config
+    return config;
   }
 
-  handleResponse(response) {
-
+  handleResponse<T>(response: T): T {
     if (this.options.handleResponse && isFunction(this.options.handleResponse)) {
-      return this.options.handleResponse(response)
+      return this.options.handleResponse(response);
     }
-
-    // const status = response[this.options.codeKey || 'status']
-    // response.success = status === this.options.code
-
-    return response
+    return response;
   }
 
-  cancel() {
-    if (this.isRead) {
-      this.isRead = false
-    }
-
-    if (this.controller) {
-      this.controller.abort()
-    }
+  /**
+   * 取消所有活跃的请求
+   */
+  cancelAll(): void {
+    this.activeRequests.forEach(context => {
+      context.isActive = false;
+      context.controller.abort();
+    });
+    this.activeRequests.clear();
   }
 }
 
-
-export const ndJson = new NdJson()
+// 默认实例
+const defaultNdJson = new NdJson();
+
+/**
+ * 创建新的 NdJson 实例
+ */
+export const createNdJson = (options?: NdJsonOptions): NdJson => {
+  return new NdJson(options);
+};
+
+/**
+ * 初始化默认实例
+ */
+export const createNdJsonService = (options: NdJsonOptions): void => {
+  defaultNdJson.create(options);
+};
+
+// 导出默认实例 (保持向后兼容)
+export const ndJson = defaultNdJson;

package/src/type.ts

@@ -1,7 +1,14 @@
 import type {AxiosError, AxiosResponse, InternalAxiosRequestConfig} from "axios";
 
+export interface AxiosResponseRewrite<T = any>
+  extends AxiosResponse<T, any> {
+  result: T
+  success: boolean
+}
+
+
 export interface Options {
-  tokenExpiration: (err?: AxiosError<any>, response?: AxiosResponse) => void
+  tokenExpiration: (err?: AxiosError<any>, response?: AxiosResponseRewrite) => void
   handleReconnect: () => Promise<any>
   filter_url?: Array<string>
   code?: number
@@ -16,7 +23,7 @@ export interface Options {
    * response处理函数
    * @param response AxiosResponse实例
    */
-  handleResponse?: (response: AxiosResponse) => void
+  handleResponse?: (response: AxiosResponseRewrite) => void
   /**
    * 错误处理函数
    * @param msg 错误消息
@@ -30,15 +37,17 @@ export interface Options {
 
 export interface ExpandRequestConfig extends InternalAxiosRequestConfig {
   __requestKey?: string
+  _retry?: boolean
 }
 
-export interface ExpandAxiosResponse extends AxiosResponse {
+export interface ExpandAxiosResponse<T = any> extends AxiosResponseRewrite<T> {
   config: ExpandRequestConfig
   message: string
 }
 
-export interface ExpandAxiosError<T> extends AxiosError<T> {
-  response: ExpandAxiosResponse
+export interface ExpandAxiosError<T = any> extends Omit<AxiosError<T>, 'config'> {
+  config?: ExpandRequestConfig
+  response?: ExpandAxiosResponse<T>
 }
 
 export interface PageResult<T> {