@reskin/core 0.0.21 → 0.1.0

package/fesm2015/reskin-core-utils.js

@@ -1,4 +1,5 @@
 import { Observable } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
 
 /**
  * 默认前缀
@@ -8,159 +9,302 @@ let prefix = 'SK_';
  * 设置存储前缀
  *
  * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。
- * 存储前缀的更改可能会影响已存储的数据被正确识别和访问。
+ * 注意：更改前缀后，之前使用旧前缀存储的数据将无法访问。
  *
  * @param newPrefix 新的存储前缀字符串
+ *
+ * @example
+ * setStorePrefix('MY_APP_');
  */
 function setStorePrefix(newPrefix) {
     prefix = newPrefix;
 }
 /**
- * 提供了一个用于缓存值的类，值可以被存储在浏览器的localStorage或sessionStorage中。
- * 如果提供了过期时间，存储的值会在过期后自动移除。
+ * 提供了一个用于缓存值的类，值可以被存储在浏览器的 localStorage 或 sessionStorage 中。
+ * 支持过期时间设置，过期后数据会自动移除。
+ *
+ * @template T 存储数据的类型
+ *
+ * @example
+ * // 基础用法
+ * const userStore = new Store<User>('user', { name: '', age: 0 });
+ * userStore.set({ name: '张三', age: 25 });
+ * console.log(userStore.get()); // { name: '张三', age: 25 }
+ *
+ * @example
+ * // 使用 localStorage 并设置过期时间
+ * const tokenStore = new Store<string>('token', '', {
+ *   storageEngine: localStorage,
+ *   expires: 3600000 // 1小时后过期
+ * });
  */
 class Store {
     /**
-     * 初始化Store类的实例。
-     * @param key 缓存值的键名。
-     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值。
-     * @param options 配置选项，包括存储引擎和过期时间。
+     * 初始化 Store 类的实例
+     * @param key 缓存值的键名
+     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值
+     * @param options 配置选项，包括存储引擎和过期时间
      */
     constructor(key, defaultValue, options) {
+        this.key = key;
         this.value = defaultValue;
-        // 进行初始设置
-        this.storageKey = () => `@${prefix}_${key}`.toLocaleUpperCase();
         const { storageEngine = sessionStorage, expires } = options !== null && options !== void 0 ? options : {};
         this.storage = storageEngine;
         this.expires = expires;
-        const storedValue = this.storage.getItem(this.storageKey());
-        if (storedValue) {
+        // 尝试从存储中读取数据
+        this.loadFromStorage();
+    }
+    /**
+     * 生成存储键名
+     */
+    getStorageKey() {
+        return `@${prefix}_${this.key}`.toLocaleUpperCase();
+    }
+    /**
+     * 从存储中加载数据
+     */
+    loadFromStorage() {
+        try {
+            const storedValue = this.storage.getItem(this.getStorageKey());
+            if (!storedValue) {
+                return;
+            }
             const { data, expiry } = JSON.parse(storedValue);
-            // 判断是否过期，过期后删除key
+            // 检查是否过期
             if (!expiry || expiry > Date.now()) {
                 this.value = data;
             }
             else {
-                this.storage.removeItem(this.storageKey());
+                // 过期则删除
+                this.clear();
             }
         }
+        catch (error) {
+            console.error(`从存储中读取数据失败 (key: ${this.getStorageKey()}):`, error);
+            // 数据损坏时清除
+            this.clear();
+        }
     }
     /**
-     * 获取当前缓存的值。
-     * @returns 缓存的值。
+     * 获取当前缓存的值
+     * @returns 缓存的值
      */
     get() {
         return this.value;
     }
     /**
-     * 设置新的缓存值。
-     * @param newValue 新的值。
+     * 设置新的缓存值
+     * @param newValue 新的值
      */
     set(newValue) {
         this.value = newValue;
-        // 设置值时进行Storage设置
-        const value = JSON.stringify({
-            data: newValue,
-            expiry: this.expires ? Date.now() + this.expires : null,
-        });
-        this.storage.setItem(this.storageKey(), value);
+        try {
+            const storageData = {
+                data: newValue,
+                expiry: this.expires ? Date.now() + this.expires : null,
+            };
+            this.storage.setItem(this.getStorageKey(), JSON.stringify(storageData));
+        }
+        catch (error) {
+            console.error(`存储数据失败 (key: ${this.getStorageKey()}):`, error);
+        }
     }
     /**
-     * 使用提供的函数更新缓存的值。
-     * @param updateFn 一个接受当前值并返回新值的函数。
+     * 使用提供的函数更新缓存的值
+     * @param updateFn 一个接受当前值并返回新值的函数
+     *
+     * @example
+     * const countStore = new Store<number>('count', 0);
+     * countStore.update(count => count + 1);
      */
     update(updateFn) {
         if (typeof updateFn === 'function') {
             this.set(updateFn(this.value));
         }
     }
+    /**
+     * 清除缓存数据
+     */
+    clear() {
+        try {
+            this.storage.removeItem(this.getStorageKey());
+        }
+        catch (error) {
+            console.error(`清除存储数据失败 (key: ${this.getStorageKey()}):`, error);
+        }
+    }
+    /**
+     * 检查缓存是否存在且未过期
+     * @returns 如果缓存存在且未过期返回 true，否则返回 false
+     */
+    has() {
+        try {
+            const storedValue = this.storage.getItem(this.getStorageKey());
+            if (!storedValue) {
+                return false;
+            }
+            const { expiry } = JSON.parse(storedValue);
+            return !expiry || expiry > Date.now();
+        }
+        catch (_a) {
+            return false;
+        }
+    }
 }
 
 /**
  * 深克隆一个对象或数组
  *
- * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响
+ * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响。
+ * 支持克隆：普通对象、数组、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
  */
 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;
 }
 
 /**
  * 监听元素的大小变化
  *
- * 此函数创建了一个Observable，用于观察给定HTMLElement元素的大小变化它使用了ResizeObserver API来实现
- * 当元素的大小发生变化时，会发出一个包含变化记录的数组
+ * 此函数创建了一个 Observable，用于观察给定 HTMLElement 元素的大小变化。
+ * 它使用了 ResizeObserver API 来实现，当元素的大小发生变化时，会发出一个包含变化记录的数组。
+ *
+ * @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}`);
+ * });
  *
- * @param element 需要观察大小变化的HTMLElement元素
- * @returns 返回一个Observable，其中包含ResizeObserverEntry的数组，用于记录每次大小变化的信息
+ * @example
+ * // 使用防抖优化性能
+ * observeResize(element, { debounce: 300 }).subscribe(entries => {
+ *   // 300ms 内的多次变化只会触发一次
+ *   console.log('元素大小已稳定');
+ * });
  */
-function observeResize(element) {
-    return new Observable((observer) => {
-        // 创建ResizeObserver实例，当观察的目标元素大小发生变化时，会调用回调函数
+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$;
 }
 
 /**
  * 表单验证
- * @param form
+ *
+ * 遍历表单所有控件，标记为脏状态并触发验证。
+ * 如果表单验证通过，返回表单的原始值；否则返回 false。
+ *
+ * @param form Angular 表单组对象
+ * @param options 验证配置选项
+ * @returns 验证通过返回表单值，验证失败返回 false
+ *
+ * @example
+ * const result = formVerify(this.form);
+ * if (result) {
+ *   console.log('表单数据:', result);
+ * }
+ *
+ * @example
+ * // 自定义错误处理
+ * formVerify(this.form, {
+ *   logError: false,
+ *   onError: (fields) => {
+ *     this.message.error(`以下字段验证失败: ${fields.join(', ')}`);
+ *   }
+ * });
  */
-function formVerify(form) {
-    const errList = [];
-    for (const key in form.controls) {
-        form.controls[key].markAsDirty();
-        form.controls[key].updateValueAndValidity();
-        if (form.controls[key].status !== 'VALID' && form.controls[key].status !== 'DISABLED') {
-            errList.push(key);
+function formVerify(form, options) {
+    const { logError = true, onError } = options || {};
+    const invalidFields = [];
+    // 遍历所有控件，标记为脏状态并更新验证状态
+    Object.keys(form.controls).forEach((key) => {
+        const control = form.controls[key];
+        control.markAsDirty();
+        control.updateValueAndValidity();
+        // 收集验证失败的字段（排除禁用状态）
+        if (control.status !== 'VALID' && control.status !== 'DISABLED') {
+            invalidFields.push(key);
+        }
+    });
+    // 表单验证失败（排除全部禁用的情况）
+    if (form.status !== 'VALID' && form.status !== 'DISABLED') {
+        if (logError) {
+            console.error(`表单验证失败，字段: ${invalidFields.join(', ')}`);
+        }
+        if (onError) {
+            onError(invalidFields);
         }
-    }
-    // 表单验证状态
-    if (form.status !== 'VALID') {
-        console.error(`Form validation failed fields：${errList.join(',')}`);
         return false;
     }
+    // 验证通过，返回表单原始值（包含禁用字段）
     return form.getRawValue();
 }
 

package/fesm2015/reskin-core-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"reskin-core-utils.js","sources":["../../../library/core/utils/store.ts","../../../library/core/utils/array.ts","../../../library/core/utils/dom.ts","../../../library/core/utils/form.ts","../../../library/core/utils/reskin-core-utils.ts"],"sourcesContent":["/**\r\n * 缓存配置信息\r\n */\r\nexport interface StoreOptions {\r\n    /**\r\n     * 缓存存储方式\r\n     */\r\n    storageEngine?: Storage;\r\n    /**\r\n     * 过期时间(毫秒)\r\n     */\r\n    expires?: number;\r\n}\r\n\r\n/**\r\n * 默认前缀\r\n */\r\nlet prefix: string = 'SK_';\r\n\r\n/**\r\n * 设置存储前缀\r\n *\r\n * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。\r\n * 存储前缀的更改可能会影响已存储的数据被正确识别和访问。\r\n *\r\n * @param newPrefix 新的存储前缀字符串\r\n */\r\nexport function setStorePrefix(newPrefix: string) {\r\n    prefix = newPrefix;\r\n}\r\n\r\n/**\r\n * 提供了一个用于缓存值的类，值可以被存储在浏览器的localStorage或sessionStorage中。\r\n * 如果提供了过期时间，存储的值会在过期后自动移除。\r\n */\r\nexport class Store<T> {\r\n    private value: T;\r\n    private readonly storage: Storage;\r\n    private readonly expires?: number;\r\n    private readonly storageKey: () => string;\r\n\r\n    /**\r\n     * 初始化Store类的实例。\r\n     * @param key 缓存值的键名。\r\n     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值。\r\n     * @param options 配置选项，包括存储引擎和过期时间。\r\n     */\r\n    constructor(key: string, defaultValue: T, options?: StoreOptions) {\r\n        this.value = defaultValue;\r\n\r\n        // 进行初始设置\r\n        this.storageKey = () => `@${prefix}_${key}`.toLocaleUpperCase();\r\n        const { storageEngine = sessionStorage, expires } = options ?? {};\r\n        this.storage = storageEngine;\r\n        this.expires = expires;\r\n\r\n        const storedValue = this.storage.getItem(this.storageKey());\r\n        if (storedValue) {\r\n            const { data, expiry } = JSON.parse(storedValue);\r\n            // 判断是否过期，过期后删除key\r\n            if (!expiry || expiry > Date.now()) {\r\n                this.value = data;\r\n            } else {\r\n                this.storage.removeItem(this.storageKey());\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 获取当前缓存的值。\r\n     * @returns 缓存的值。\r\n     */\r\n    get(): T {\r\n        return this.value;\r\n    }\r\n\r\n    /**\r\n     * 设置新的缓存值。\r\n     * @param newValue 新的值。\r\n     */\r\n    set(newValue: T): void {\r\n        this.value = newValue;\r\n\r\n        // 设置值时进行Storage设置\r\n        const value = JSON.stringify({\r\n            data: newValue,\r\n            expiry: this.expires ? Date.now() + this.expires : null,\r\n        });\r\n        this.storage.setItem(this.storageKey(), value);\r\n    }\r\n\r\n    /**\r\n     * 使用提供的函数更新缓存的值。\r\n     * @param updateFn 一个接受当前值并返回新值的函数。\r\n     */\r\n    update(updateFn: (currentValue: T) => T): void {\r\n        if (typeof updateFn === 'function') {\r\n            this.set(updateFn(this.value));\r\n        }\r\n    }\r\n}\r\n","/**\r\n * 深克隆一个对象或数组\r\n *\r\n * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响\r\n *\r\n * @param source 需要克隆的源对象或数组\r\n * @returns 返回克隆后的对象或数组\r\n */\r\nexport function deepClone<T>(source: T): T {\r\n    // 如果源对象为null或不是对象类型，则直接返回源对象\r\n    if (source === null || typeof source !== 'object') {\r\n        return source;\r\n    }\r\n\r\n    // 如果源对象是数组，则创建一个新数组并递归克隆每个元素\r\n    if (Array.isArray(source)) {\r\n        const clonedArray = [];\r\n        for (let i = 0; i < source.length; i++) {\r\n            clonedArray[i] = deepClone(source[i]);\r\n        }\r\n        // 忽略类型检查器的警告，确保能够返回泛型T类型的数组\r\n        // @ts-ignore\r\n        return clonedArray as T;\r\n    }\r\n\r\n    // 如果源对象是普通对象，则创建一个新的空对象并递归克隆每个属性\r\n    if (typeof source === 'object') {\r\n        const clonedObject: Record<string, any> = {};\r\n        for (const key in source) {\r\n            // 确保只处理对象自身的属性，避免原型链上的属性被克隆\r\n            // @ts-ignore\r\n            if (source.hasOwnProperty(key)) {\r\n                clonedObject[key] = deepClone(source[key]);\r\n            }\r\n        }\r\n        // 忽略类型检查器的警告，确保能够返回泛型T类型的对象\r\n        return clonedObject as T;\r\n    }\r\n\r\n    // 如果源对象是其他非对象类型，则直接返回源对象\r\n    return source;\r\n}\r\n","import { Observable } from 'rxjs';\r\n\r\n/**\r\n * 监听元素的大小变化\r\n *\r\n * 此函数创建了一个Observable，用于观察给定HTMLElement元素的大小变化它使用了ResizeObserver API来实现\r\n * 当元素的大小发生变化时，会发出一个包含变化记录的数组\r\n *\r\n * @param element 需要观察大小变化的HTMLElement元素\r\n * @returns 返回一个Observable，其中包含ResizeObserverEntry的数组，用于记录每次大小变化的信息\r\n */\r\nexport function observeResize(element: HTMLElement): Observable<ResizeObserverEntry[]> {\r\n    return new Observable((observer) => {\r\n        // 创建ResizeObserver实例，当观察的目标元素大小发生变化时，会调用回调函数\r\n        const resizeObserver = new ResizeObserver((entries) => {\r\n            observer.next(entries);\r\n        });\r\n        // 开始观察指定的元素\r\n        resizeObserver.observe(element);\r\n        // 返回一个函数，用于在停止观察时调用，以清理资源\r\n        return () => {\r\n            // 停止观察指定的元素\r\n            resizeObserver.unobserve(element);\r\n            // 断开与所有目标的观察连接\r\n            resizeObserver.disconnect();\r\n        };\r\n    });\r\n}\r\n","import { FormGroup } from '@angular/forms';\r\n\r\n/**\r\n * 表单验证\r\n * @param form\r\n */\r\nexport function formVerify<T = Record<string, any>>(form: FormGroup): false | T {\r\n    const errList = [];\r\n    for (const key in form.controls) {\r\n        form.controls[key].markAsDirty();\r\n        form.controls[key].updateValueAndValidity();\r\n        if (form.controls[key].status !== 'VALID' && form.controls[key].status !== 'DISABLED') {\r\n            errList.push(key);\r\n        }\r\n    }\r\n    // 表单验证状态\r\n    if (form.status !== 'VALID') {\r\n        console.error(`Form validation failed fields：${errList.join(',')}`);\r\n        return false;\r\n    }\r\n    return form.getRawValue();\r\n}\r\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;AAcA;;AAEG;AACH,IAAI,MAAM,GAAW,KAAK,CAAC;AAE3B;;;;;;;AAOG;AACG,SAAU,cAAc,CAAC,SAAiB,EAAA;IAC5C,MAAM,GAAG,SAAS,CAAC;AACvB,CAAC;AAED;;;AAGG;MACU,KAAK,CAAA;AAMd;;;;;AAKG;AACH,IAAA,WAAA,CAAY,GAAW,EAAE,YAAe,EAAE,OAAsB,EAAA;AAC5D,QAAA,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;;AAG1B,QAAA,IAAI,CAAC,UAAU,GAAG,MAAM,CAAA,CAAA,EAAI,MAAM,CAAA,CAAA,EAAI,GAAG,CAAA,CAAE,CAAC,iBAAiB,EAAE,CAAC;AAChE,QAAA,MAAM,EAAE,aAAa,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,OAAO,aAAP,OAAO,KAAA,KAAA,CAAA,GAAP,OAAO,GAAI,EAAE,CAAC;AAClE,QAAA,IAAI,CAAC,OAAO,GAAG,aAAa,CAAC;AAC7B,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;AAEvB,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;AAC5D,QAAA,IAAI,WAAW,EAAE;AACb,YAAA,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;;YAEjD,IAAI,CAAC,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE;AAChC,gBAAA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;AACrB,aAAA;AAAM,iBAAA;gBACH,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;AAC9C,aAAA;AACJ,SAAA;KACJ;AAED;;;AAGG;IACH,GAAG,GAAA;QACC,OAAO,IAAI,CAAC,KAAK,CAAC;KACrB;AAED;;;AAGG;AACH,IAAA,GAAG,CAAC,QAAW,EAAA;AACX,QAAA,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;;AAGtB,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;AACzB,YAAA,IAAI,EAAE,QAAQ;AACd,YAAA,MAAM,EAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI;AAC1D,SAAA,CAAC,CAAC;AACH,QAAA,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,KAAK,CAAC,CAAC;KAClD;AAED;;;AAGG;AACH,IAAA,MAAM,CAAC,QAAgC,EAAA;AACnC,QAAA,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE;YAChC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAClC,SAAA;KACJ;AACJ;;ACpGD;;;;;;;AAOG;AACG,SAAU,SAAS,CAAI,MAAS,EAAA;;IAElC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC/C,QAAA,OAAO,MAAM,CAAC;AACjB,KAAA;;AAGD,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACvB,MAAM,WAAW,GAAG,EAAE,CAAC;AACvB,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACpC,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACzC,SAAA;;;AAGD,QAAA,OAAO,WAAgB,CAAC;AAC3B,KAAA;;AAGD,IAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QAC5B,MAAM,YAAY,GAAwB,EAAE,CAAC;AAC7C,QAAA,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE;;;AAGtB,YAAA,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;gBAC5B,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9C,aAAA;AACJ,SAAA;;AAED,QAAA,OAAO,YAAiB,CAAC;AAC5B,KAAA;;AAGD,IAAA,OAAO,MAAM,CAAC;AAClB;;ACvCA;;;;;;;;AAQG;AACG,SAAU,aAAa,CAAC,OAAoB,EAAA;AAC9C,IAAA,OAAO,IAAI,UAAU,CAAC,CAAC,QAAQ,KAAI;;QAE/B,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC,CAAC,OAAO,KAAI;AAClD,YAAA,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3B,SAAC,CAAC,CAAC;;AAEH,QAAA,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;;AAEhC,QAAA,OAAO,MAAK;;AAER,YAAA,cAAc,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;;YAElC,cAAc,CAAC,UAAU,EAAE,CAAC;AAChC,SAAC,CAAC;AACN,KAAC,CAAC,CAAC;AACP;;ACzBA;;;AAGG;AACG,SAAU,UAAU,CAA0B,IAAe,EAAA;IAC/D,MAAM,OAAO,GAAG,EAAE,CAAC;AACnB,IAAA,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE;QAC7B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;QACjC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,sBAAsB,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,UAAU,EAAE;AACnF,YAAA,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACrB,SAAA;AACJ,KAAA;;AAED,IAAA,IAAI,IAAI,CAAC,MAAM,KAAK,OAAO,EAAE;AACzB,QAAA,OAAO,CAAC,KAAK,CAAC,CAAA,8BAAA,EAAiC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAE,CAAA,CAAC,CAAC;AACpE,QAAA,OAAO,KAAK,CAAC;AAChB,KAAA;AACD,IAAA,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;AAC9B;;ACrBA;;AAEG;;;;"}
+{"version":3,"file":"reskin-core-utils.js","sources":["../../../library/core/utils/store.ts","../../../library/core/utils/array.ts","../../../library/core/utils/dom.ts","../../../library/core/utils/form.ts","../../../library/core/utils/reskin-core-utils.ts"],"sourcesContent":["/**\r\n * 缓存配置信息\r\n */\r\nexport interface StoreOptions {\r\n    /**\r\n     * 缓存存储方式\r\n     * @default sessionStorage\r\n     */\r\n    storageEngine?: Storage;\r\n    /**\r\n     * 过期时间（毫秒）\r\n     * @default undefined (永不过期)\r\n     */\r\n    expires?: number;\r\n}\r\n\r\n/**\r\n * 存储数据结构\r\n */\r\ninterface StorageData<T> {\r\n    /**\r\n     * 实际存储的数据\r\n     */\r\n    data: T;\r\n    /**\r\n     * 过期时间戳（毫秒）\r\n     */\r\n    expiry: number | null;\r\n}\r\n\r\n/**\r\n * 默认前缀\r\n */\r\nlet prefix: string = 'SK_';\r\n\r\n/**\r\n * 设置存储前缀\r\n *\r\n * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。\r\n * 注意：更改前缀后，之前使用旧前缀存储的数据将无法访问。\r\n *\r\n * @param newPrefix 新的存储前缀字符串\r\n *\r\n * @example\r\n * setStorePrefix('MY_APP_');\r\n */\r\nexport function setStorePrefix(newPrefix: string): void {\r\n    prefix = newPrefix;\r\n}\r\n\r\n/**\r\n * 提供了一个用于缓存值的类，值可以被存储在浏览器的 localStorage 或 sessionStorage 中。\r\n * 支持过期时间设置，过期后数据会自动移除。\r\n *\r\n * @template T 存储数据的类型\r\n *\r\n * @example\r\n * // 基础用法\r\n * const userStore = new Store<User>('user', { name: '', age: 0 });\r\n * userStore.set({ name: '张三', age: 25 });\r\n * console.log(userStore.get()); // { name: '张三', age: 25 }\r\n *\r\n * @example\r\n * // 使用 localStorage 并设置过期时间\r\n * const tokenStore = new Store<string>('token', '', {\r\n *   storageEngine: localStorage,\r\n *   expires: 3600000 // 1小时后过期\r\n * });\r\n */\r\nexport class Store<T> {\r\n    private value: T;\r\n    private readonly storage: Storage;\r\n    private readonly expires?: number;\r\n    private readonly key: string;\r\n\r\n    /**\r\n     * 初始化 Store 类的实例\r\n     * @param key 缓存值的键名\r\n     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值\r\n     * @param options 配置选项，包括存储引擎和过期时间\r\n     */\r\n    constructor(key: string, defaultValue: T, options?: StoreOptions) {\r\n        this.key = key;\r\n        this.value = defaultValue;\r\n\r\n        const { storageEngine = sessionStorage, expires } = options ?? {};\r\n        this.storage = storageEngine;\r\n        this.expires = expires;\r\n\r\n        // 尝试从存储中读取数据\r\n        this.loadFromStorage();\r\n    }\r\n\r\n    /**\r\n     * 生成存储键名\r\n     */\r\n    private getStorageKey(): string {\r\n        return `@${prefix}_${this.key}`.toLocaleUpperCase();\r\n    }\r\n\r\n    /**\r\n     * 从存储中加载数据\r\n     */\r\n    private loadFromStorage(): void {\r\n        try {\r\n            const storedValue = this.storage.getItem(this.getStorageKey());\r\n            if (!storedValue) {\r\n                return;\r\n            }\r\n\r\n            const { data, expiry } = JSON.parse(storedValue) as StorageData<T>;\r\n\r\n            // 检查是否过期\r\n            if (!expiry || expiry > Date.now()) {\r\n                this.value = data;\r\n            } else {\r\n                // 过期则删除\r\n                this.clear();\r\n            }\r\n        } catch (error) {\r\n            console.error(`从存储中读取数据失败 (key: ${this.getStorageKey()}):`, error);\r\n            // 数据损坏时清除\r\n            this.clear();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 获取当前缓存的值\r\n     * @returns 缓存的值\r\n     */\r\n    get(): T {\r\n        return this.value;\r\n    }\r\n\r\n    /**\r\n     * 设置新的缓存值\r\n     * @param newValue 新的值\r\n     */\r\n    set(newValue: T): void {\r\n        this.value = newValue;\r\n\r\n        try {\r\n            const storageData: StorageData<T> = {\r\n                data: newValue,\r\n                expiry: this.expires ? Date.now() + this.expires : null,\r\n            };\r\n            this.storage.setItem(this.getStorageKey(), JSON.stringify(storageData));\r\n        } catch (error) {\r\n            console.error(`存储数据失败 (key: ${this.getStorageKey()}):`, error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 使用提供的函数更新缓存的值\r\n     * @param updateFn 一个接受当前值并返回新值的函数\r\n     *\r\n     * @example\r\n     * const countStore = new Store<number>('count', 0);\r\n     * countStore.update(count => count + 1);\r\n     */\r\n    update(updateFn: (currentValue: T) => T): void {\r\n        if (typeof updateFn === 'function') {\r\n            this.set(updateFn(this.value));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 清除缓存数据\r\n     */\r\n    clear(): void {\r\n        try {\r\n            this.storage.removeItem(this.getStorageKey());\r\n        } catch (error) {\r\n            console.error(`清除存储数据失败 (key: ${this.getStorageKey()}):`, error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 检查缓存是否存在且未过期\r\n     * @returns 如果缓存存在且未过期返回 true，否则返回 false\r\n     */\r\n    has(): boolean {\r\n        try {\r\n            const storedValue = this.storage.getItem(this.getStorageKey());\r\n            if (!storedValue) {\r\n                return false;\r\n            }\r\n\r\n            const { expiry } = JSON.parse(storedValue) as StorageData<T>;\r\n            return !expiry || expiry > Date.now();\r\n        } catch {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n","/**\r\n * 深克隆一个对象或数组\r\n *\r\n * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响。\r\n * 支持克隆：普通对象、数组、Date、Map、Set、RegExp 等类型。\r\n *\r\n * @param source 需要克隆的源对象或数组\r\n * @returns 返回克隆后的对象或数组\r\n *\r\n * @example\r\n * const obj = { a: 1, b: { c: 2 } };\r\n * const cloned = deepClone(obj);\r\n * cloned.b.c = 3;\r\n * console.log(obj.b.c); // 输出: 2\r\n */\r\nexport function deepClone<T>(source: T): T {\r\n    // 处理 null 和基本类型\r\n    if (source === null || typeof source !== 'object') {\r\n        return source;\r\n    }\r\n\r\n    // 处理 Date 对象\r\n    if (source instanceof Date) {\r\n        return new Date(source.getTime()) as unknown as T;\r\n    }\r\n\r\n    // 处理 RegExp 对象\r\n    if (source instanceof RegExp) {\r\n        return new RegExp(source.source, source.flags) as unknown as T;\r\n    }\r\n\r\n    // 处理 Map 对象\r\n    if (source instanceof Map) {\r\n        const clonedMap = new Map();\r\n        source.forEach((value, key) => {\r\n            clonedMap.set(deepClone(key), deepClone(value));\r\n        });\r\n        return clonedMap as unknown as T;\r\n    }\r\n\r\n    // 处理 Set 对象\r\n    if (source instanceof Set) {\r\n        const clonedSet = new Set();\r\n        source.forEach((value) => {\r\n            clonedSet.add(deepClone(value));\r\n        });\r\n        return clonedSet as unknown as T;\r\n    }\r\n\r\n    // 处理数组\r\n    if (Array.isArray(source)) {\r\n        return source.map((item) => deepClone(item)) as unknown as T;\r\n    }\r\n\r\n    // 处理普通对象\r\n    if (Object.prototype.toString.call(source) === '[object Object]') {\r\n        const clonedObject = {} as T;\r\n        Object.keys(source).forEach((key) => {\r\n            (clonedObject as any)[key] = deepClone((source as any)[key]);\r\n        });\r\n        return clonedObject;\r\n    }\r\n\r\n    // 其他类型直接返回（如函数、Symbol 等）\r\n    return source;\r\n}\r\n","import { Observable } from 'rxjs';\r\nimport { debounceTime } from 'rxjs/operators';\r\n\r\n/**\r\n * 监听元素大小变化的配置选项\r\n */\r\nexport interface ObserveResizeOptions {\r\n    /**\r\n     * 防抖延迟时间（毫秒）\r\n     * 设置后会对频繁的大小变化事件进行防抖处理\r\n     * @default undefined (不防抖)\r\n     */\r\n    debounce?: number;\r\n}\r\n\r\n/**\r\n * 监听元素的大小变化\r\n *\r\n * 此函数创建了一个 Observable，用于观察给定 HTMLElement 元素的大小变化。\r\n * 它使用了 ResizeObserver API 来实现，当元素的大小发生变化时，会发出一个包含变化记录的数组。\r\n *\r\n * @param element 需要观察大小变化的 HTMLElement 元素\r\n * @param options 配置选项\r\n * @returns 返回一个 Observable，其中包含 ResizeObserverEntry 的数组，用于记录每次大小变化的信息\r\n *\r\n * @example\r\n * // 基础用法\r\n * const element = document.querySelector('.container');\r\n * observeResize(element).subscribe(entries => {\r\n *   const { width, height } = entries[0].contentRect;\r\n *   console.log(`元素尺寸: ${width}x${height}`);\r\n * });\r\n *\r\n * @example\r\n * // 使用防抖优化性能\r\n * observeResize(element, { debounce: 300 }).subscribe(entries => {\r\n *   // 300ms 内的多次变化只会触发一次\r\n *   console.log('元素大小已稳定');\r\n * });\r\n */\r\nexport function observeResize(element: HTMLElement, options?: ObserveResizeOptions): Observable<ResizeObserverEntry[]> {\r\n    const { debounce } = options || {};\r\n\r\n    const resize$ = new Observable<ResizeObserverEntry[]>((observer) => {\r\n        // 创建 ResizeObserver 实例，当观察的目标元素大小发生变化时，会调用回调函数\r\n        const resizeObserver = new ResizeObserver((entries) => {\r\n            observer.next(entries);\r\n        });\r\n\r\n        // 开始观察指定的元素\r\n        resizeObserver.observe(element);\r\n\r\n        // 返回清理函数，用于在取消订阅时调用\r\n        return () => {\r\n            resizeObserver.unobserve(element);\r\n            resizeObserver.disconnect();\r\n        };\r\n    });\r\n\r\n    // 如果设置了防抖，则应用防抖操作符\r\n    return debounce ? resize$.pipe(debounceTime(debounce)) : resize$;\r\n}\r\n","import { FormGroup } from '@angular/forms';\r\n\r\n/**\r\n * 表单验证配置\r\n */\r\nexport interface FormVerifyOptions {\r\n    /**\r\n     * 是否在控制台输出错误信息\r\n     * @default true\r\n     */\r\n    logError?: boolean;\r\n    /**\r\n     * 自定义错误处理函数\r\n     */\r\n    onError?: (invalidFields: string[]) => void;\r\n}\r\n\r\n/**\r\n * 表单验证\r\n *\r\n * 遍历表单所有控件，标记为脏状态并触发验证。\r\n * 如果表单验证通过，返回表单的原始值；否则返回 false。\r\n *\r\n * @param form Angular 表单组对象\r\n * @param options 验证配置选项\r\n * @returns 验证通过返回表单值，验证失败返回 false\r\n *\r\n * @example\r\n * const result = formVerify(this.form);\r\n * if (result) {\r\n *   console.log('表单数据:', result);\r\n * }\r\n *\r\n * @example\r\n * // 自定义错误处理\r\n * formVerify(this.form, {\r\n *   logError: false,\r\n *   onError: (fields) => {\r\n *     this.message.error(`以下字段验证失败: ${fields.join(', ')}`);\r\n *   }\r\n * });\r\n */\r\nexport function formVerify<T = Record<string, any>>(form: FormGroup, options?: FormVerifyOptions): false | T {\r\n    const { logError = true, onError } = options || {};\r\n    const invalidFields: string[] = [];\r\n\r\n    // 遍历所有控件，标记为脏状态并更新验证状态\r\n    Object.keys(form.controls).forEach((key) => {\r\n        const control = form.controls[key];\r\n        control.markAsDirty();\r\n        control.updateValueAndValidity();\r\n\r\n        // 收集验证失败的字段（排除禁用状态）\r\n        if (control.status !== 'VALID' && control.status !== 'DISABLED') {\r\n            invalidFields.push(key);\r\n        }\r\n    });\r\n\r\n    // 表单验证失败（排除全部禁用的情况）\r\n    if (form.status !== 'VALID' && form.status !== 'DISABLED') {\r\n        if (logError) {\r\n            console.error(`表单验证失败，字段: ${invalidFields.join(', ')}`);\r\n        }\r\n        if (onError) {\r\n            onError(invalidFields);\r\n        }\r\n        return false;\r\n    }\r\n\r\n    // 验证通过，返回表单原始值（包含禁用字段）\r\n    return form.getRawValue();\r\n}\r\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/guards/auth.guard.d.ts

@@ -6,7 +6,21 @@ import * as i0 from "@angular/core";
 /**
  * 路由守卫配置注入令牌
  */
-export declare const RK_ROUTER_GUARD_CONFIG: InjectionToken<unknown>;
+export declare const RK_ROUTER_GUARD_CONFIG: InjectionToken<IRouterGuardConfig[]>;
+/**
+ * 路由守卫选项注入令牌
+ */
+export declare const RK_ROUTER_GUARD_OPTIONS: InjectionToken<IAuthGuardOptions>;
+/**
+ * 菜单数据接口
+ */
+export interface IMenuData {
+    /**
+     * 系统资源URL
+     */
+    SYSTEM_RESOURCE_URL: string;
+    [key: string]: any;
+}
 /**
  * 路由守卫配置
  */
@@ -20,22 +34,88 @@ export interface IRouterGuardConfig {
      */
     extends: string[];
 }
+/**
+ * 路由守卫选项配置
+ */
+export interface IAuthGuardOptions {
+    /**
+     * 无权限时的跳转路径
+     * @default '/errors/401'
+     */
+    unauthorizedPath?: string;
+    /**
+     * 自定义无权限处理回调
+     * @param url - 被拒绝访问的路由地址
+     * @returns 返回 false 阻止导航，返回 UrlTree 进行重定向，返回 true 允许访问
+     */
+    onAccessDenied?: (url: string) => boolean | UrlTree;
+    /**
+     * 权限检查前的钩子函数
+     * @param route - 激活的路由快照
+     * @param state - 路由状态快照
+     * @returns 返回 false 跳过权限检查并拒绝访问，返回 true 继续权限检查
+     */
+    beforeCheck?: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;
+}
 /**
  * 路由守卫提供者配置函数
  *
  * @param urls - 路由守卫配置数组，包含需要保护的路由配置信息
+ * @param options - 可选的守卫选项配置
  * @returns 返回Angular依赖注入的Provider数组，用于配置路由守卫
  */
-export declare function providerRouterGuard(urls: IRouterGuardConfig[]): Provider[];
+export declare function providerRouterGuard(urls: IRouterGuardConfig[], options?: IAuthGuardOptions): Provider[];
+/**
+ * 路由权限守卫
+ *
+ * 用于保护路由，确保用户只能访问其被授权的路由。
+ * 支持权限继承机制和自定义权限检查逻辑。
+ */
 export declare class RkAuthGuard implements CanActivateChild {
     private config;
+    private options;
     private menu;
     private router;
-    constructor(config: IRouterGuardConfig[], menu: RkMenuService, router: Router);
+    constructor(config: IRouterGuardConfig[] | null, options: IAuthGuardOptions | null, menu: RkMenuService, router: Router);
     canActivateChild(childRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    /**
+     * 检查用户是否有权限访问指定路由
+     *
+     * @param menus - 用户菜单权限数据
+     * @param url - 目标路由地址
+     * @returns 返回 true 允许访问，返回 false 或 UrlTree 拒绝访问
+     */
     private checkAccess;
-    private match;
+    /**
+     * 检查是否有继承的权限
+     *
+     * @param routerUrl - 标准化后的路由地址
+     * @param authRoutes - 用户权限路由集合
+     * @returns 返回 true 表示有继承权限
+     */
+    private hasInheritedPermission;
+    /**
+     * 匹配路由规则
+     *
+     * @param pattern - 路由模式（支持 ** 通配符）
+     * @param path - 实际路由路径
+     * @returns 返回 true 表示匹配成功
+     */
+    private matchRoute;
+    /**
+     * 标准化URL，移除查询参数和片段标识符
+     *
+     * @param url - 原始URL
+     * @returns 标准化后的URL
+     */
+    private normalizeUrl;
+    /**
+     * 处理无权限访问
+     *
+     * @param url - 被拒绝访问的路由地址
+     * @returns 返回 false 或 UrlTree
+     */
     private handleNoAccess;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RkAuthGuard, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RkAuthGuard, [{ optional: true; }, { optional: true; }, null, null]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RkAuthGuard>;
 }

package/interceptors/blob.interceptor.d.ts

@@ -1,17 +1,44 @@
 import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * Blob 响应拦截器
+ * 处理文件下载请求中的 JSON 错误响应
+ */
 export declare class BlobInterceptor implements HttpInterceptor {
+    /**
+     * 拦截 HTTP 请求，处理 Blob 类型响应
+     * @param request HTTP 请求对象
+     * @param next 下一个拦截器处理器
+     * @returns Observable<HttpEvent<T>>
+     */
     intercept<T>(request: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>>;
+    /**
+     * 处理 Blob 响应事件
+     * @param event HTTP 事件
+     * @returns Observable<HttpEvent<any>>
+     */
     private handleBlobResponse;
+    /**
+     * 处理 Blob 错误响应
+     * @param error HTTP 错误响应
+     * @returns Observable<HttpEvent<any>>
+     */
     private handleBlobError;
-    private blobToJson;
+    /**
+     * 将 Blob 转换为 JSON 对象并抛出错误
+     * @param blob Blob 对象
+     * @returns Observable<HttpEvent<T>>
+     */
+    private convertBlobToJson;
     static ɵfac: i0.ɵɵFactoryDeclaration<BlobInterceptor, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BlobInterceptor>;
 }
 /**
- * 下载文件拦截器
- * blob类型的请求会被处理
+ * 提供 Blob 响应拦截器
+ * @returns Provider 配置对象
+ * @example
+ * providers: [providerDownBlob()]
  */
 export declare function providerDownBlob(): {
     provide: import("@angular/core").InjectionToken<HttpInterceptor[]>;

package/interceptors/cache.interceptor.d.ts

@@ -1,19 +1,43 @@
-import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
+import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HttpHeaders } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { RkCacheHttpService } from '@reskin/core/services';
 import * as i0 from "@angular/core";
+/**
+ * HTTP 缓存拦截器
+ * 为 GET 请求提供缓存功能，减少重复请求
+ */
 export declare class CacheInterceptor implements HttpInterceptor {
-    private cacheHttp;
-    constructor(cacheHttp: RkCacheHttpService);
+    private cacheHttpService;
+    constructor(cacheHttpService: RkCacheHttpService);
+    /**
+     * 拦截 HTTP 请求，实现缓存逻辑
+     * @param request HTTP 请求对象
+     * @param next 下一个拦截器处理器
+     * @returns Observable<HttpEvent<unknown>>
+     */
     intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CacheInterceptor, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CacheInterceptor>;
 }
 /**
- * GET请求缓存拦截器
+ * 提供 HTTP 缓存拦截器
+ * @returns Provider 配置对象
+ * @example
+ * providers: [providerHttpCache()]
  */
 export declare function providerHttpCache(): {
     provide: import("@angular/core").InjectionToken<HttpInterceptor[]>;
     useClass: typeof CacheInterceptor;
     multi: boolean;
 };
+/**
+ * 创建带缓存标记的 GET 请求配置
+ * @param urls 模板字符串数组
+ * @param params 模板参数
+ * @returns [url, options] 元组
+ * @example
+ * this.http.get(...CacheHttpTemplate`/api/data`).subscribe();
+ */
+export declare function CacheHttpTemplate(urls: TemplateStringsArray, ...params: any[]): [string, {
+    headers: HttpHeaders;
+}];