@reskin/core 0.0.21 → 0.1.0

package/directives/string.template.outlet.directive.d.ts

@@ -1,20 +1,77 @@
 import { OnChanges, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class RkStringTemplateOutletDirective<_T = unknown> implements OnChanges {
-    private viewContainer;
+/**
+ * 字符串模板输出上下文
+ */
+export declare class RkStringTemplateOutletContext<T = any> {
+    /** 隐式上下文值 */
+    $implicit: T | 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>
+ * ```
+ */
+export declare class RkStringTemplateOutletDirective<T = unknown> implements OnChanges {
+    private viewContainerRef;
     private templateRef;
     private embeddedViewRef;
     private context;
-    rkStringTemplateOutletContext: any | null;
-    rkStringTemplateOutlet: any | TemplateRef<any>;
-    static rkTemplateContextGuard<T>(_dir: RkStringTemplateOutletDirective<T>, _ctx: any): _ctx is RkStringTemplateOutletContext;
+    /**
+     * 输出内容
+     * 可以是字符串或 TemplateRef
+     */
+    rkStringTemplateOutlet: T | TemplateRef<RkStringTemplateOutletContext<T>> | null;
+    /**
+     * 模板上下文
+     * 当 rkStringTemplateOutlet 是 TemplateRef 时使用
+     */
+    rkStringTemplateOutletContext: RkStringTemplateOutletContext<T> | null;
+    /**
+     * 类型守卫
+     * 用于 Angular 模板类型检查
+     */
+    static rkTemplateContextGuard<T>(_dir: RkStringTemplateOutletDirective<T>, _ctx: any): _ctx is RkStringTemplateOutletContext<T>;
+    constructor(viewContainerRef: ViewContainerRef, templateRef: TemplateRef<RkStringTemplateOutletContext<T>>);
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * 判断是否需要重建视图
+     */
+    private shouldRecreateView;
+    /**
+     * 检查 outlet 类型是否变化
+     */
+    private isOutletTypeChanged;
+    /**
+     * 检查上下文结构是否变化
+     */
+    private isContextShapeChanged;
+    /**
+     * 重建视图
+     */
     private recreateView;
+    /**
+     * 更新视图上下文
+     */
     private updateContext;
-    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<any>);
-    ngOnChanges(changes: SimpleChanges): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RkStringTemplateOutletDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RkStringTemplateOutletDirective<any>, "[rkStringTemplateOutlet]", never, { "rkStringTemplateOutletContext": "rkStringTemplateOutletContext"; "rkStringTemplateOutlet": "rkStringTemplateOutlet"; }, {}, never>;
-}
-export declare class RkStringTemplateOutletContext {
-    $implicit: any;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RkStringTemplateOutletDirective<any>, "[rkStringTemplateOutlet]", never, { "rkStringTemplateOutlet": "rkStringTemplateOutlet"; "rkStringTemplateOutletContext": "rkStringTemplateOutletContext"; }, {}, never>;
 }

package/esm2015/directives/auth.directive.js

@@ -1,62 +1,103 @@
 import { Directive, Input } from '@angular/core';
-import { map } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { map, takeUntil } from 'rxjs/operators';
 import * as i0 from "@angular/core";
 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>
+ * ```
+ */
 export 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;
         }));
     }
 }
@@ -74,4 +115,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             }], rkAuthElse: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.directive.js","sourceRoot":"","sources":["../../../../library/core/directives/auth.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAA4C,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;;;AAahD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,MAAM,OAAO,eAAe;IAkCxB,YACY,WAA0B,EAC1B,gBAAkC,EACnC,WAA6B;QAF5B,gBAAW,GAAX,WAAW,CAAe;QAC1B,qBAAgB,GAAhB,gBAAgB,CAAkB;QACnC,gBAAW,GAAX,WAAW,CAAkB;QApChC,cAAS,GAAsB,EAAE,CAAC;QAGzB,aAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;QAmC5C,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;IACvC,CAAC;IAlCD;;;OAGG;IACH,IACI,MAAM,CAAC,SAA4B;QACnC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,IACI,UAAU,CAAC,WAA6B;QACxC,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACnC,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,IACI,UAAU,CAAC,WAA6B;QACxC,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACnC,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAUD,WAAW;QACP,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED;;OAEG;IACK,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACjB,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC9B,OAAO;SACV;QAED,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC;aACzB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC9B,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YACnB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;IACX,CAAC;IAED;;OAEG;IACK,UAAU,CAAC,OAAsB;QACrC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAE9B,IAAI,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,eAAe,EAAE;YACxC,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;SAC3E;aAAM,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,eAAe,EAAE;YAChD,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;SAC3E;IACL,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,IAAuB;QACrC,MAAM,OAAO,GAAa,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAE9D,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,IAAI,CACtC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YACb,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC;YAErG,MAAM,OAAO,GAAkB;gBAC3B,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,IAAI;gBACvE,MAAM,EAAE,YAAY,CAAC,MAAM,GAAG,CAAC;aAClC,CAAC;YAEF,OAAO,OAAO,CAAC;QACnB,CAAC,CAAC,CACL,CAAC;IACN,CAAC;;6GA9FQ,eAAe;iGAAf,eAAe;4FAAf,eAAe;kBAH3B,SAAS;mBAAC;oBACP,QAAQ,EAAE,UAAU;iBACvB;6JAYO,MAAM;sBADT,KAAK;gBAUF,UAAU;sBADb,KAAK;gBAUF,UAAU;sBADb,KAAK","sourcesContent":["import { Directive, Input, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { map, takeUntil } from 'rxjs/operators';\r\nimport { RkMenuService } from '@reskin/core/services';\r\n\r\n/**\r\n * 权限指令上下文\r\n */\r\nexport interface RkAuthContext<T = any> {\r\n    /** 隐式上下文，包含匹配的菜单数据 */\r\n    $implicit: T;\r\n    /** 权限验证状态 */\r\n    status: boolean;\r\n}\r\n\r\n/**\r\n * 权限指令\r\n * 根据权限标识符控制模板的显示与隐藏\r\n *\r\n * @example\r\n * ```html\r\n * <!-- 基础用法 -->\r\n * <div *rkAuth=\"'user:edit'\">有编辑权限才显示</div>\r\n *\r\n * <!-- 多个权限（或关系） -->\r\n * <div *rkAuth=\"['user:edit', 'user:delete']\">有任一权限即显示</div>\r\n *\r\n * <!-- 使用 then/else 模板 -->\r\n * <ng-container *rkAuth=\"'user:edit'; then hasAuth; else noAuth\"></ng-container>\r\n * <ng-template #hasAuth let-menu>\r\n *   <p>有权限，菜单信息：{{ menu | json }}</p>\r\n * </ng-template>\r\n * <ng-template #noAuth>\r\n *   <p>无权限</p>\r\n * </ng-template>\r\n * ```\r\n */\r\n@Directive({\r\n    selector: '[rkAuth]',\r\n})\r\nexport class RkAuthDirective implements OnDestroy {\r\n    private condition: string | string[] = '';\r\n    private thenTemplateRef?: TemplateRef<any>;\r\n    private elseTemplateRef?: TemplateRef<any>;\r\n    private readonly destroy$ = new Subject<void>();\r\n\r\n    /**\r\n     * 权限标识符\r\n     * 传递多个标识符时，匹配按\"或\"运算\r\n     */\r\n    @Input()\r\n    set rkAuth(condition: string | string[]) {\r\n        this.condition = condition;\r\n        this.updateView();\r\n    }\r\n\r\n    /**\r\n     * 有权限时显示的模板\r\n     */\r\n    @Input()\r\n    set rkAuthThen(templateRef: TemplateRef<any>) {\r\n        this.thenTemplateRef = templateRef;\r\n        this.updateView();\r\n    }\r\n\r\n    /**\r\n     * 无权限时显示的模板\r\n     */\r\n    @Input()\r\n    set rkAuthElse(templateRef: TemplateRef<any>) {\r\n        this.elseTemplateRef = templateRef;\r\n        this.updateView();\r\n    }\r\n\r\n    constructor(\r\n        private menuService: RkMenuService,\r\n        private viewContainerRef: ViewContainerRef,\r\n        public templateRef: TemplateRef<any>,\r\n    ) {\r\n        this.thenTemplateRef = templateRef;\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    /**\r\n     * 更新视图显示\r\n     */\r\n    private updateView(): void {\r\n        if (!this.condition) {\r\n            this.viewContainerRef.clear();\r\n            return;\r\n        }\r\n\r\n        this.checkAuth(this.condition)\r\n            .pipe(takeUntil(this.destroy$))\r\n            .subscribe((context) => {\r\n                this.renderView(context);\r\n            });\r\n    }\r\n\r\n    /**\r\n     * 渲染视图\r\n     */\r\n    private renderView(context: RkAuthContext): void {\r\n        this.viewContainerRef.clear();\r\n\r\n        if (context.status && this.thenTemplateRef) {\r\n            this.viewContainerRef.createEmbeddedView(this.thenTemplateRef, context);\r\n        } else if (!context.status && this.elseTemplateRef) {\r\n            this.viewContainerRef.createEmbeddedView(this.elseTemplateRef, context);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 检查权限\r\n     */\r\n    private checkAuth(tags: string | string[]) {\r\n        const tagList: string[] = Array.isArray(tags) ? tags : [tags];\r\n\r\n        return this.menuService.requestData().pipe(\r\n            map((response) => {\r\n                const matchedMenus = response.data.filter((menu) => tagList.includes(menu.SYSTEM_RESOURCE_GUARD_ID));\r\n\r\n                const context: RkAuthContext = {\r\n                    $implicit: Array.isArray(tags) ? matchedMenus : matchedMenus[0] || null,\r\n                    status: matchedMenus.length > 0,\r\n                };\r\n\r\n                return context;\r\n            }),\r\n        );\r\n    }\r\n}\r\n"]}

package/esm2015/directives/load.styles.directive.js

@@ -1,31 +1,100 @@
 import { Directive, Input, Output, EventEmitter } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
 import * as i0 from "@angular/core";
 import * as i1 from "@reskin/core/services";
+/**
+ * 样式按需加载指令
+ * 在指令初始化时加载指定的样式文件，销毁时自动卸载
+ *
+ * @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>
+ * ```
+ */
 export 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 });
@@ -40,4 +109,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             }], stylesLoaded: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/directives/string.template.outlet.directive.js

@@ -1,91 +1,149 @@
 import { Directive, Input, TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 字符串模板输出上下文
+ */
+export 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>
+ * ```
+ */
 export 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
             }] } });
-export class RkStringTemplateOutletContext {
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string.template.outlet.directive.js","sourceRoot":"","sources":["../../../../library/core/directives/string.template.outlet.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EmbeddedViewRef, Input, OnChanges, SimpleChange, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';\r\n\r\n@Directive({\r\n    selector: '[rkStringTemplateOutlet]',\r\n})\r\nexport class RkStringTemplateOutletDirective<_T = unknown> implements OnChanges {\r\n    private embeddedViewRef: EmbeddedViewRef<any> | null = null;\r\n    private context = new RkStringTemplateOutletContext();\r\n    @Input() rkStringTemplateOutletContext: any | null = null;\r\n    @Input() rkStringTemplateOutlet: any | TemplateRef<any> = null;\r\n\r\n    static rkTemplateContextGuard<T>(_dir: RkStringTemplateOutletDirective<T>, _ctx: any): _ctx is RkStringTemplateOutletContext {\r\n        return true;\r\n    }\r\n\r\n    private recreateView(): void {\r\n        this.viewContainer.clear();\r\n        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;\r\n        const templateRef = (isTemplateRef ? this.rkStringTemplateOutlet : this.templateRef) as any;\r\n        this.embeddedViewRef = this.viewContainer.createEmbeddedView(\r\n            templateRef,\r\n            isTemplateRef ? this.rkStringTemplateOutletContext : this.context,\r\n        );\r\n    }\r\n\r\n    private updateContext(): void {\r\n        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;\r\n        const newCtx = isTemplateRef ? this.rkStringTemplateOutletContext : this.context;\r\n        const oldCtx = this.embeddedViewRef!.context as any;\r\n        if (newCtx) {\r\n            for (const propName of Object.keys(newCtx)) {\r\n                oldCtx[propName] = newCtx[propName];\r\n            }\r\n        }\r\n    }\r\n\r\n    constructor(\r\n        private viewContainer: ViewContainerRef,\r\n        private templateRef: TemplateRef<any>,\r\n    ) {}\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        const { rkStringTemplateOutletContext, rkStringTemplateOutlet } = changes;\r\n        const shouldRecreateView = (): boolean => {\r\n            let shouldOutletRecreate = false;\r\n            if (rkStringTemplateOutlet) {\r\n                if (rkStringTemplateOutlet.firstChange) {\r\n                    shouldOutletRecreate = true;\r\n                } else {\r\n                    const isPreviousOutletTemplate = rkStringTemplateOutlet.previousValue instanceof TemplateRef;\r\n                    const isCurrentOutletTemplate = rkStringTemplateOutlet.currentValue instanceof TemplateRef;\r\n                    shouldOutletRecreate = isPreviousOutletTemplate || isCurrentOutletTemplate;\r\n                }\r\n            }\r\n            const hasContextShapeChanged = (ctxChange: SimpleChange): boolean => {\r\n                const prevCtxKeys = Object.keys(ctxChange.previousValue || {});\r\n                const currCtxKeys = Object.keys(ctxChange.currentValue || {});\r\n                if (prevCtxKeys.length === currCtxKeys.length) {\r\n                    for (const propName of currCtxKeys) {\r\n                        if (prevCtxKeys.indexOf(propName) === -1) {\r\n                            return true;\r\n                        }\r\n                    }\r\n                    return false;\r\n                } else {\r\n                    return true;\r\n                }\r\n            };\r\n            const shouldContextRecreate = rkStringTemplateOutletContext && hasContextShapeChanged(rkStringTemplateOutletContext);\r\n            return shouldContextRecreate || shouldOutletRecreate;\r\n        };\r\n\r\n        if (rkStringTemplateOutlet) {\r\n            this.context.$implicit = rkStringTemplateOutlet.currentValue;\r\n        }\r\n\r\n        const recreateView = shouldRecreateView();\r\n        if (recreateView) {\r\n            /** recreate view when context shape or outlet change **/\r\n            this.recreateView();\r\n        } else {\r\n            /** update context **/\r\n            this.updateContext();\r\n        }\r\n    }\r\n}\r\n\r\nexport class RkStringTemplateOutletContext {\r\n    public $implicit: any;\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string.template.outlet.directive.js","sourceRoot":"","sources":["../../../../library/core/directives/string.template.outlet.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EmbeddedViewRef, Input, OnChanges, SimpleChange, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';\r\n\r\n/**\r\n * 字符串模板输出上下文\r\n */\r\nexport class RkStringTemplateOutletContext<T = any> {\r\n    /** 隐式上下文值 */\r\n    public $implicit: T | null = null;\r\n}\r\n\r\n/**\r\n * 字符串模板输出指令\r\n * 支持动态渲染字符串或 TemplateRef\r\n *\r\n * @example\r\n * ```html\r\n * <!-- 渲染字符串 -->\r\n * <ng-container *rkStringTemplateOutlet=\"'Hello World'\">\r\n *   <ng-template>默认模板</ng-template>\r\n * </ng-container>\r\n *\r\n * <!-- 渲染 TemplateRef -->\r\n * <ng-container *rkStringTemplateOutlet=\"customTemplate; context: { $implicit: data }\">\r\n * </ng-container>\r\n * <ng-template #customTemplate let-item>\r\n *   <div>{{ item }}</div>\r\n * </ng-template>\r\n *\r\n * <!-- 动态切换 -->\r\n * <ng-container *rkStringTemplateOutlet=\"isTemplate ? templateRef : 'Static Text'\">\r\n * </ng-container>\r\n * ```\r\n */\r\n@Directive({\r\n    selector: '[rkStringTemplateOutlet]',\r\n})\r\nexport class RkStringTemplateOutletDirective<T = unknown> implements OnChanges {\r\n    private embeddedViewRef: EmbeddedViewRef<RkStringTemplateOutletContext<T>> | null = null;\r\n    private context = new RkStringTemplateOutletContext<T>();\r\n\r\n    /**\r\n     * 输出内容\r\n     * 可以是字符串或 TemplateRef\r\n     */\r\n    @Input() rkStringTemplateOutlet: T | TemplateRef<RkStringTemplateOutletContext<T>> | null = null;\r\n\r\n    /**\r\n     * 模板上下文\r\n     * 当 rkStringTemplateOutlet 是 TemplateRef 时使用\r\n     */\r\n    @Input() rkStringTemplateOutletContext: RkStringTemplateOutletContext<T> | null = null;\r\n\r\n    /**\r\n     * 类型守卫\r\n     * 用于 Angular 模板类型检查\r\n     */\r\n    static rkTemplateContextGuard<T>(\r\n        _dir: RkStringTemplateOutletDirective<T>,\r\n        _ctx: any,\r\n    ): _ctx is RkStringTemplateOutletContext<T> {\r\n        return true;\r\n    }\r\n\r\n    constructor(\r\n        private viewContainerRef: ViewContainerRef,\r\n        private templateRef: TemplateRef<RkStringTemplateOutletContext<T>>,\r\n    ) {}\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        const { rkStringTemplateOutlet, rkStringTemplateOutletContext } = changes;\r\n\r\n        // 更新隐式上下文\r\n        if (rkStringTemplateOutlet) {\r\n            this.context.$implicit = rkStringTemplateOutlet.currentValue;\r\n        }\r\n\r\n        // 判断是否需要重建视图\r\n        if (this.shouldRecreateView(rkStringTemplateOutlet, rkStringTemplateOutletContext)) {\r\n            this.recreateView();\r\n        } else {\r\n            this.updateContext();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 判断是否需要重建视图\r\n     */\r\n    private shouldRecreateView(outletChange?: SimpleChange, contextChange?: SimpleChange): boolean {\r\n        // 首次变更需要创建视图\r\n        if (outletChange?.firstChange) {\r\n            return true;\r\n        }\r\n\r\n        // outlet 在 TemplateRef 和非 TemplateRef 之间切换时需要重建\r\n        if (outletChange && this.isOutletTypeChanged(outletChange)) {\r\n            return true;\r\n        }\r\n\r\n        // 上下文结构变化时需要重建\r\n        if (contextChange && this.isContextShapeChanged(contextChange)) {\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * 检查 outlet 类型是否变化\r\n     */\r\n    private isOutletTypeChanged(change: SimpleChange): boolean {\r\n        const isPreviousTemplate = change.previousValue instanceof TemplateRef;\r\n        const isCurrentTemplate = change.currentValue instanceof TemplateRef;\r\n        return isPreviousTemplate !== isCurrentTemplate;\r\n    }\r\n\r\n    /**\r\n     * 检查上下文结构是否变化\r\n     */\r\n    private isContextShapeChanged(change: SimpleChange): boolean {\r\n        const prevKeys = Object.keys(change.previousValue || {});\r\n        const currKeys = Object.keys(change.currentValue || {});\r\n\r\n        if (prevKeys.length !== currKeys.length) {\r\n            return true;\r\n        }\r\n\r\n        return currKeys.some((key) => !prevKeys.includes(key));\r\n    }\r\n\r\n    /**\r\n     * 重建视图\r\n     */\r\n    private recreateView(): void {\r\n        this.viewContainerRef.clear();\r\n\r\n        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;\r\n        const templateRef = isTemplateRef ? this.rkStringTemplateOutlet : this.templateRef;\r\n        const context = isTemplateRef ? this.rkStringTemplateOutletContext : this.context;\r\n\r\n        this.embeddedViewRef = this.viewContainerRef.createEmbeddedView(\r\n            templateRef as TemplateRef<RkStringTemplateOutletContext<T>>,\r\n            context || this.context,\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 更新视图上下文\r\n     */\r\n    private updateContext(): void {\r\n        if (!this.embeddedViewRef) {\r\n            return;\r\n        }\r\n\r\n        const isTemplateRef = this.rkStringTemplateOutlet instanceof TemplateRef;\r\n        const newContext = isTemplateRef ? this.rkStringTemplateOutletContext : this.context;\r\n        const viewContext = this.embeddedViewRef.context;\r\n\r\n        if (newContext) {\r\n            Object.keys(newContext).forEach((key) => {\r\n                (viewContext as any)[key] = (newContext as any)[key];\r\n            });\r\n        }\r\n    }\r\n}\r\n"]}