@reskin/core 0.0.22 → 0.1.0

package/esm2015/interceptors/error.interceptor.js

@@ -1,25 +1,91 @@
 import { Injectable } from '@angular/core';
 import { HTTP_INTERCEPTORS } from '@angular/common/http';
-import { of } from 'rxjs';
+import { throwError } from 'rxjs';
 import { catchError } from 'rxjs/operators';
+import { Router } from '@angular/router';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
+/**
+ * 默认配置
+ */
+const DEFAULT_CONFIG = {
+    unauthorizedPath: '/errors/401',
+    enableLogging: false,
+};
+/**
+ * HTTP 错误拦截器
+ * 统一处理 HTTP 请求错误，包括 401 未授权错误的自动跳转
+ */
 export class ErrorInterceptor {
     constructor(router) {
         this.router = router;
+        this.config = DEFAULT_CONFIG;
+    }
+    /**
+     * 设置拦截器配置
+     * @param config 配置对象
+     */
+    setConfig(config) {
+        this.config = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
     }
+    /**
+     * 拦截 HTTP 请求，处理错误响应
+     * @param request HTTP 请求对象
+     * @param next 下一个拦截器处理器
+     * @returns Observable<HttpEvent<unknown>>
+     */
     intercept(request, next) {
-        return next.handle(request).pipe(catchError((result) => {
-            var _a;
-            if (result.status === 401) {
-                this.router.navigate(['/errors/401']).then();
+        return next.handle(request).pipe(catchError((error) => {
+            // 处理 401 未授权错误
+            if (error.status === 401) {
+                this.handleUnauthorizedError();
+                return throwError(error);
             }
-            if (result.error.code) {
-                return 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;
+            // 提取错误信息
+            const errorMessage = this.extractErrorMessage(error);
+            return throwError(new Error(errorMessage));
         }));
     }
+    /**
+     * 处理 401 未授权错误
+     */
+    handleUnauthorizedError() {
+        const path = this.config.unauthorizedPath || DEFAULT_CONFIG.unauthorizedPath;
+        this.router.navigate([path]).catch((err) => {
+            console.error('导航到错误页面失败:', err);
+        });
+    }
+    /**
+     * 提取错误信息
+     * @param error HTTP 错误响应
+     * @returns 错误信息字符串
+     */
+    extractErrorMessage(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}`;
+    }
 }
 ErrorInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ErrorInterceptor, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
 ErrorInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ErrorInterceptor });
@@ -27,9 +93,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.Router }]; } });
 /**
- * 请求错误拦截器
+ * 提供 HTTP 错误拦截器
+ * @param config 可选的配置对象
+ * @returns Provider 配置对象
+ * @example
+ * providers: [
+ *   providerHttpError({ unauthorizedPath: '/login', enableLogging: true })
+ * ]
  */
-export function providerHttpError() {
-    return { provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true };
+export function providerHttpError(config) {
+    if (config) {
+        // 如果有配置，使用 useFactory
+        return {
+            provide: HTTP_INTERCEPTORS,
+            useFactory: (router) => {
+                const interceptor = new ErrorInterceptor(router);
+                interceptor.setConfig(config);
+                return interceptor;
+            },
+            deps: [Router],
+            multi: true,
+        };
+    }
+    else {
+        // 没有配置，直接使用 useClass
+        return {
+            provide: HTTP_INTERCEPTORS,
+            useClass: ErrorInterceptor,
+            multi: true,
+        };
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error.interceptor.js","sourceRoot":"","sources":["../../../../library/core/interceptors/error.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HTTP_INTERCEPTORS, HttpErrorResponse } from '@angular/common/http';\r\nimport { Observable, throwError } from 'rxjs';\r\nimport { catchError } from 'rxjs/operators';\r\nimport { Router } from '@angular/router';\r\nimport { ErrorInterceptorConfig } from './types';\r\n\r\n/**\r\n * 默认配置\r\n */\r\nconst DEFAULT_CONFIG: ErrorInterceptorConfig = {\r\n    unauthorizedPath: '/errors/401',\r\n    enableLogging: false,\r\n};\r\n\r\n/**\r\n * HTTP 错误拦截器\r\n * 统一处理 HTTP 请求错误，包括 401 未授权错误的自动跳转\r\n */\r\n@Injectable()\r\nexport class ErrorInterceptor implements HttpInterceptor {\r\n    private config: ErrorInterceptorConfig = DEFAULT_CONFIG;\r\n\r\n    constructor(private router: Router) {}\r\n\r\n    /**\r\n     * 设置拦截器配置\r\n     * @param config 配置对象\r\n     */\r\n    setConfig(config: ErrorInterceptorConfig): void {\r\n        this.config = { ...DEFAULT_CONFIG, ...config };\r\n    }\r\n\r\n    /**\r\n     * 拦截 HTTP 请求，处理错误响应\r\n     * @param request HTTP 请求对象\r\n     * @param next 下一个拦截器处理器\r\n     * @returns Observable<HttpEvent<unknown>>\r\n     */\r\n    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {\r\n        return next.handle(request).pipe(\r\n            catchError((error: HttpErrorResponse) => {\r\n                // 处理 401 未授权错误\r\n                if (error.status === 401) {\r\n                    this.handleUnauthorizedError();\r\n                    return throwError(error);\r\n                }\r\n\r\n                // 记录错误日志\r\n                if (this.config.enableLogging) {\r\n                    console.error('[HTTP Error]', {\r\n                        url: request.url,\r\n                        method: request.method,\r\n                        status: error.status,\r\n                        message: error.message,\r\n                        error: error.error,\r\n                    });\r\n                }\r\n\r\n                // 提取错误信息\r\n                const errorMessage = this.extractErrorMessage(error);\r\n                return throwError(new Error(errorMessage));\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 处理 401 未授权错误\r\n     */\r\n    private handleUnauthorizedError(): void {\r\n        const path = this.config.unauthorizedPath || DEFAULT_CONFIG.unauthorizedPath;\r\n        this.router.navigate([path]).catch((err) => {\r\n            console.error('导航到错误页面失败:', err);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * 提取错误信息\r\n     * @param error HTTP 错误响应\r\n     * @returns 错误信息字符串\r\n     */\r\n    private extractErrorMessage(error: HttpErrorResponse): string {\r\n        if (error.error) {\r\n            // 尝试从 error.error 中提取信息\r\n            if (typeof error.error === 'string') {\r\n                return error.error;\r\n            }\r\n            if (error.error.msg) {\r\n                return error.error.msg;\r\n            }\r\n            if (error.error.message) {\r\n                return error.error.message;\r\n            }\r\n        }\r\n        // 使用默认错误信息\r\n        return error.message || `HTTP Error ${error.status}`;\r\n    }\r\n}\r\n\r\n/**\r\n * 提供 HTTP 错误拦截器\r\n * @param config 可选的配置对象\r\n * @returns Provider 配置对象\r\n * @example\r\n * providers: [\r\n *   providerHttpError({ unauthorizedPath: '/login', enableLogging: true })\r\n * ]\r\n */\r\nexport function providerHttpError(config?: ErrorInterceptorConfig) {\r\n    if (config) {\r\n        // 如果有配置，使用 useFactory\r\n        return {\r\n            provide: HTTP_INTERCEPTORS,\r\n            useFactory: (router: Router) => {\r\n                const interceptor = new ErrorInterceptor(router);\r\n                interceptor.setConfig(config);\r\n                return interceptor;\r\n            },\r\n            deps: [Router],\r\n            multi: true,\r\n        };\r\n    } else {\r\n        // 没有配置，直接使用 useClass\r\n        return {\r\n            provide: HTTP_INTERCEPTORS,\r\n            useClass: ErrorInterceptor,\r\n            multi: true,\r\n        };\r\n    }\r\n}\r\n"]}

package/esm2015/interceptors/public-api.js

@@ -1,5 +1,6 @@
+export * from './types';
 export * from './token.interceptor';
 export * from './error.interceptor';
 export * from './cache.interceptor';
 export * from './blob.interceptor';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnJhcnkvY29yZS9pbnRlcmNlcHRvcnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2tlbi5pbnRlcmNlcHRvcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3IuaW50ZXJjZXB0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2NhY2hlLmludGVyY2VwdG9yJztcclxuZXhwb3J0ICogZnJvbSAnLi9ibG9iLmludGVyY2VwdG9yJztcclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnJhcnkvY29yZS9pbnRlcmNlcHRvcnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW4uaW50ZXJjZXB0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2Vycm9yLmludGVyY2VwdG9yJztcclxuZXhwb3J0ICogZnJvbSAnLi9jYWNoZS5pbnRlcmNlcHRvcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vYmxvYi5pbnRlcmNlcHRvcic7XHJcbiJdfQ==

package/esm2015/interceptors/token.interceptor.js

@@ -2,39 +2,54 @@ import { Injectable } from '@angular/core';
 import { HTTP_INTERCEPTORS, HttpHeaders } from '@angular/common/http';
 import * as i0 from "@angular/core";
 import * as i1 from "@reskin/core/services";
-// 定义默认的 token header 名称
+/**
+ * Token 拦截器常量
+ */
 const DEFAULT_TOKEN_HEADER_NAME = 'Authorization';
 const TOKEN_CONTROL_HEADER = 'Token-Control';
 const CUSTOM_TOKEN_HEADER = 'Custom-Token';
 const CUSTOM_TOKEN_HEADER_NAME = 'Custom-Token-Header';
 const AUTH_ID_HEADER = 'X-Auth-Id';
+/**
+ * Token 拦截器
+ * 自动为 HTTP 请求添加认证 Token
+ */
 export class TokenInterceptor {
-    constructor(service) {
-        this.service = service;
+    constructor(authService) {
+        this.authService = authService;
     }
+    /**
+     * 拦截 HTTP 请求，添加 Token 认证信息
+     * @param request HTTP 请求对象
+     * @param next 下一个拦截器处理器
+     * @returns Observable<HttpEvent<unknown>>
+     */
     intercept(request, next) {
-        const tc = request.headers.get(TOKEN_CONTROL_HEADER);
-        // 检查是否提供了自定义token
+        const tokenControl = request.headers.get(TOKEN_CONTROL_HEADER);
+        // 如果明确指定不需要 Token，直接放行
+        if (tokenControl === 'no-token') {
+            return next.handle(request);
+        }
         const customToken = request.headers.get(CUSTOM_TOKEN_HEADER);
-        // 检查是否提供了自定义token header名称
         const customTokenHeaderName = request.headers.get(CUSTOM_TOKEN_HEADER_NAME) || DEFAULT_TOKEN_HEADER_NAME;
-        if (tc !== 'no-token') {
-            let headers = {};
-            if (customToken) {
-                // 使用自定义token
-                headers[customTokenHeaderName] = customToken;
-            }
-            else {
-                // 使用默认认证信息
-                const auth = this.service.token;
-                if (auth.token) {
-                    headers[DEFAULT_TOKEN_HEADER_NAME] = auth.token;
+        const headers = {};
+        if (customToken) {
+            // 使用自定义 Token
+            headers[customTokenHeaderName] = customToken;
+        }
+        else {
+            // 使用默认认证信息
+            const 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);
     }
@@ -45,59 +60,57 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.RkAuthService }]; } });
 /**
- * 请求头增加token验证拦截器
+ * 提供 Token 拦截器
+ * @returns Provider 配置对象
  */
 export function providerAuthToken() {
     return { provide: 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();
  */
 export function NoAuthTokenTemplate(urls, ...params) {
-    let [url] = urls;
-    if (params.length > 0) {
-        url = String.raw(urls, ...params);
-    }
-    return [url, { headers: new HttpHeaders({ 'Token-Control': 'no-token' }) }];
+    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];
+    return [url, { headers: new HttpHeaders({ [TOKEN_CONTROL_HEADER]: 'no-token' }) }];
 }
 /**
- * 使用自定义token的请求
- * @param token 自定义token值
- * @param urls 地址
- * @param params 参数
- * @constructor
+ * 创建使用自定义 Token 的请求配置
+ * @param token 自定义 Token 值
+ * @param urls 模板字符串数组
+ * @param params 模板参数
+ * @returns [url, options] 元组
+ * @example
+ * this.http.get(...CustomTokenTemplate('my-token', `/api/data`)).subscribe();
  */
 export function CustomTokenTemplate(token, urls, ...params) {
-    let [url] = urls;
-    if (params.length > 0) {
-        url = String.raw(urls, ...params);
-    }
-    return [url, { headers: new HttpHeaders({ 'Custom-Token': token }) }];
+    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];
+    return [url, { headers: new HttpHeaders({ [CUSTOM_TOKEN_HEADER]: token }) }];
 }
 /**
- * 使用自定义token和自定义header名称的请求
- * @param token 自定义token值
- * @param headerName 自定义header名称
- * @param urls 地址
- * @param params 参数
- * @constructor
+ * 创建使用自定义 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();
  */
 export function CustomTokenWithHeaderTemplate(token, headerName, urls, ...params) {
-    let [url] = urls;
-    if (params.length > 0) {
-        url = String.raw(urls, ...params);
-    }
+    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];
     return [
         url,
         {
             headers: new HttpHeaders({
-                'Custom-Token': token,
-                'Custom-Token-Header': headerName,
+                [CUSTOM_TOKEN_HEADER]: token,
+                [CUSTOM_TOKEN_HEADER_NAME]: headerName,
             }),
         },
     ];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.interceptor.js","sourceRoot":"","sources":["../../../../library/core/interceptors/token.interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAwD,iBAAiB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;;;AAK5H,wBAAwB;AACxB,MAAM,yBAAyB,GAAG,eAAe,CAAC;AAClD,MAAM,oBAAoB,GAAG,eAAe,CAAC;AAC7C,MAAM,mBAAmB,GAAG,cAAc,CAAC;AAC3C,MAAM,wBAAwB,GAAG,qBAAqB,CAAC;AACvD,MAAM,cAAc,GAAG,WAAW,CAAC;AAGnC,MAAM,OAAO,gBAAgB;IACzB,YAAoB,OAAsB;QAAtB,YAAO,GAAP,OAAO,CAAe;IAAG,CAAC;IAE9C,SAAS,CAAC,OAA6B,EAAE,IAAiB;QACtD,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QACrD,kBAAkB;QAClB,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QAC7D,2BAA2B;QAC3B,MAAM,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,IAAI,yBAAyB,CAAC;QAEzG,IAAI,EAAE,KAAK,UAAU,EAAE;YACnB,IAAI,OAAO,GAA0C,EAAE,CAAC;YAExD,IAAI,WAAW,EAAE;gBACb,aAAa;gBACb,OAAO,CAAC,qBAAqB,CAAC,GAAG,WAAW,CAAC;aAChD;iBAAM;gBACH,WAAW;gBACX,MAAM,IAAI,GAAU,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;gBACvC,IAAI,IAAI,CAAC,KAAK,EAAE;oBACZ,OAAO,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;oBAChD,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;iBACrC;aACJ;YAED,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;gBACjC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;aACpD;SACJ;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;;8GA9BQ,gBAAgB;kHAAhB,gBAAgB;4FAAhB,gBAAgB;kBAD5B,UAAU;;AAkCX;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAC7B,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACnF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAA0B,EAAE,GAAG,MAAa;IAC5E,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACjB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;QACnB,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC;KACrC;IACD,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,IAAI,WAAW,CAAC,EAAE,eAAe,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa,EAAE,IAA0B,EAAE,GAAG,MAAa;IAC3F,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACjB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;QACnB,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC;KACrC;IACD,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,IAAI,WAAW,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,6BAA6B,CACzC,KAAa,EACb,UAAkB,EAClB,IAA0B,EAC1B,GAAG,MAAa;IAEhB,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACjB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;QACnB,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC;KACrC;IACD,OAAO;QACH,GAAG;QACH;YACI,OAAO,EAAE,IAAI,WAAW,CAAC;gBACrB,cAAc,EAAE,KAAK;gBACrB,qBAAqB,EAAE,UAAU;aACpC,CAAC;SACL;KACJ,CAAC;AACN,CAAC","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HTTP_INTERCEPTORS, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { RkAuthService } from '@reskin/core/services';\r\nimport { IAuth } from '@reskin/core/entity/user';\r\n\r\n// 定义默认的 token header 名称\r\nconst DEFAULT_TOKEN_HEADER_NAME = 'Authorization';\r\nconst TOKEN_CONTROL_HEADER = 'Token-Control';\r\nconst CUSTOM_TOKEN_HEADER = 'Custom-Token';\r\nconst CUSTOM_TOKEN_HEADER_NAME = 'Custom-Token-Header';\r\nconst AUTH_ID_HEADER = 'X-Auth-Id';\r\n\r\n@Injectable()\r\nexport class TokenInterceptor implements HttpInterceptor {\r\n    constructor(private service: RkAuthService) {}\r\n\r\n    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {\r\n        const tc = request.headers.get(TOKEN_CONTROL_HEADER);\r\n        // 检查是否提供了自定义token\r\n        const customToken = request.headers.get(CUSTOM_TOKEN_HEADER);\r\n        // 检查是否提供了自定义token header名称\r\n        const customTokenHeaderName = request.headers.get(CUSTOM_TOKEN_HEADER_NAME) || DEFAULT_TOKEN_HEADER_NAME;\r\n\r\n        if (tc !== 'no-token') {\r\n            let headers: { [name: string]: string | string[] } = {};\r\n\r\n            if (customToken) {\r\n                // 使用自定义token\r\n                headers[customTokenHeaderName] = customToken;\r\n            } else {\r\n                // 使用默认认证信息\r\n                const auth: IAuth = this.service.token;\r\n                if (auth.token) {\r\n                    headers[DEFAULT_TOKEN_HEADER_NAME] = auth.token;\r\n                    headers[AUTH_ID_HEADER] = auth.id;\r\n                }\r\n            }\r\n\r\n            if (Object.keys(headers).length > 0) {\r\n                request = request.clone({ setHeaders: headers });\r\n            }\r\n        }\r\n        return next.handle(request);\r\n    }\r\n}\r\n\r\n/**\r\n * 请求头增加token验证拦截器\r\n */\r\nexport function providerAuthToken() {\r\n    return { provide: HTTP_INTERCEPTORS, useClass: TokenInterceptor, multi: true };\r\n}\r\n\r\n/**\r\n * 不带token验证信息请求\r\n * @param urls 地址\r\n * @param params 参数\r\n * @constructor\r\n */\r\nexport function NoAuthTokenTemplate(urls: TemplateStringsArray, ...params: any[]): [string, { headers: HttpHeaders }] {\r\n    let [url] = urls;\r\n    if (params.length > 0) {\r\n        url = String.raw(urls, ...params);\r\n    }\r\n    return [url, { headers: new HttpHeaders({ 'Token-Control': 'no-token' }) }];\r\n}\r\n\r\n/**\r\n * 使用自定义token的请求\r\n * @param token 自定义token值\r\n * @param urls 地址\r\n * @param params 参数\r\n * @constructor\r\n */\r\nexport function CustomTokenTemplate(token: string, urls: TemplateStringsArray, ...params: any[]): [string, { headers: HttpHeaders }] {\r\n    let [url] = urls;\r\n    if (params.length > 0) {\r\n        url = String.raw(urls, ...params);\r\n    }\r\n    return [url, { headers: new HttpHeaders({ 'Custom-Token': token }) }];\r\n}\r\n\r\n/**\r\n * 使用自定义token和自定义header名称的请求\r\n * @param token 自定义token值\r\n * @param headerName 自定义header名称\r\n * @param urls 地址\r\n * @param params 参数\r\n * @constructor\r\n */\r\nexport function CustomTokenWithHeaderTemplate(\r\n    token: string,\r\n    headerName: string,\r\n    urls: TemplateStringsArray,\r\n    ...params: any[]\r\n): [string, { headers: HttpHeaders }] {\r\n    let [url] = urls;\r\n    if (params.length > 0) {\r\n        url = String.raw(urls, ...params);\r\n    }\r\n    return [\r\n        url,\r\n        {\r\n            headers: new HttpHeaders({\r\n                'Custom-Token': token,\r\n                'Custom-Token-Header': headerName,\r\n            }),\r\n        },\r\n    ];\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.interceptor.js","sourceRoot":"","sources":["../../../../library/core/interceptors/token.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HTTP_INTERCEPTORS, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { RkAuthService } from '@reskin/core/services';\r\nimport { IAuth } from '@reskin/core/entity/user';\r\n\r\n/**\r\n * Token 拦截器常量\r\n */\r\nconst DEFAULT_TOKEN_HEADER_NAME = 'Authorization';\r\nconst TOKEN_CONTROL_HEADER = 'Token-Control';\r\nconst CUSTOM_TOKEN_HEADER = 'Custom-Token';\r\nconst CUSTOM_TOKEN_HEADER_NAME = 'Custom-Token-Header';\r\nconst AUTH_ID_HEADER = 'X-Auth-Id';\r\n\r\n/**\r\n * Token 拦截器\r\n * 自动为 HTTP 请求添加认证 Token\r\n */\r\n@Injectable()\r\nexport class TokenInterceptor implements HttpInterceptor {\r\n    constructor(private authService: RkAuthService) {}\r\n\r\n    /**\r\n     * 拦截 HTTP 请求，添加 Token 认证信息\r\n     * @param request HTTP 请求对象\r\n     * @param next 下一个拦截器处理器\r\n     * @returns Observable<HttpEvent<unknown>>\r\n     */\r\n    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {\r\n        const tokenControl = request.headers.get(TOKEN_CONTROL_HEADER);\r\n        \r\n        // 如果明确指定不需要 Token，直接放行\r\n        if (tokenControl === 'no-token') {\r\n            return next.handle(request);\r\n        }\r\n\r\n        const customToken = request.headers.get(CUSTOM_TOKEN_HEADER);\r\n        const customTokenHeaderName = request.headers.get(CUSTOM_TOKEN_HEADER_NAME) || DEFAULT_TOKEN_HEADER_NAME;\r\n\r\n        const headers: { [name: string]: string | string[] } = {};\r\n\r\n        if (customToken) {\r\n            // 使用自定义 Token\r\n            headers[customTokenHeaderName] = customToken;\r\n        } else {\r\n            // 使用默认认证信息\r\n            const auth: IAuth = this.authService.token;\r\n            if (auth?.token) {\r\n                headers[DEFAULT_TOKEN_HEADER_NAME] = auth.token;\r\n                if (auth.id) {\r\n                    headers[AUTH_ID_HEADER] = auth.id;\r\n                }\r\n            }\r\n        }\r\n\r\n        // 如果有需要添加的 Header，克隆请求并添加\r\n        if (Object.keys(headers).length > 0) {\r\n            request = request.clone({ setHeaders: headers });\r\n        }\r\n\r\n        return next.handle(request);\r\n    }\r\n}\r\n\r\n/**\r\n * 提供 Token 拦截器\r\n * @returns Provider 配置对象\r\n */\r\nexport function providerAuthToken() {\r\n    return { provide: HTTP_INTERCEPTORS, useClass: TokenInterceptor, multi: true };\r\n}\r\n\r\n/**\r\n * 创建不带 Token 的请求配置\r\n * @param urls 模板字符串数组\r\n * @param params 模板参数\r\n * @returns [url, options] 元组\r\n * @example\r\n * this.http.get(...NoAuthTokenTemplate`/api/public/data`).subscribe();\r\n */\r\nexport function NoAuthTokenTemplate(urls: TemplateStringsArray, ...params: any[]): [string, { headers: HttpHeaders }] {\r\n    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];\r\n    return [url, { headers: new HttpHeaders({ [TOKEN_CONTROL_HEADER]: 'no-token' }) }];\r\n}\r\n\r\n/**\r\n * 创建使用自定义 Token 的请求配置\r\n * @param token 自定义 Token 值\r\n * @param urls 模板字符串数组\r\n * @param params 模板参数\r\n * @returns [url, options] 元组\r\n * @example\r\n * this.http.get(...CustomTokenTemplate('my-token', `/api/data`)).subscribe();\r\n */\r\nexport function CustomTokenTemplate(token: string, urls: TemplateStringsArray, ...params: any[]): [string, { headers: HttpHeaders }] {\r\n    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];\r\n    return [url, { headers: new HttpHeaders({ [CUSTOM_TOKEN_HEADER]: token }) }];\r\n}\r\n\r\n/**\r\n * 创建使用自定义 Token 和自定义 Header 名称的请求配置\r\n * @param token 自定义 Token 值\r\n * @param headerName 自定义 Header 名称\r\n * @param urls 模板字符串数组\r\n * @param params 模板参数\r\n * @returns [url, options] 元组\r\n * @example\r\n * this.http.get(...CustomTokenWithHeaderTemplate('my-token', 'X-API-Key', `/api/data`)).subscribe();\r\n */\r\nexport function CustomTokenWithHeaderTemplate(\r\n    token: string,\r\n    headerName: string,\r\n    urls: TemplateStringsArray,\r\n    ...params: any[]\r\n): [string, { headers: HttpHeaders }] {\r\n    const url = params.length > 0 ? String.raw(urls, ...params) : urls[0];\r\n    return [\r\n        url,\r\n        {\r\n            headers: new HttpHeaders({\r\n                [CUSTOM_TOKEN_HEADER]: token,\r\n                [CUSTOM_TOKEN_HEADER_NAME]: headerName,\r\n            }),\r\n        },\r\n    ];\r\n}\r\n"]}

package/esm2015/interceptors/types.js

@@ -0,0 +1,5 @@
+/**
+ * HTTP 拦截器相关类型定义
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/array.js

@@ -1,40 +1,60 @@
 /**
  * 深克隆一个对象或数组
  *
- * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响
+ * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响。
+ * 支持克隆：普通对象、数组、Date、Map、Set、RegExp 等类型。
  *
  * @param source 需要克隆的源对象或数组
  * @returns 返回克隆后的对象或数组
+ *
+ * @example
+ * const obj = { a: 1, b: { c: 2 } };
+ * const cloned = deepClone(obj);
+ * cloned.b.c = 3;
+ * console.log(obj.b.c); // 输出: 2
  */
 export function deepClone(source) {
-    // 如果源对象为null或不是对象类型，则直接返回源对象
+    // 处理 null 和基本类型
     if (source === null || typeof source !== 'object') {
         return source;
     }
-    // 如果源对象是数组，则创建一个新数组并递归克隆每个元素
+    // 处理 Date 对象
+    if (source instanceof Date) {
+        return new Date(source.getTime());
+    }
+    // 处理 RegExp 对象
+    if (source instanceof RegExp) {
+        return new RegExp(source.source, source.flags);
+    }
+    // 处理 Map 对象
+    if (source instanceof Map) {
+        const clonedMap = new Map();
+        source.forEach((value, key) => {
+            clonedMap.set(deepClone(key), deepClone(value));
+        });
+        return clonedMap;
+    }
+    // 处理 Set 对象
+    if (source instanceof Set) {
+        const clonedSet = new Set();
+        source.forEach((value) => {
+            clonedSet.add(deepClone(value));
+        });
+        return clonedSet;
+    }
+    // 处理数组
     if (Array.isArray(source)) {
-        const clonedArray = [];
-        for (let i = 0; i < source.length; i++) {
-            clonedArray[i] = deepClone(source[i]);
-        }
-        // 忽略类型检查器的警告，确保能够返回泛型T类型的数组
-        // @ts-ignore
-        return clonedArray;
+        return source.map((item) => deepClone(item));
     }
-    // 如果源对象是普通对象，则创建一个新的空对象并递归克隆每个属性
-    if (typeof source === 'object') {
+    // 处理普通对象
+    if (Object.prototype.toString.call(source) === '[object Object]') {
         const clonedObject = {};
-        for (const key in source) {
-            // 确保只处理对象自身的属性，避免原型链上的属性被克隆
-            // @ts-ignore
-            if (source.hasOwnProperty(key)) {
-                clonedObject[key] = deepClone(source[key]);
-            }
-        }
-        // 忽略类型检查器的警告，确保能够返回泛型T类型的对象
+        Object.keys(source).forEach((key) => {
+            clonedObject[key] = deepClone(source[key]);
+        });
         return clonedObject;
     }
-    // 如果源对象是其他非对象类型，则直接返回源对象
+    // 其他类型直接返回（如函数、Symbol 等）
     return source;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJyYXJ5L2NvcmUvdXRpbHMvYXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCxNQUFNLFVBQVUsU0FBUyxDQUFJLE1BQVM7SUFDbEMsZ0JBQWdCO0lBQ2hCLElBQUksTUFBTSxLQUFLLElBQUksSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRLEVBQUU7UUFDL0MsT0FBTyxNQUFNLENBQUM7S0FDakI7SUFFRCxhQUFhO0lBQ2IsSUFBSSxNQUFNLFlBQVksSUFBSSxFQUFFO1FBQ3hCLE9BQU8sSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFpQixDQUFDO0tBQ3JEO0lBRUQsZUFBZTtJQUNmLElBQUksTUFBTSxZQUFZLE1BQU0sRUFBRTtRQUMxQixPQUFPLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBaUIsQ0FBQztLQUNsRTtJQUVELFlBQVk7SUFDWixJQUFJLE1BQU0sWUFBWSxHQUFHLEVBQUU7UUFDdkIsTUFBTSxTQUFTLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQztRQUM1QixNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFO1lBQzFCLFNBQVMsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ3BELENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxTQUF5QixDQUFDO0tBQ3BDO0lBRUQsWUFBWTtJQUNaLElBQUksTUFBTSxZQUFZLEdBQUcsRUFBRTtRQUN2QixNQUFNLFNBQVMsR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBQzVCLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtZQUNyQixTQUFTLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ3BDLENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxTQUF5QixDQUFDO0tBQ3BDO0lBRUQsT0FBTztJQUNQLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRTtRQUN2QixPQUFPLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBaUIsQ0FBQztLQUNoRTtJQUVELFNBQVM7SUFDVCxJQUFJLE1BQU0sQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxpQkFBaUIsRUFBRTtRQUM5RCxNQUFNLFlBQVksR0FBRyxFQUFPLENBQUM7UUFDN0IsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUMvQixZQUFvQixDQUFDLEdBQUcsQ0FBQyxHQUFHLFNBQVMsQ0FBRSxNQUFjLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUNqRSxDQUFDLENBQUMsQ0FBQztRQUNILE9BQU8sWUFBWSxDQUFDO0tBQ3ZCO0lBRUQseUJBQXlCO0lBQ3pCLE9BQU8sTUFBTSxDQUFDO0FBQ2xCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICog5rex5YWL6ZqG5LiA5Liq5a+56LGh5oiW5pWw57uEXHJcbiAqXHJcbiAqIOivpeWHveaVsOmAmui/h+mAkuW9kuaWueW8j+a3seWFi+mahui+k+WFpeeahOWvueixoeaIluaVsOe7hO+8jOehruS/neS4juWOn+WvueixoeaIluaVsOe7hOmalOemu++8jOS4jeS8muebuOS6kuW9seWTjeOAglxyXG4gKiDmlK/mjIHlhYvpmobvvJrmma7pgJrlr7nosaHjgIHmlbDnu4TjgIFEYXRl44CBTWFw44CBU2V044CBUmVnRXhwIOetieexu+Wei+OAglxyXG4gKlxyXG4gKiBAcGFyYW0gc291cmNlIOmcgOimgeWFi+mahueahOa6kOWvueixoeaIluaVsOe7hFxyXG4gKiBAcmV0dXJucyDov5Tlm57lhYvpmoblkI7nmoTlr7nosaHmiJbmlbDnu4RcclxuICpcclxuICogQGV4YW1wbGVcclxuICogY29uc3Qgb2JqID0geyBhOiAxLCBiOiB7IGM6IDIgfSB9O1xyXG4gKiBjb25zdCBjbG9uZWQgPSBkZWVwQ2xvbmUob2JqKTtcclxuICogY2xvbmVkLmIuYyA9IDM7XHJcbiAqIGNvbnNvbGUubG9nKG9iai5iLmMpOyAvLyDovpPlh7o6IDJcclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBkZWVwQ2xvbmU8VD4oc291cmNlOiBUKTogVCB7XHJcbiAgICAvLyDlpITnkIYgbnVsbCDlkozln7rmnKznsbvlnotcclxuICAgIGlmIChzb3VyY2UgPT09IG51bGwgfHwgdHlwZW9mIHNvdXJjZSAhPT0gJ29iamVjdCcpIHtcclxuICAgICAgICByZXR1cm4gc291cmNlO1xyXG4gICAgfVxyXG5cclxuICAgIC8vIOWkhOeQhiBEYXRlIOWvueixoVxyXG4gICAgaWYgKHNvdXJjZSBpbnN0YW5jZW9mIERhdGUpIHtcclxuICAgICAgICByZXR1cm4gbmV3IERhdGUoc291cmNlLmdldFRpbWUoKSkgYXMgdW5rbm93biBhcyBUO1xyXG4gICAgfVxyXG5cclxuICAgIC8vIOWkhOeQhiBSZWdFeHAg5a+56LGhXHJcbiAgICBpZiAoc291cmNlIGluc3RhbmNlb2YgUmVnRXhwKSB7XHJcbiAgICAgICAgcmV0dXJuIG5ldyBSZWdFeHAoc291cmNlLnNvdXJjZSwgc291cmNlLmZsYWdzKSBhcyB1bmtub3duIGFzIFQ7XHJcbiAgICB9XHJcblxyXG4gICAgLy8g5aSE55CGIE1hcCDlr7nosaFcclxuICAgIGlmIChzb3VyY2UgaW5zdGFuY2VvZiBNYXApIHtcclxuICAgICAgICBjb25zdCBjbG9uZWRNYXAgPSBuZXcgTWFwKCk7XHJcbiAgICAgICAgc291cmNlLmZvckVhY2goKHZhbHVlLCBrZXkpID0+IHtcclxuICAgICAgICAgICAgY2xvbmVkTWFwLnNldChkZWVwQ2xvbmUoa2V5KSwgZGVlcENsb25lKHZhbHVlKSk7XHJcbiAgICAgICAgfSk7XHJcbiAgICAgICAgcmV0dXJuIGNsb25lZE1hcCBhcyB1bmtub3duIGFzIFQ7XHJcbiAgICB9XHJcblxyXG4gICAgLy8g5aSE55CGIFNldCDlr7nosaFcclxuICAgIGlmIChzb3VyY2UgaW5zdGFuY2VvZiBTZXQpIHtcclxuICAgICAgICBjb25zdCBjbG9uZWRTZXQgPSBuZXcgU2V0KCk7XHJcbiAgICAgICAgc291cmNlLmZvckVhY2goKHZhbHVlKSA9PiB7XHJcbiAgICAgICAgICAgIGNsb25lZFNldC5hZGQoZGVlcENsb25lKHZhbHVlKSk7XHJcbiAgICAgICAgfSk7XHJcbiAgICAgICAgcmV0dXJuIGNsb25lZFNldCBhcyB1bmtub3duIGFzIFQ7XHJcbiAgICB9XHJcblxyXG4gICAgLy8g5aSE55CG5pWw57uEXHJcbiAgICBpZiAoQXJyYXkuaXNBcnJheShzb3VyY2UpKSB7XHJcbiAgICAgICAgcmV0dXJuIHNvdXJjZS5tYXAoKGl0ZW0pID0+IGRlZXBDbG9uZShpdGVtKSkgYXMgdW5rbm93biBhcyBUO1xyXG4gICAgfVxyXG5cclxuICAgIC8vIOWkhOeQhuaZrumAmuWvueixoVxyXG4gICAgaWYgKE9iamVjdC5wcm90b3R5cGUudG9TdHJpbmcuY2FsbChzb3VyY2UpID09PSAnW29iamVjdCBPYmplY3RdJykge1xyXG4gICAgICAgIGNvbnN0IGNsb25lZE9iamVjdCA9IHt9IGFzIFQ7XHJcbiAgICAgICAgT2JqZWN0LmtleXMoc291cmNlKS5mb3JFYWNoKChrZXkpID0+IHtcclxuICAgICAgICAgICAgKGNsb25lZE9iamVjdCBhcyBhbnkpW2tleV0gPSBkZWVwQ2xvbmUoKHNvdXJjZSBhcyBhbnkpW2tleV0pO1xyXG4gICAgICAgIH0pO1xyXG4gICAgICAgIHJldHVybiBjbG9uZWRPYmplY3Q7XHJcbiAgICB9XHJcblxyXG4gICAgLy8g5YW25LuW57G75Z6L55u05o6l6L+U5Zue77yI5aaC5Ye95pWw44CBU3ltYm9sIOetie+8iVxyXG4gICAgcmV0dXJuIHNvdXJjZTtcclxufVxyXG4iXX0=

package/esm2015/utils/dom.js

@@ -1,28 +1,46 @@
 import { Observable } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
 /**
  * 监听元素的大小变化
  *
- * 此函数创建了一个Observable，用于观察给定HTMLElement元素的大小变化它使用了ResizeObserver API来实现
- * 当元素的大小发生变化时，会发出一个包含变化记录的数组
+ * 此函数创建了一个 Observable，用于观察给定 HTMLElement 元素的大小变化。
+ * 它使用了 ResizeObserver API 来实现，当元素的大小发生变化时，会发出一个包含变化记录的数组。
  *
- * @param element 需要观察大小变化的HTMLElement元素
- * @returns 返回一个Observable，其中包含ResizeObserverEntry的数组，用于记录每次大小变化的信息
+ * @param element 需要观察大小变化的 HTMLElement 元素
+ * @param options 配置选项
+ * @returns 返回一个 Observable，其中包含 ResizeObserverEntry 的数组，用于记录每次大小变化的信息
+ *
+ * @example
+ * // 基础用法
+ * const element = document.querySelector('.container');
+ * observeResize(element).subscribe(entries => {
+ *   const { width, height } = entries[0].contentRect;
+ *   console.log(`元素尺寸: ${width}x${height}`);
+ * });
+ *
+ * @example
+ * // 使用防抖优化性能
+ * observeResize(element, { debounce: 300 }).subscribe(entries => {
+ *   // 300ms 内的多次变化只会触发一次
+ *   console.log('元素大小已稳定');
+ * });
  */
-export function observeResize(element) {
-    return new Observable((observer) => {
-        // 创建ResizeObserver实例，当观察的目标元素大小发生变化时，会调用回调函数
+export function observeResize(element, options) {
+    const { debounce } = options || {};
+    const resize$ = new Observable((observer) => {
+        // 创建 ResizeObserver 实例，当观察的目标元素大小发生变化时，会调用回调函数
         const resizeObserver = new ResizeObserver((entries) => {
             observer.next(entries);
         });
         // 开始观察指定的元素
         resizeObserver.observe(element);
-        // 返回一个函数，用于在停止观察时调用，以清理资源
+        // 返回清理函数，用于在取消订阅时调用
         return () => {
-            // 停止观察指定的元素
             resizeObserver.unobserve(element);
-            // 断开与所有目标的观察连接
             resizeObserver.disconnect();
         };
     });
+    // 如果设置了防抖，则应用防抖操作符
+    return debounce ? resize$.pipe(debounceTime(debounce)) : resize$;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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