@reskin/core 0.0.21 → 0.1.0

package/bundles/reskin-core-interceptors.umd.js

@@ -503,31 +503,54 @@
       __disposeResources: __disposeResources,
   };
 
+  /**
+   * Token 拦截器常量
+   */
+  var DEFAULT_TOKEN_HEADER_NAME = 'Authorization';
+  var TOKEN_CONTROL_HEADER = 'Token-Control';
+  var CUSTOM_TOKEN_HEADER = 'Custom-Token';
+  var CUSTOM_TOKEN_HEADER_NAME = 'Custom-Token-Header';
+  var AUTH_ID_HEADER = 'X-Auth-Id';
+  /**
+   * Token 拦截器
+   * 自动为 HTTP 请求添加认证 Token
+   */
   var TokenInterceptor = /** @class */ (function () {
-      function TokenInterceptor(service) {
-          this.service = service;
+      function TokenInterceptor(authService) {
+          this.authService = authService;
       }
+      /**
+       * 拦截 HTTP 请求，添加 Token 认证信息
+       * @param request HTTP 请求对象
+       * @param next 下一个拦截器处理器
+       * @returns Observable<HttpEvent<unknown>>
+       */
       TokenInterceptor.prototype.intercept = function (request, next) {
-          var tc = request.headers.get('Token-Control');
-          // 检查是否提供了自定义token
-          var customToken = request.headers.get('Custom-Token');
-          if (tc !== 'no-token') {
-              var headers = {};
-              if (customToken) {
-                  // 使用自定义token
-                  headers['Authorization'] = customToken;
-              }
-              else {
-                  // 使用默认认证信息
-                  var auth = this.service.token;
-                  if (auth.token) {
-                      headers['Authorization'] = auth.token;
-                      headers['X-Auth-Id'] = auth.id;
+          var tokenControl = request.headers.get(TOKEN_CONTROL_HEADER);
+          // 如果明确指定不需要 Token，直接放行
+          if (tokenControl === 'no-token') {
+              return next.handle(request);
+          }
+          var customToken = request.headers.get(CUSTOM_TOKEN_HEADER);
+          var customTokenHeaderName = request.headers.get(CUSTOM_TOKEN_HEADER_NAME) || DEFAULT_TOKEN_HEADER_NAME;
+          var headers = {};
+          if (customToken) {
+              // 使用自定义 Token
+              headers[customTokenHeaderName] = customToken;
+          }
+          else {
+              // 使用默认认证信息
+              var auth = this.authService.token;
+              if (auth === null || auth === void 0 ? void 0 : auth.token) {
+                  headers[DEFAULT_TOKEN_HEADER_NAME] = auth.token;
+                  if (auth.id) {
+                      headers[AUTH_ID_HEADER] = auth.id;
                   }
               }
-              if (Object.keys(headers).length > 0) {
-                  request = request.clone({ setHeaders: headers });
-              }
+          }
+          // 如果有需要添加的 Header，克隆请求并添加
+          if (Object.keys(headers).length > 0) {
+              request = request.clone({ setHeaders: headers });
           }
           return next.handle(request);
       };
@@ -539,64 +562,157 @@
               type: i0.Injectable
           }], ctorParameters: function () { return [{ type: i1__namespace.RkAuthService }]; } });
   /**
-   * 请求头增加token验证拦截器
+   * 提供 Token 拦截器
+   * @returns Provider 配置对象
    */
   function providerAuthToken() {
       return { provide: http.HTTP_INTERCEPTORS, useClass: TokenInterceptor, multi: true };
   }
   /**
-   * 不带token验证信息请求
-   * @param urls 地址
-   * @param params 参数
-   * @constructor
+   * 创建不带 Token 的请求配置
+   * @param urls 模板字符串数组
+   * @param params 模板参数
+   * @returns [url, options] 元组
+   * @example
+   * this.http.get(...NoAuthTokenTemplate`/api/public/data`).subscribe();
    */
   function NoAuthTokenTemplate(urls) {
+      var _a;
       var params = [];
       for (var _i = 1; _i < arguments.length; _i++) {
           params[_i - 1] = arguments[_i];
       }
-      var _a = __read(urls, 1), url = _a[0];
-      if (params.length > 0) {
-          url = String.raw.apply(String, __spreadArray([urls], __read(params)));
-      }
-      return [url, { headers: new http.HttpHeaders({ 'Token-Control': 'no-token' }) }];
+      var url = params.length > 0 ? String.raw.apply(String, __spreadArray([urls], __read(params))) : urls[0];
+      return [url, { headers: new http.HttpHeaders((_a = {}, _a[TOKEN_CONTROL_HEADER] = 'no-token', _a)) }];
   }
   /**
-   * 使用自定义token的请求(模板字符串版本)
-   * @param urls 地址
-   * @param params 参数，第一个参数必须是token值
-   * @constructor
+   * 创建使用自定义 Token 的请求配置
+   * @param token 自定义 Token 值
+   * @param urls 模板字符串数组
+   * @param params 模板参数
+   * @returns [url, options] 元组
+   * @example
+   * this.http.get(...CustomTokenTemplate('my-token', `/api/data`)).subscribe();
    */
-  function CustomTokenTemplate(urls) {
+  function CustomTokenTemplate(token, urls) {
+      var _a;
       var params = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-          params[_i - 1] = arguments[_i];
+      for (var _i = 2; _i < arguments.length; _i++) {
+          params[_i - 2] = arguments[_i];
       }
-      if (params.length === 0) {
-          throw new Error('CustomTokenTemplate 至少需要一个参数作为token值');
+      var url = params.length > 0 ? String.raw.apply(String, __spreadArray([urls], __read(params))) : urls[0];
+      return [url, { headers: new http.HttpHeaders((_a = {}, _a[CUSTOM_TOKEN_HEADER] = token, _a)) }];
+  }
+  /**
+   * 创建使用自定义 Token 和自定义 Header 名称的请求配置
+   * @param token 自定义 Token 值
+   * @param headerName 自定义 Header 名称
+   * @param urls 模板字符串数组
+   * @param params 模板参数
+   * @returns [url, options] 元组
+   * @example
+   * this.http.get(...CustomTokenWithHeaderTemplate('my-token', 'X-API-Key', `/api/data`)).subscribe();
+   */
+  function CustomTokenWithHeaderTemplate(token, headerName, urls) {
+      var _a;
+      var params = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+          params[_i - 3] = arguments[_i];
       }
-      var token = params[0];
-      var url = String.raw.apply(String, __spreadArray([urls], __read(params.slice(1))));
-      return [url, { headers: new http.HttpHeaders({ 'Custom-Token': token }) }];
+      var url = params.length > 0 ? String.raw.apply(String, __spreadArray([urls], __read(params))) : urls[0];
+      return [
+          url,
+          {
+              headers: new http.HttpHeaders((_a = {},
+                  _a[CUSTOM_TOKEN_HEADER] = token,
+                  _a[CUSTOM_TOKEN_HEADER_NAME] = headerName,
+                  _a)),
+          },
+      ];
   }
 
+  /**
+   * 默认配置
+   */
+  var DEFAULT_CONFIG = {
+      unauthorizedPath: '/errors/401',
+      enableLogging: false,
+  };
+  /**
+   * HTTP 错误拦截器
+   * 统一处理 HTTP 请求错误，包括 401 未授权错误的自动跳转
+   */
   var ErrorInterceptor = /** @class */ (function () {
       function ErrorInterceptor(router) {
           this.router = router;
+          this.config = DEFAULT_CONFIG;
       }
+      /**
+       * 设置拦截器配置
+       * @param config 配置对象
+       */
+      ErrorInterceptor.prototype.setConfig = function (config) {
+          this.config = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
+      };
+      /**
+       * 拦截 HTTP 请求，处理错误响应
+       * @param request HTTP 请求对象
+       * @param next 下一个拦截器处理器
+       * @returns Observable<HttpEvent<unknown>>
+       */
       ErrorInterceptor.prototype.intercept = function (request, next) {
           var _this = this;
-          return next.handle(request).pipe(operators.catchError(function (result) {
-              var _a;
-              if (result.status === 401) {
-                  _this.router.navigate(['/errors/401']).then();
+          return next.handle(request).pipe(operators.catchError(function (error) {
+              // 处理 401 未授权错误
+              if (error.status === 401) {
+                  _this.handleUnauthorizedError();
+                  return rxjs.throwError(error);
               }
-              if (result.error.code) {
-                  return rxjs.of(result.error);
+              // 记录错误日志
+              if (_this.config.enableLogging) {
+                  console.error('[HTTP Error]', {
+                      url: request.url,
+                      method: request.method,
+                      status: error.status,
+                      message: error.message,
+                      error: error.error,
+                  });
               }
-              throw (_a = result.error.msg) !== null && _a !== void 0 ? _a : result.message;
+              // 提取错误信息
+              var errorMessage = _this.extractErrorMessage(error);
+              return rxjs.throwError(new Error(errorMessage));
           }));
       };
+      /**
+       * 处理 401 未授权错误
+       */
+      ErrorInterceptor.prototype.handleUnauthorizedError = function () {
+          var path = this.config.unauthorizedPath || DEFAULT_CONFIG.unauthorizedPath;
+          this.router.navigate([path]).catch(function (err) {
+              console.error('导航到错误页面失败:', err);
+          });
+      };
+      /**
+       * 提取错误信息
+       * @param error HTTP 错误响应
+       * @returns 错误信息字符串
+       */
+      ErrorInterceptor.prototype.extractErrorMessage = function (error) {
+          if (error.error) {
+              // 尝试从 error.error 中提取信息
+              if (typeof error.error === 'string') {
+                  return error.error;
+              }
+              if (error.error.msg) {
+                  return error.error.msg;
+              }
+              if (error.error.message) {
+                  return error.error.message;
+              }
+          }
+          // 使用默认错误信息
+          return error.message || "HTTP Error " + error.status;
+      };
       return ErrorInterceptor;
   }());
   ErrorInterceptor.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ErrorInterceptor, deps: [{ token: i1__namespace$1.Router }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
@@ -605,28 +721,71 @@
               type: i0.Injectable
           }], ctorParameters: function () { return [{ type: i1__namespace$1.Router }]; } });
   /**
-   * 请求错误拦截器
+   * 提供 HTTP 错误拦截器
+   * @param config 可选的配置对象
+   * @returns Provider 配置对象
+   * @example
+   * providers: [
+   *   providerHttpError({ unauthorizedPath: '/login', enableLogging: true })
+   * ]
    */
-  function providerHttpError() {
-      return { provide: http.HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true };
+  function providerHttpError(config) {
+      if (config) {
+          // 如果有配置，使用 useFactory
+          return {
+              provide: http.HTTP_INTERCEPTORS,
+              useFactory: function (router) {
+                  var interceptor = new ErrorInterceptor(router);
+                  interceptor.setConfig(config);
+                  return interceptor;
+              },
+              deps: [i1$1.Router],
+              multi: true,
+          };
+      }
+      else {
+          // 没有配置，直接使用 useClass
+          return {
+              provide: http.HTTP_INTERCEPTORS,
+              useClass: ErrorInterceptor,
+              multi: true,
+          };
+      }
   }
 
+  /**
+   * 缓存策略标识
+   */
+  var CACHE_HEADER = 'Cache-Map';
+  var CACHE_STRATEGY = 'Storage';
+  /**
+   * HTTP 缓存拦截器
+   * 为 GET 请求提供缓存功能，减少重复请求
+   */
   var CacheInterceptor = /** @class */ (function () {
-      function CacheInterceptor(cacheHttp) {
-          this.cacheHttp = cacheHttp;
+      function CacheInterceptor(cacheHttpService) {
+          this.cacheHttpService = cacheHttpService;
       }
+      /**
+       * 拦截 HTTP 请求，实现缓存逻辑
+       * @param request HTTP 请求对象
+       * @param next 下一个拦截器处理器
+       * @returns Observable<HttpEvent<unknown>>
+       */
       CacheInterceptor.prototype.intercept = function (request, next) {
-          // 1.判断是GET
-          // 2.header中添加 Cache-Map: Storage
-          var cacheMap = request.headers.get('Cache-Map');
-          if (request.method === 'GET' && cacheMap === 'Storage') {
-              var response = this.cacheHttp.get(request.url);
-              if (!response) {
-                  response = next.handle(request).pipe(operators.shareReplay(1));
-                  this.cacheHttp.set(request.url, response);
+          // 只缓存 GET 请求且明确标记了缓存策略的请求
+          var cacheStrategy = request.headers.get(CACHE_HEADER);
+          if (request.method === 'GET' && cacheStrategy === CACHE_STRATEGY) {
+              // 尝试从缓存中获取响应
+              var cachedResponse = this.cacheHttpService.get(request.url);
+              if (!cachedResponse) {
+                  // 缓存未命中，发起请求并缓存结果
+                  cachedResponse = next.handle(request).pipe(operators.shareReplay(1));
+                  this.cacheHttpService.set(request.url, cachedResponse);
               }
-              return response;
+              return cachedResponse;
           }
+          // 非缓存请求，直接放行
           return next.handle(request);
       };
       return CacheInterceptor;
@@ -637,63 +796,118 @@
               type: i0.Injectable
           }], ctorParameters: function () { return [{ type: i1__namespace.RkCacheHttpService }]; } });
   /**
-   * GET请求缓存拦截器
+   * 提供 HTTP 缓存拦截器
+   * @returns Provider 配置对象
+   * @example
+   * providers: [providerHttpCache()]
    */
   function providerHttpCache() {
       return { provide: http.HTTP_INTERCEPTORS, useClass: CacheInterceptor, multi: true };
+  }
+  /**
+   * 创建带缓存标记的 GET 请求配置
+   * @param urls 模板字符串数组
+   * @param params 模板参数
+   * @returns [url, options] 元组
+   * @example
+   * this.http.get(...CacheHttpTemplate`/api/data`).subscribe();
+   */
+  function CacheHttpTemplate(urls) {
+      var _a;
+      var params = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+          params[_i - 1] = arguments[_i];
+      }
+      var url = params.length > 0 ? String.raw.apply(String, __spreadArray([urls], __read(params))) : urls[0];
+      return [url, { headers: new http.HttpHeaders((_a = {}, _a[CACHE_HEADER] = CACHE_STRATEGY, _a)) }];
   }
 
+  /**
+   * Blob 响应拦截器
+   * 处理文件下载请求中的 JSON 错误响应
+   */
   var BlobInterceptor = /** @class */ (function () {
       function BlobInterceptor() {
       }
+      /**
+       * 拦截 HTTP 请求，处理 Blob 类型响应
+       * @param request HTTP 请求对象
+       * @param next 下一个拦截器处理器
+       * @returns Observable<HttpEvent<T>>
+       */
       BlobInterceptor.prototype.intercept = function (request, next) {
           var _this = this;
+          // 只处理 responseType 为 blob 的请求
           if (request.responseType !== 'blob') {
               return next.handle(request);
           }
-          return next.handle(request).pipe(operators.switchMap(function (response) { return _this.handleBlobResponse(response); }), operators.catchError(function (response) { return _this.handleBlobError(response); }));
+          return next.handle(request).pipe(operators.switchMap(function (event) { return _this.handleBlobResponse(event); }), operators.catchError(function (error) { return _this.handleBlobError(error); }));
       };
-      BlobInterceptor.prototype.handleBlobResponse = function (response) {
-          var _this = this;
-          if (response.type !== http.HttpEventType.Response) {
+      /**
+       * 处理 Blob 响应事件
+       * @param event HTTP 事件
+       * @returns Observable<HttpEvent<any>>
+       */
+      BlobInterceptor.prototype.handleBlobResponse = function (event) {
+          var _a;
+          // 只处理完整的响应事件
+          if (event.type !== http.HttpEventType.Response) {
               return new rxjs.Observable(function (subscriber) {
-                  subscriber.next(response);
+                  subscriber.next(event);
                   subscriber.complete();
               });
           }
-          if (response instanceof http.HttpResponse && response.body && response.body.type === 'application/json') {
-              return new rxjs.Observable(function (subscriber) { return _this.blobToJson(response.body, subscriber); });
+          // 检查响应体是否为 JSON 类型（通常表示错误）
+          if (event instanceof http.HttpResponse && ((_a = event.body) === null || _a === void 0 ? void 0 : _a.type) === 'application/json') {
+              return this.convertBlobToJson(event.body);
           }
           return new rxjs.Observable(function (subscriber) {
-              subscriber.next(response);
+              subscriber.next(event);
               subscriber.complete();
           });
       };
-      BlobInterceptor.prototype.handleBlobError = function (response) {
-          var _this = this;
-          if (response.error && response.error.type === 'application/json') {
-              return new rxjs.Observable(function (subscriber) { return _this.blobToJson(response.error, subscriber); });
+      /**
+       * 处理 Blob 错误响应
+       * @param error HTTP 错误响应
+       * @returns Observable<HttpEvent<any>>
+       */
+      BlobInterceptor.prototype.handleBlobError = function (error) {
+          var _a;
+          // 如果错误响应体是 JSON 类型的 Blob，转换为 JSON 对象
+          if (((_a = error.error) === null || _a === void 0 ? void 0 : _a.type) === 'application/json') {
+              return this.convertBlobToJson(error.error);
           }
           return new rxjs.Observable(function (subscriber) {
-              subscriber.error(response);
+              subscriber.error(error);
               subscriber.complete();
           });
       };
-      BlobInterceptor.prototype.blobToJson = function (blob, subscriber) {
-          var reader = new FileReader();
-          reader.addEventListener('loadend', function () {
-              try {
-                  var json = JSON.parse(reader.result);
-                  subscriber.error(json);
-              }
-              catch (error) {
-                  subscriber.error(error);
-              }
-              finally {
+      /**
+       * 将 Blob 转换为 JSON 对象并抛出错误
+       * @param blob Blob 对象
+       * @returns Observable<HttpEvent<T>>
+       */
+      BlobInterceptor.prototype.convertBlobToJson = function (blob) {
+          return new rxjs.Observable(function (subscriber) {
+              var reader = new FileReader();
+              reader.addEventListener('loadend', function () {
+                  try {
+                      var json = JSON.parse(reader.result);
+                      subscriber.error(json);
+                  }
+                  catch (parseError) {
+                      subscriber.error(parseError);
+                  }
+                  finally {
+                      subscriber.complete();
+                  }
+              });
+              reader.addEventListener('error', function () {
+                  subscriber.error(new Error('读取 Blob 数据失败'));
                   subscriber.complete();
-              }
+              });
+              reader.readAsText(blob, 'utf-8');
           });
-          reader.readAsText(blob, 'utf-8');
       };
       return BlobInterceptor;
   }());
@@ -703,8 +917,10 @@
               type: i0.Injectable
           }] });
   /**
-   * 下载文件拦截器
-   * blob类型的请求会被处理
+   * 提供 Blob 响应拦截器
+   * @returns Provider 配置对象
+   * @example
+   * providers: [providerDownBlob()]
    */
   function providerDownBlob() {
       return { provide: http.HTTP_INTERCEPTORS, useClass: BlobInterceptor, multi: true };
@@ -715,8 +931,10 @@
    */
 
   exports.BlobInterceptor = BlobInterceptor;
+  exports.CacheHttpTemplate = CacheHttpTemplate;
   exports.CacheInterceptor = CacheInterceptor;
   exports.CustomTokenTemplate = CustomTokenTemplate;
+  exports.CustomTokenWithHeaderTemplate = CustomTokenWithHeaderTemplate;
   exports.ErrorInterceptor = ErrorInterceptor;
   exports.NoAuthTokenTemplate = NoAuthTokenTemplate;
   exports.TokenInterceptor = TokenInterceptor;