@reskin/core 0.0.21 → 0.1.0

package/esm2015/guards/auth.guard.js

@@ -1,5 +1,6 @@
-import { Inject, Injectable, InjectionToken } from '@angular/core';
-import { filter, map, catchError } from 'rxjs/operators';
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, filter, map } from 'rxjs/operators';
 import * as i0 from "@angular/core";
 import * as i1 from "@reskin/core/services";
 import * as i2 from "@angular/router";
@@ -7,60 +8,139 @@ import * as i2 from "@angular/router";
  * 路由守卫配置注入令牌
  */
 export const RK_ROUTER_GUARD_CONFIG = new InjectionToken('router_guard_config');
+/**
+ * 路由守卫选项注入令牌
+ */
+export const RK_ROUTER_GUARD_OPTIONS = new InjectionToken('router_guard_options');
 /**
  * 路由守卫提供者配置函数
  *
  * @param urls - 路由守卫配置数组，包含需要保护的路由配置信息
+ * @param options - 可选的守卫选项配置
  * @returns 返回Angular依赖注入的Provider数组，用于配置路由守卫
  */
-export function providerRouterGuard(urls) {
-    return [
-        // 路由守卫配置
-        { provide: RK_ROUTER_GUARD_CONFIG, useValue: urls },
-    ];
+export function providerRouterGuard(urls, options) {
+    const providers = [{ provide: RK_ROUTER_GUARD_CONFIG, useValue: urls }];
+    if (options) {
+        providers.push({ provide: RK_ROUTER_GUARD_OPTIONS, useValue: options });
+    }
+    return providers;
 }
+/**
+ * 路由权限守卫
+ *
+ * 用于保护路由，确保用户只能访问其被授权的路由。
+ * 支持权限继承机制和自定义权限检查逻辑。
+ */
 export class RkAuthGuard {
-    constructor(config, menu, router) {
+    constructor(config, options, menu, router) {
         this.config = config;
+        this.options = options;
         this.menu = menu;
         this.router = router;
     }
     canActivateChild(childRoute, state) {
-        return this.menu.requestData().pipe(filter((json) => json.code === 0), map((json) => json.data), map((menus) => this.checkAccess(menus, childRoute, state.url)), catchError(() => {
-            this.handleNoAccess(state.url);
-            return [false];
+        var _a;
+        // 检查路由数据中是否配置跳过权限检查
+        if (childRoute.data['skipAuth'] === true) {
+            return true;
+        }
+        // 执行前置钩子
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.beforeCheck) && !this.options.beforeCheck(childRoute, state)) {
+            return this.handleNoAccess(state.url);
+        }
+        return this.menu.requestData().pipe(filter((json) => json.code === 0), map((json) => json.data), map((menus) => this.checkAccess(menus, state.url)), catchError((error) => {
+            console.error('路由权限检查失败:', error);
+            return of(this.handleNoAccess(state.url));
         }));
     }
-    checkAccess(menus, childRoute, url) {
-        if (!menus.length) {
-            throw new Error(`此账号无任何功能权限.`);
+    /**
+     * 检查用户是否有权限访问指定路由
+     *
+     * @param menus - 用户菜单权限数据
+     * @param url - 目标路由地址
+     * @returns 返回 true 允许访问，返回 false 或 UrlTree 拒绝访问
+     */
+    checkAccess(menus, url) {
+        if (!menus || menus.length === 0) {
+            console.error('此账号无任何功能权限');
+            return this.handleNoAccess(url);
         }
-        const routerUrl = url.replace(/\?.*/, '');
+        // 移除查询参数，只保留路径部分
+        const routerUrl = this.normalizeUrl(url);
+        // 构建用户权限路由集合
         const authRoutes = new Set(menus.map((m) => m.SYSTEM_RESOURCE_URL));
+        // 直接权限检查
         if (authRoutes.has(routerUrl)) {
             return true;
         }
-        if (this.config && this.config.length > 0) {
-            const extendRoutes = this.config.filter((item) => {
-                return item.extends.some((route) => (route.includes('**') ? this.match(route, routerUrl) : route === routerUrl));
-            });
-            if (extendRoutes.length > 0) {
-                return extendRoutes.some((item) => authRoutes.has(item.url));
-            }
+        // 继承权限检查
+        if (this.hasInheritedPermission(routerUrl, authRoutes)) {
+            return true;
+        }
+        // 无权限访问
+        return this.handleNoAccess(url);
+    }
+    /**
+     * 检查是否有继承的权限
+     *
+     * @param routerUrl - 标准化后的路由地址
+     * @param authRoutes - 用户权限路由集合
+     * @returns 返回 true 表示有继承权限
+     */
+    hasInheritedPermission(routerUrl, authRoutes) {
+        if (!this.config || this.config.length === 0) {
+            return false;
+        }
+        // 查找匹配的继承配置
+        const matchedConfigs = this.config.filter((item) => {
+            return item.extends.some((route) => this.matchRoute(route, routerUrl));
+        });
+        // 检查是否有任一配置的 url 在用户权限中
+        return matchedConfigs.some((item) => authRoutes.has(item.url));
+    }
+    /**
+     * 匹配路由规则
+     *
+     * @param pattern - 路由模式（支持 ** 通配符）
+     * @param path - 实际路由路径
+     * @returns 返回 true 表示匹配成功
+     */
+    matchRoute(pattern, path) {
+        if (pattern.includes('**')) {
+            const regexPattern = pattern.replace(/\*\*/g, '.*');
+            return new RegExp(`^${regexPattern}$`).test(path);
         }
-        this.handleNoAccess(url);
-        return false;
+        return pattern === path;
     }
-    match(pattern, path) {
-        const regexPattern = pattern.replace(/\*\*/g, '.*');
-        return new RegExp(`^${regexPattern}$`).test(path);
+    /**
+     * 标准化URL，移除查询参数和片段标识符
+     *
+     * @param url - 原始URL
+     * @returns 标准化后的URL
+     */
+    normalizeUrl(url) {
+        return url.replace(/[?#].*/, '');
     }
+    /**
+     * 处理无权限访问
+     *
+     * @param url - 被拒绝访问的路由地址
+     * @returns 返回 false 或 UrlTree
+     */
     handleNoAccess(url) {
+        var _a, _b;
         console.error(`无权限访问路由地址: ${url}`);
-        this.router.navigate(['/errors/401']).then();
+        // 使用自定义回调
+        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.onAccessDenied) {
+            return this.options.onAccessDenied(url);
+        }
+        // 使用自定义未授权路径或默认路径
+        const unauthorizedPath = ((_b = this.options) === null || _b === void 0 ? void 0 : _b.unauthorizedPath) || '/errors/401';
+        return this.router.createUrlTree([unauthorizedPath]);
     }
 }
-RkAuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthGuard, deps: [{ token: RK_ROUTER_GUARD_CONFIG }, { token: i1.RkMenuService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RkAuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthGuard, deps: [{ token: RK_ROUTER_GUARD_CONFIG, optional: true }, { token: RK_ROUTER_GUARD_OPTIONS, optional: true }, { token: i1.RkMenuService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
 RkAuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthGuard, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthGuard, decorators: [{
             type: Injectable,
@@ -68,7 +148,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
                     type: Inject,
                     args: [RK_ROUTER_GUARD_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RK_ROUTER_GUARD_OPTIONS]
                 }] }, { type: i1.RkMenuService }, { type: i2.Router }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.guard.js","sourceRoot":"","sources":["../../../../library/core/guards/auth.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional, Provider } from '@angular/core';\r\nimport { ActivatedRouteSnapshot, CanActivateChild, Router, RouterStateSnapshot, UrlTree } from '@angular/router';\r\nimport { Observable, of } from 'rxjs';\r\nimport { catchError, filter, map } from 'rxjs/operators';\r\nimport { RkMenuService } from '@reskin/core/services';\r\n\r\n/**\r\n * 路由守卫配置注入令牌\r\n */\r\nexport const RK_ROUTER_GUARD_CONFIG = new InjectionToken<IRouterGuardConfig[]>('router_guard_config');\r\n\r\n/**\r\n * 路由守卫选项注入令牌\r\n */\r\nexport const RK_ROUTER_GUARD_OPTIONS = new InjectionToken<IAuthGuardOptions>('router_guard_options');\r\n\r\n/**\r\n * 菜单数据接口\r\n */\r\nexport interface IMenuData {\r\n    /**\r\n     * 系统资源URL\r\n     */\r\n    SYSTEM_RESOURCE_URL: string;\r\n    [key: string]: any;\r\n}\r\n\r\n/**\r\n * 路由守卫配置\r\n */\r\nexport interface IRouterGuardConfig {\r\n    /**\r\n     * 路由地址\r\n     */\r\n    url: string;\r\n    /**\r\n     * 继承的权限\r\n     */\r\n    extends: string[];\r\n}\r\n\r\n/**\r\n * 路由守卫选项配置\r\n */\r\nexport interface IAuthGuardOptions {\r\n    /**\r\n     * 无权限时的跳转路径\r\n     * @default '/errors/401'\r\n     */\r\n    unauthorizedPath?: string;\r\n    /**\r\n     * 自定义无权限处理回调\r\n     * @param url - 被拒绝访问的路由地址\r\n     * @returns 返回 false 阻止导航，返回 UrlTree 进行重定向，返回 true 允许访问\r\n     */\r\n    onAccessDenied?: (url: string) => boolean | UrlTree;\r\n    /**\r\n     * 权限检查前的钩子函数\r\n     * @param route - 激活的路由快照\r\n     * @param state - 路由状态快照\r\n     * @returns 返回 false 跳过权限检查并拒绝访问，返回 true 继续权限检查\r\n     */\r\n    beforeCheck?: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;\r\n}\r\n\r\n/**\r\n * 路由守卫提供者配置函数\r\n *\r\n * @param urls - 路由守卫配置数组，包含需要保护的路由配置信息\r\n * @param options - 可选的守卫选项配置\r\n * @returns 返回Angular依赖注入的Provider数组，用于配置路由守卫\r\n */\r\nexport function providerRouterGuard(urls: IRouterGuardConfig[], options?: IAuthGuardOptions): Provider[] {\r\n    const providers: Provider[] = [{ provide: RK_ROUTER_GUARD_CONFIG, useValue: urls }];\r\n\r\n    if (options) {\r\n        providers.push({ provide: RK_ROUTER_GUARD_OPTIONS, useValue: options });\r\n    }\r\n\r\n    return providers;\r\n}\r\n\r\n/**\r\n * 路由权限守卫\r\n *\r\n * 用于保护路由，确保用户只能访问其被授权的路由。\r\n * 支持权限继承机制和自定义权限检查逻辑。\r\n */\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class RkAuthGuard implements CanActivateChild {\r\n    constructor(\r\n        @Optional() @Inject(RK_ROUTER_GUARD_CONFIG) private config: IRouterGuardConfig[] | null,\r\n        @Optional() @Inject(RK_ROUTER_GUARD_OPTIONS) private options: IAuthGuardOptions | null,\r\n        private menu: RkMenuService,\r\n        private router: Router,\r\n    ) {}\r\n\r\n    canActivateChild(\r\n        childRoute: ActivatedRouteSnapshot,\r\n        state: RouterStateSnapshot,\r\n    ): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree {\r\n        // 检查路由数据中是否配置跳过权限检查\r\n        if (childRoute.data['skipAuth'] === true) {\r\n            return true;\r\n        }\r\n\r\n        // 执行前置钩子\r\n        if (this.options?.beforeCheck && !this.options.beforeCheck(childRoute, state)) {\r\n            return this.handleNoAccess(state.url);\r\n        }\r\n\r\n        return this.menu.requestData().pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data as IMenuData[]),\r\n            map((menus) => this.checkAccess(menus, state.url)),\r\n            catchError((error) => {\r\n                console.error('路由权限检查失败:', error);\r\n                return of(this.handleNoAccess(state.url));\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 检查用户是否有权限访问指定路由\r\n     *\r\n     * @param menus - 用户菜单权限数据\r\n     * @param url - 目标路由地址\r\n     * @returns 返回 true 允许访问，返回 false 或 UrlTree 拒绝访问\r\n     */\r\n    private checkAccess(menus: IMenuData[], url: string): boolean | UrlTree {\r\n        if (!menus || menus.length === 0) {\r\n            console.error('此账号无任何功能权限');\r\n            return this.handleNoAccess(url);\r\n        }\r\n\r\n        // 移除查询参数，只保留路径部分\r\n        const routerUrl = this.normalizeUrl(url);\r\n\r\n        // 构建用户权限路由集合\r\n        const authRoutes = new Set<string>(menus.map((m) => m.SYSTEM_RESOURCE_URL));\r\n\r\n        // 直接权限检查\r\n        if (authRoutes.has(routerUrl)) {\r\n            return true;\r\n        }\r\n\r\n        // 继承权限检查\r\n        if (this.hasInheritedPermission(routerUrl, authRoutes)) {\r\n            return true;\r\n        }\r\n\r\n        // 无权限访问\r\n        return this.handleNoAccess(url);\r\n    }\r\n\r\n    /**\r\n     * 检查是否有继承的权限\r\n     *\r\n     * @param routerUrl - 标准化后的路由地址\r\n     * @param authRoutes - 用户权限路由集合\r\n     * @returns 返回 true 表示有继承权限\r\n     */\r\n    private hasInheritedPermission(routerUrl: string, authRoutes: Set<string>): boolean {\r\n        if (!this.config || this.config.length === 0) {\r\n            return false;\r\n        }\r\n\r\n        // 查找匹配的继承配置\r\n        const matchedConfigs = this.config.filter((item) => {\r\n            return item.extends.some((route: string) => this.matchRoute(route, routerUrl));\r\n        });\r\n\r\n        // 检查是否有任一配置的 url 在用户权限中\r\n        return matchedConfigs.some((item) => authRoutes.has(item.url));\r\n    }\r\n\r\n    /**\r\n     * 匹配路由规则\r\n     *\r\n     * @param pattern - 路由模式（支持 ** 通配符）\r\n     * @param path - 实际路由路径\r\n     * @returns 返回 true 表示匹配成功\r\n     */\r\n    private matchRoute(pattern: string, path: string): boolean {\r\n        if (pattern.includes('**')) {\r\n            const regexPattern = pattern.replace(/\\*\\*/g, '.*');\r\n            return new RegExp(`^${regexPattern}$`).test(path);\r\n        }\r\n        return pattern === path;\r\n    }\r\n\r\n    /**\r\n     * 标准化URL，移除查询参数和片段标识符\r\n     *\r\n     * @param url - 原始URL\r\n     * @returns 标准化后的URL\r\n     */\r\n    private normalizeUrl(url: string): string {\r\n        return url.replace(/[?#].*/, '');\r\n    }\r\n\r\n    /**\r\n     * 处理无权限访问\r\n     *\r\n     * @param url - 被拒绝访问的路由地址\r\n     * @returns 返回 false 或 UrlTree\r\n     */\r\n    private handleNoAccess(url: string): boolean | UrlTree {\r\n        console.error(`无权限访问路由地址: ${url}`);\r\n\r\n        // 使用自定义回调\r\n        if (this.options?.onAccessDenied) {\r\n            return this.options.onAccessDenied(url);\r\n        }\r\n\r\n        // 使用自定义未授权路径或默认路径\r\n        const unauthorizedPath = this.options?.unauthorizedPath || '/errors/401';\r\n        return this.router.createUrlTree([unauthorizedPath]);\r\n    }\r\n}\r\n"]}

package/esm2015/interceptors/blob.interceptor.js

@@ -1,54 +1,91 @@
 import { Injectable } from '@angular/core';
 import { HttpEventType, HttpResponse, HTTP_INTERCEPTORS, } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { catchError, switchMap } from 'rxjs/operators';
+import { switchMap, catchError } from 'rxjs/operators';
 import * as i0 from "@angular/core";
+/**
+ * Blob 响应拦截器
+ * 处理文件下载请求中的 JSON 错误响应
+ */
 export class BlobInterceptor {
+    /**
+     * 拦截 HTTP 请求，处理 Blob 类型响应
+     * @param request HTTP 请求对象
+     * @param next 下一个拦截器处理器
+     * @returns Observable<HttpEvent<T>>
+     */
     intercept(request, next) {
+        // 只处理 responseType 为 blob 的请求
         if (request.responseType !== 'blob') {
             return next.handle(request);
         }
-        return next.handle(request).pipe(switchMap((response) => this.handleBlobResponse(response)), catchError((response) => this.handleBlobError(response)));
+        return next.handle(request).pipe(switchMap((event) => this.handleBlobResponse(event)), catchError((error) => this.handleBlobError(error)));
     }
-    handleBlobResponse(response) {
-        if (response.type !== HttpEventType.Response) {
+    /**
+     * 处理 Blob 响应事件
+     * @param event HTTP 事件
+     * @returns Observable<HttpEvent<any>>
+     */
+    handleBlobResponse(event) {
+        var _a;
+        // 只处理完整的响应事件
+        if (event.type !== HttpEventType.Response) {
             return new Observable((subscriber) => {
-                subscriber.next(response);
+                subscriber.next(event);
                 subscriber.complete();
             });
         }
-        if (response instanceof HttpResponse && response.body && response.body.type === 'application/json') {
-            return new Observable((subscriber) => this.blobToJson(response.body, subscriber));
+        // 检查响应体是否为 JSON 类型（通常表示错误）
+        if (event instanceof HttpResponse && ((_a = event.body) === null || _a === void 0 ? void 0 : _a.type) === 'application/json') {
+            return this.convertBlobToJson(event.body);
         }
         return new Observable((subscriber) => {
-            subscriber.next(response);
+            subscriber.next(event);
             subscriber.complete();
         });
     }
-    handleBlobError(response) {
-        if (response.error && response.error.type === 'application/json') {
-            return new Observable((subscriber) => this.blobToJson(response.error, subscriber));
+    /**
+     * 处理 Blob 错误响应
+     * @param error HTTP 错误响应
+     * @returns Observable<HttpEvent<any>>
+     */
+    handleBlobError(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 Observable((subscriber) => {
-            subscriber.error(response);
+            subscriber.error(error);
             subscriber.complete();
         });
     }
-    blobToJson(blob, subscriber) {
-        const reader = new FileReader();
-        reader.addEventListener('loadend', () => {
-            try {
-                const json = JSON.parse(reader.result);
-                subscriber.error(json);
-            }
-            catch (error) {
-                subscriber.error(error);
-            }
-            finally {
+    /**
+     * 将 Blob 转换为 JSON 对象并抛出错误
+     * @param blob Blob 对象
+     * @returns Observable<HttpEvent<T>>
+     */
+    convertBlobToJson(blob) {
+        return new Observable((subscriber) => {
+            const reader = new FileReader();
+            reader.addEventListener('loadend', () => {
+                try {
+                    const json = JSON.parse(reader.result);
+                    subscriber.error(json);
+                }
+                catch (parseError) {
+                    subscriber.error(parseError);
+                }
+                finally {
+                    subscriber.complete();
+                }
+            });
+            reader.addEventListener('error', () => {
+                subscriber.error(new Error('读取 Blob 数据失败'));
                 subscriber.complete();
-            }
+            });
+            reader.readAsText(blob, 'utf-8');
         });
-        reader.readAsText(blob, 'utf-8');
     }
 }
 BlobInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BlobInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -57,10 +94,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             type: Injectable
         }] });
 /**
- * 下载文件拦截器
- * blob类型的请求会被处理
+ * 提供 Blob 响应拦截器
+ * @returns Provider 配置对象
+ * @example
+ * providers: [providerDownBlob()]
  */
 export function providerDownBlob() {
     return { provide: HTTP_INTERCEPTORS, useClass: BlobInterceptor, multi: true };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blob.interceptor.js","sourceRoot":"","sources":["../../../../library/core/interceptors/blob.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n    HttpRequest,\r\n    HttpHandler,\r\n    HttpEvent,\r\n    HttpInterceptor,\r\n    HttpEventType,\r\n    HttpResponse,\r\n    HttpErrorResponse,\r\n    HTTP_INTERCEPTORS,\r\n} from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { switchMap, catchError } from 'rxjs/operators';\r\n\r\n/**\r\n * Blob 响应拦截器\r\n * 处理文件下载请求中的 JSON 错误响应\r\n */\r\n@Injectable()\r\nexport class BlobInterceptor implements HttpInterceptor {\r\n    /**\r\n     * 拦截 HTTP 请求，处理 Blob 类型响应\r\n     * @param request HTTP 请求对象\r\n     * @param next 下一个拦截器处理器\r\n     * @returns Observable<HttpEvent<T>>\r\n     */\r\n    intercept<T>(request: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>> {\r\n        // 只处理 responseType 为 blob 的请求\r\n        if (request.responseType !== 'blob') {\r\n            return next.handle(request);\r\n        }\r\n\r\n        return next.handle(request).pipe(\r\n            switchMap((event: HttpEvent<any>) => this.handleBlobResponse(event)),\r\n            catchError((error: HttpErrorResponse) => this.handleBlobError(error)),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 处理 Blob 响应事件\r\n     * @param event HTTP 事件\r\n     * @returns Observable<HttpEvent<any>>\r\n     */\r\n    private handleBlobResponse(event: HttpEvent<any>): Observable<HttpEvent<any>> {\r\n        // 只处理完整的响应事件\r\n        if (event.type !== HttpEventType.Response) {\r\n            return new Observable((subscriber) => {\r\n                subscriber.next(event);\r\n                subscriber.complete();\r\n            });\r\n        }\r\n\r\n        // 检查响应体是否为 JSON 类型（通常表示错误）\r\n        if (event instanceof HttpResponse && event.body?.type === 'application/json') {\r\n            return this.convertBlobToJson(event.body);\r\n        }\r\n\r\n        return new Observable((subscriber) => {\r\n            subscriber.next(event);\r\n            subscriber.complete();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * 处理 Blob 错误响应\r\n     * @param error HTTP 错误响应\r\n     * @returns Observable<HttpEvent<any>>\r\n     */\r\n    private handleBlobError(error: HttpErrorResponse): Observable<HttpEvent<any>> {\r\n        // 如果错误响应体是 JSON 类型的 Blob，转换为 JSON 对象\r\n        if (error.error?.type === 'application/json') {\r\n            return this.convertBlobToJson(error.error);\r\n        }\r\n\r\n        return new Observable((subscriber) => {\r\n            subscriber.error(error);\r\n            subscriber.complete();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * 将 Blob 转换为 JSON 对象并抛出错误\r\n     * @param blob Blob 对象\r\n     * @returns Observable<HttpEvent<T>>\r\n     */\r\n    private convertBlobToJson<T>(blob: Blob): Observable<HttpEvent<T>> {\r\n        return new Observable((subscriber) => {\r\n            const reader = new FileReader();\r\n            \r\n            reader.addEventListener('loadend', () => {\r\n                try {\r\n                    const json: T = JSON.parse(reader.result as string);\r\n                    subscriber.error(json);\r\n                } catch (parseError) {\r\n                    subscriber.error(parseError);\r\n                } finally {\r\n                    subscriber.complete();\r\n                }\r\n            });\r\n\r\n            reader.addEventListener('error', () => {\r\n                subscriber.error(new Error('读取 Blob 数据失败'));\r\n                subscriber.complete();\r\n            });\r\n\r\n            reader.readAsText(blob, 'utf-8');\r\n        });\r\n    }\r\n}\r\n\r\n/**\r\n * 提供 Blob 响应拦截器\r\n * @returns Provider 配置对象\r\n * @example\r\n * providers: [providerDownBlob()]\r\n */\r\nexport function providerDownBlob() {\r\n    return { provide: HTTP_INTERCEPTORS, useClass: BlobInterceptor, multi: true };\r\n}\r\n"]}

package/esm2015/interceptors/cache.interceptor.js

@@ -1,24 +1,41 @@
 import { Injectable } from '@angular/core';
-import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { HTTP_INTERCEPTORS, HttpHeaders } from '@angular/common/http';
 import { shareReplay } from 'rxjs/operators';
 import * as i0 from "@angular/core";
 import * as i1 from "@reskin/core/services";
+/**
+ * 缓存策略标识
+ */
+const CACHE_HEADER = 'Cache-Map';
+const CACHE_STRATEGY = 'Storage';
+/**
+ * HTTP 缓存拦截器
+ * 为 GET 请求提供缓存功能，减少重复请求
+ */
 export class CacheInterceptor {
-    constructor(cacheHttp) {
-        this.cacheHttp = cacheHttp;
+    constructor(cacheHttpService) {
+        this.cacheHttpService = cacheHttpService;
     }
+    /**
+     * 拦截 HTTP 请求，实现缓存逻辑
+     * @param request HTTP 请求对象
+     * @param next 下一个拦截器处理器
+     * @returns Observable<HttpEvent<unknown>>
+     */
     intercept(request, next) {
-        // 1.判断是GET
-        // 2.header中添加 Cache-Map: Storage
-        const cacheMap = request.headers.get('Cache-Map');
-        if (request.method === 'GET' && cacheMap === 'Storage') {
-            let response = this.cacheHttp.get(request.url);
-            if (!response) {
-                response = next.handle(request).pipe(shareReplay(1));
-                this.cacheHttp.set(request.url, response);
+        // 只缓存 GET 请求且明确标记了缓存策略的请求
+        const cacheStrategy = request.headers.get(CACHE_HEADER);
+        if (request.method === 'GET' && cacheStrategy === CACHE_STRATEGY) {
+            // 尝试从缓存中获取响应
+            let cachedResponse = this.cacheHttpService.get(request.url);
+            if (!cachedResponse) {
+                // 缓存未命中，发起请求并缓存结果
+                cachedResponse = next.handle(request).pipe(shareReplay(1));
+                this.cacheHttpService.set(request.url, cachedResponse);
             }
-            return response;
+            return cachedResponse;
         }
+        // 非缓存请求，直接放行
         return next.handle(request);
     }
 }
@@ -28,9 +45,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.RkCacheHttpService }]; } });
 /**
- * GET请求缓存拦截器
+ * 提供 HTTP 缓存拦截器
+ * @returns Provider 配置对象
+ * @example
+ * providers: [providerHttpCache()]
  */
 export function providerHttpCache() {
     return { provide: HTTP_INTERCEPTORS, useClass: CacheInterceptor, multi: true };
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 创建带缓存标记的 GET 请求配置
+ * @param urls 模板字符串数组
+ * @param params 模板参数
+ * @returns [url, options] 元组
+ * @example
+ * this.http.get(...CacheHttpTemplate`/api/data`).subscribe();
+ */
+export function CacheHttpTemplate(urls, ...params) {
+    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];
+    return [url, { headers: new HttpHeaders({ [CACHE_HEADER]: CACHE_STRATEGY }) }];
+}
+//# sourceMappingURL=data:application/json;base64,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