@reskin/core 0.0.21 → 0.1.0

package/esm2015/utils/store.js

@@ -6,71 +6,146 @@ let prefix = 'SK_';
  * 设置存储前缀
  *
  * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。
- * 存储前缀的更改可能会影响已存储的数据被正确识别和访问。
+ * 注意：更改前缀后，之前使用旧前缀存储的数据将无法访问。
  *
  * @param newPrefix 新的存储前缀字符串
+ *
+ * @example
+ * setStorePrefix('MY_APP_');
  */
 export 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小时后过期
+ * });
  */
 export 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;
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../library/core/utils/store.ts"],"names":[],"mappings":"AA8BA;;GAEG;AACH,IAAI,MAAM,GAAW,KAAK,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,SAAiB;IAC5C,MAAM,GAAG,SAAS,CAAC;AACvB,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,KAAK;IAMd;;;;;OAKG;IACH,YAAY,GAAW,EAAE,YAAe,EAAE,OAAsB;QAC5D,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;QAE1B,MAAM,EAAE,aAAa,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,EAAE,CAAC;QAClE,IAAI,CAAC,OAAO,GAAG,aAAa,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,aAAa;QACb,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,aAAa;QACjB,OAAO,IAAI,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC;IACxD,CAAC;IAED;;OAEG;IACK,eAAe;QACnB,IAAI;YACA,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;YAC/D,IAAI,CAAC,WAAW,EAAE;gBACd,OAAO;aACV;YAED,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAmB,CAAC;YAEnE,SAAS;YACT,IAAI,CAAC,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE;gBAChC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;aACrB;iBAAM;gBACH,QAAQ;gBACR,IAAI,CAAC,KAAK,EAAE,CAAC;aAChB;SACJ;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,CAAC,KAAK,CAAC,oBAAoB,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YACnE,UAAU;YACV,IAAI,CAAC,KAAK,EAAE,CAAC;SAChB;IACL,CAAC;IAED;;;OAGG;IACH,GAAG;QACC,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,QAAW;QACX,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QAEtB,IAAI;YACA,MAAM,WAAW,GAAmB;gBAChC,IAAI,EAAE,QAAQ;gBACd,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI;aAC1D,CAAC;YACF,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC;SAC3E;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,CAAC,KAAK,CAAC,gBAAgB,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;SAClE;IACL,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,QAAgC;QACnC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE;YAChC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAClC;IACL,CAAC;IAED;;OAEG;IACH,KAAK;QACD,IAAI;YACA,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;SACjD;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,CAAC,KAAK,CAAC,kBAAkB,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;SACpE;IACL,CAAC;IAED;;;OAGG;IACH,GAAG;QACC,IAAI;YACA,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;YAC/D,IAAI,CAAC,WAAW,EAAE;gBACd,OAAO,KAAK,CAAC;aAChB;YAED,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAmB,CAAC;YAC7D,OAAO,CAAC,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;SACzC;QAAC,WAAM;YACJ,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;CACJ","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"]}

package/fesm2015/reskin-core-directives.js

@@ -1,63 +1,104 @@
 import * as i0 from '@angular/core';
 import { Directive, Input, TemplateRef, EventEmitter, Output, NgModule } from '@angular/core';
-import { map } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { takeUntil, map } from 'rxjs/operators';
 import * as i1 from '@reskin/core/services';
 
+/**
+ * 权限指令
+ * 根据权限标识符控制模板的显示与隐藏
+ *
+ * @example
+ * ```html
+ * <!-- 基础用法 -->
+ * <div *rkAuth="'user:edit'">有编辑权限才显示</div>
+ *
+ * <!-- 多个权限（或关系） -->
+ * <div *rkAuth="['user:edit', 'user:delete']">有任一权限即显示</div>
+ *
+ * <!-- 使用 then/else 模板 -->
+ * <ng-container *rkAuth="'user:edit'; then hasAuth; else noAuth"></ng-container>
+ * <ng-template #hasAuth let-menu>
+ *   <p>有权限，菜单信息：{{ menu | json }}</p>
+ * </ng-template>
+ * <ng-template #noAuth>
+ *   <p>无权限</p>
+ * </ng-template>
+ * ```
+ */
 class RkAuthDirective {
-    constructor(menu, viewContainerRef, templateRef) {
-        this.menu = menu;
+    constructor(menuService, viewContainerRef, templateRef) {
+        this.menuService = menuService;
         this.viewContainerRef = viewContainerRef;
         this.templateRef = templateRef;
         this.condition = '';
+        this.destroy$ = new Subject();
         this.thenTemplateRef = templateRef;
     }
     /**
-     * 传递多个标识符时，逗号分隔，匹配按"或者"运算
-     * @param condition
+     * 权限标识符
+     * 传递多个标识符时，匹配按"或"运算
      */
     set rkAuth(condition) {
         this.condition = condition;
         this.updateView();
     }
+    /**
+     * 有权限时显示的模板
+     */
     set rkAuthThen(templateRef) {
         this.thenTemplateRef = templateRef;
         this.updateView();
     }
+    /**
+     * 无权限时显示的模板
+     */
     set rkAuthElse(templateRef) {
         this.elseTemplateRef = templateRef;
         this.updateView();
     }
     ngOnDestroy() {
-        var _a;
-        (_a = this.authSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.destroy$.next();
+        this.destroy$.complete();
     }
+    /**
+     * 更新视图显示
+     */
     updateView() {
-        var _a;
-        (_a = this.authSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-        this.authSubscription = this.hasAuth(this.condition).subscribe((context) => {
+        if (!this.condition) {
             this.viewContainerRef.clear();
-            if (context.status) {
-                if (this.thenTemplateRef) {
-                    this.viewContainerRef.createEmbeddedView(this.thenTemplateRef, context);
-                }
-            }
-            else {
-                if (this.elseTemplateRef) {
-                    this.viewContainerRef.createEmbeddedView(this.elseTemplateRef, context);
-                }
-            }
+            return;
+        }
+        this.checkAuth(this.condition)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((context) => {
+            this.renderView(context);
         });
     }
-    hasAuth(tags) {
-        const tagList = typeof tags === 'string' ? [tags] : tags;
-        return this.menu.requestData().pipe(map((json) => {
-            const menus = json.data.filter((menu) => tagList.includes(menu.SYSTEM_RESOURCE_GUARD_ID));
-            if (!menus.length)
-                return { $implicit: [], status: false };
-            return {
-                $implicit: typeof tags === 'string' ? menus[0] : menus,
-                status: !!menus.length,
+    /**
+     * 渲染视图
+     */
+    renderView(context) {
+        this.viewContainerRef.clear();
+        if (context.status && this.thenTemplateRef) {
+            this.viewContainerRef.createEmbeddedView(this.thenTemplateRef, context);
+        }
+        else if (!context.status && this.elseTemplateRef) {
+            this.viewContainerRef.createEmbeddedView(this.elseTemplateRef, context);
+        }
+    }
+    /**
+     * 检查权限
+     */
+    checkAuth(tags) {
+        const tagList = Array.isArray(tags) ? tags : [tags];
+        return this.menuService.requestData().pipe(map((response) => {
+            const matchedMenus = response.data.filter((menu) => tagList.includes(menu.SYSTEM_RESOURCE_GUARD_ID));
+            const context = {
+                $implicit: Array.isArray(tags) ? matchedMenus : matchedMenus[0] || null,
+                status: matchedMenus.length > 0,
             };
+            return context;
         }));
     }
 }
@@ -76,120 +117,245 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                 type: Input
             }] } });
 
+/**
+ * 字符串模板输出上下文
+ */
+class RkStringTemplateOutletContext {
+    constructor() {
+        /** 隐式上下文值 */
+        this.$implicit = null;
+    }
+}
+/**
+ * 字符串模板输出指令
+ * 支持动态渲染字符串或 TemplateRef
+ *
+ * @example
+ * ```html
+ * <!-- 渲染字符串 -->
+ * <ng-container *rkStringTemplateOutlet="'Hello World'">
+ *   <ng-template>默认模板</ng-template>
+ * </ng-container>
+ *
+ * <!-- 渲染 TemplateRef -->
+ * <ng-container *rkStringTemplateOutlet="customTemplate; context: { $implicit: data }">
+ * </ng-container>
+ * <ng-template #customTemplate let-item>
+ *   <div>{{ item }}</div>
+ * </ng-template>
+ *
+ * <!-- 动态切换 -->
+ * <ng-container *rkStringTemplateOutlet="isTemplate ? templateRef : 'Static Text'">
+ * </ng-container>
+ * ```
+ */
 class RkStringTemplateOutletDirective {
-    constructor(viewContainer, templateRef) {
-        this.viewContainer = viewContainer;
+    constructor(viewContainerRef, templateRef) {
+        this.viewContainerRef = viewContainerRef;
         this.templateRef = templateRef;
         this.embeddedViewRef = null;
         this.context = new RkStringTemplateOutletContext();
-        this.rkStringTemplateOutletContext = null;
+        /**
+         * 输出内容
+         * 可以是字符串或 TemplateRef
+         */
         this.rkStringTemplateOutlet = null;
+        /**
+         * 模板上下文
+         * 当 rkStringTemplateOutlet 是 TemplateRef 时使用
+         */
+        this.rkStringTemplateOutletContext = null;
     }
+    /**
+     * 类型守卫
+     * 用于 Angular 模板类型检查
+     */
     static rkTemplateContextGuard(_dir, _ctx) {
         return true;
     }
-    recreateView() {
-        this.viewContainer.clear();
-        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;
-        const templateRef = (isTemplateRef ? this.rkStringTemplateOutlet : this.templateRef);
-        this.embeddedViewRef = this.viewContainer.createEmbeddedView(templateRef, isTemplateRef ? this.rkStringTemplateOutletContext : this.context);
-    }
-    updateContext() {
-        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;
-        const newCtx = isTemplateRef ? this.rkStringTemplateOutletContext : this.context;
-        const oldCtx = this.embeddedViewRef.context;
-        if (newCtx) {
-            for (const propName of Object.keys(newCtx)) {
-                oldCtx[propName] = newCtx[propName];
-            }
-        }
-    }
     ngOnChanges(changes) {
-        const { rkStringTemplateOutletContext, rkStringTemplateOutlet } = changes;
-        const shouldRecreateView = () => {
-            let shouldOutletRecreate = false;
-            if (rkStringTemplateOutlet) {
-                if (rkStringTemplateOutlet.firstChange) {
-                    shouldOutletRecreate = true;
-                }
-                else {
-                    const isPreviousOutletTemplate = rkStringTemplateOutlet.previousValue instanceof TemplateRef;
-                    const isCurrentOutletTemplate = rkStringTemplateOutlet.currentValue instanceof TemplateRef;
-                    shouldOutletRecreate = isPreviousOutletTemplate || isCurrentOutletTemplate;
-                }
-            }
-            const hasContextShapeChanged = (ctxChange) => {
-                const prevCtxKeys = Object.keys(ctxChange.previousValue || {});
-                const currCtxKeys = Object.keys(ctxChange.currentValue || {});
-                if (prevCtxKeys.length === currCtxKeys.length) {
-                    for (const propName of currCtxKeys) {
-                        if (prevCtxKeys.indexOf(propName) === -1) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-                else {
-                    return true;
-                }
-            };
-            const shouldContextRecreate = rkStringTemplateOutletContext && hasContextShapeChanged(rkStringTemplateOutletContext);
-            return shouldContextRecreate || shouldOutletRecreate;
-        };
+        const { rkStringTemplateOutlet, rkStringTemplateOutletContext } = changes;
+        // 更新隐式上下文
         if (rkStringTemplateOutlet) {
             this.context.$implicit = rkStringTemplateOutlet.currentValue;
         }
-        const recreateView = shouldRecreateView();
-        if (recreateView) {
-            /** recreate view when context shape or outlet change **/
+        // 判断是否需要重建视图
+        if (this.shouldRecreateView(rkStringTemplateOutlet, rkStringTemplateOutletContext)) {
             this.recreateView();
         }
         else {
-            /** update context **/
             this.updateContext();
         }
     }
+    /**
+     * 判断是否需要重建视图
+     */
+    shouldRecreateView(outletChange, contextChange) {
+        // 首次变更需要创建视图
+        if (outletChange === null || outletChange === void 0 ? void 0 : outletChange.firstChange) {
+            return true;
+        }
+        // outlet 在 TemplateRef 和非 TemplateRef 之间切换时需要重建
+        if (outletChange && this.isOutletTypeChanged(outletChange)) {
+            return true;
+        }
+        // 上下文结构变化时需要重建
+        if (contextChange && this.isContextShapeChanged(contextChange)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 检查 outlet 类型是否变化
+     */
+    isOutletTypeChanged(change) {
+        const isPreviousTemplate = change.previousValue instanceof TemplateRef;
+        const isCurrentTemplate = change.currentValue instanceof TemplateRef;
+        return isPreviousTemplate !== isCurrentTemplate;
+    }
+    /**
+     * 检查上下文结构是否变化
+     */
+    isContextShapeChanged(change) {
+        const prevKeys = Object.keys(change.previousValue || {});
+        const currKeys = Object.keys(change.currentValue || {});
+        if (prevKeys.length !== currKeys.length) {
+            return true;
+        }
+        return currKeys.some((key) => !prevKeys.includes(key));
+    }
+    /**
+     * 重建视图
+     */
+    recreateView() {
+        this.viewContainerRef.clear();
+        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;
+        const templateRef = isTemplateRef ? this.rkStringTemplateOutlet : this.templateRef;
+        const context = isTemplateRef ? this.rkStringTemplateOutletContext : this.context;
+        this.embeddedViewRef = this.viewContainerRef.createEmbeddedView(templateRef, context || this.context);
+    }
+    /**
+     * 更新视图上下文
+     */
+    updateContext() {
+        if (!this.embeddedViewRef) {
+            return;
+        }
+        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;
+        const newContext = isTemplateRef ? this.rkStringTemplateOutletContext : this.context;
+        const viewContext = this.embeddedViewRef.context;
+        if (newContext) {
+            Object.keys(newContext).forEach((key) => {
+                viewContext[key] = newContext[key];
+            });
+        }
+    }
 }
 RkStringTemplateOutletDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkStringTemplateOutletDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
-RkStringTemplateOutletDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: RkStringTemplateOutletDirective, selector: "[rkStringTemplateOutlet]", inputs: { rkStringTemplateOutletContext: "rkStringTemplateOutletContext", rkStringTemplateOutlet: "rkStringTemplateOutlet" }, usesOnChanges: true, ngImport: i0 });
+RkStringTemplateOutletDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: RkStringTemplateOutletDirective, selector: "[rkStringTemplateOutlet]", inputs: { rkStringTemplateOutlet: "rkStringTemplateOutlet", rkStringTemplateOutletContext: "rkStringTemplateOutletContext" }, usesOnChanges: true, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkStringTemplateOutletDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rkStringTemplateOutlet]',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { rkStringTemplateOutletContext: [{
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { rkStringTemplateOutlet: [{
                 type: Input
-            }], rkStringTemplateOutlet: [{
+            }], rkStringTemplateOutletContext: [{
                 type: Input
-            }] } });
-class RkStringTemplateOutletContext {
-}
+            }] } });
 
+/**
+ * 样式按需加载指令
+ * 在指令初始化时加载指定的样式文件，销毁时自动卸载
+ *
+ * @example
+ * ```html
+ * <!-- 加载单个样式 -->
+ * <div [rkLoadStyles]="'assets/styles/theme.css'">内容</div>
+ *
+ * <!-- 加载多个样式 -->
+ * <div [rkLoadStyles]="['assets/styles/theme.css', 'assets/styles/components.css']">内容</div>
+ *
+ * <!-- 监听加载完成事件 -->
+ * <div [rkLoadStyles]="styleUrls" (stylesLoaded)="onLoaded($event)">内容</div>
+ * ```
+ */
 class RkLoadStylesDirective {
-    constructor(styleLoader) {
-        this.styleLoader = styleLoader;
+    constructor(styleLoaderService) {
+        this.styleLoaderService = styleLoaderService;
+        this.destroy$ = new Subject();
+        this.styleUrls = [];
+        /**
+         * 样式文件路径
+         * 可以是单个路径字符串或路径数组
+         */
         this.hrefs = [];
-        // (可选) 输出加载完成事件，以便父组件可以响应
+        /**
+         * 样式加载完成事件
+         * 返回每个样式文件的加载结果
+         */
         this.stylesLoaded = new EventEmitter();
-        this.styleUrls = [];
     }
     ngOnInit() {
-        this.styleUrls = Array.isArray(this.hrefs) ? this.hrefs : [this.hrefs];
-        if (this.styleUrls.length > 0) {
-            this.subscription = this.styleLoader.load(...this.styleUrls).subscribe((results) => {
-                this.stylesLoaded.emit(results);
-            });
-        }
+        this.loadStyles();
     }
     ngOnDestroy() {
-        if (this.subscription) {
-            this.subscription.unsubscribe();
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.unloadStyles();
+    }
+    /**
+     * 加载样式文件
+     */
+    loadStyles() {
+        this.styleUrls = this.normalizeHrefs(this.hrefs);
+        if (this.styleUrls.length === 0) {
+            return;
         }
-        // 指令销毁时，自动调用 unload，服务内部会处理引用计数
+        this.styleLoaderService
+            .load(...this.styleUrls)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (results) => {
+                this.stylesLoaded.emit(results);
+                this.logLoadResults(results);
+            },
+            error: (error) => {
+                console.error('[RkLoadStyles] 样式加载失败:', error);
+            },
+        });
+    }
+    /**
+     * 卸载样式文件
+     */
+    unloadStyles() {
         if (this.styleUrls.length > 0) {
-            this.styleLoader.unload(...this.styleUrls);
+            this.styleLoaderService.unload(...this.styleUrls);
         }
     }
+    /**
+     * 标准化 hrefs 输入为数组
+     */
+    normalizeHrefs(hrefs) {
+        if (!hrefs) {
+            return [];
+        }
+        return Array.isArray(hrefs) ? hrefs : [hrefs];
+    }
+    /**
+     * 记录加载结果（仅在开发模式）
+     */
+    logLoadResults(results) {
+        // 开发模式下记录加载结果
+        results.forEach((result) => {
+            if (result.success) {
+                console.log(`[RkLoadStyles] 样式加载成功: ${result.href}`);
+            }
+            else {
+                console.error(`[RkLoadStyles] 样式加载失败: ${result.href}`, result.error);
+            }
+        });
+    }
 }
 RkLoadStylesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkLoadStylesDirective, deps: [{ token: i1.RkStyleLoaderService }], target: i0.ɵɵFactoryTarget.Directive });
 RkLoadStylesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: RkLoadStylesDirective, selector: "[rkLoadStyles]", inputs: { hrefs: ["rkLoadStyles", "hrefs"] }, outputs: { stylesLoaded: "stylesLoaded" }, ngImport: i0 });