raise-common-lib-new 0.0.62 → 0.0.64

package/esm2022/lib/smart-popup/index.component.mjs

@@ -0,0 +1,1084 @@
+import { Component, EventEmitter, Input, Output, ViewChild, HostListener, } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class SmartPopupComponent {
+    ref;
+    _placement = "BottomLeft";
+    _offset = 8;
+    _autoAdjust = "yes";
+    triggerElementRef = null;
+    loading = false;
+    _open = false;
+    _width = null;
+    _height = null;
+    // 解析placement格式
+    get placementInfo() {
+        const placementMap = {
+            TopLeft: { placement: "top", position: "start" },
+            TopCenter: { placement: "top", position: "center" },
+            TopRight: { placement: "top", position: "end" },
+            BottomLeft: { placement: "bottom", position: "start" },
+            BottomCenter: { placement: "bottom", position: "center" },
+            BottomRight: { placement: "bottom", position: "end" },
+            LeftTop: { placement: "left", position: "start" },
+            LeftCenter: { placement: "left", position: "center" },
+            LeftBottom: { placement: "left", position: "end" },
+            RightTop: { placement: "right", position: "start" },
+            RightCenter: { placement: "right", position: "center" },
+            RightBottom: { placement: "right", position: "end" },
+        };
+        return (placementMap[this._placement] || {
+            placement: "bottom",
+            position: "start",
+        });
+    }
+    get offset() {
+        return this._offset || 8;
+    }
+    get autoAdjust() {
+        return this._autoAdjust === "yes";
+    }
+    openChange = new EventEmitter();
+    contentLoad = new EventEmitter();
+    internalTriggerElement;
+    popupElement;
+    currentTriggerElement = null;
+    constructor(ref) {
+        this.ref = ref;
+    }
+    ngAfterViewInit() {
+        this.fixedContainerEl = this.getFixedContainer();
+        this.fixedContainerEl.append(this.popupElement.nativeElement);
+        this.updateTriggerElement();
+        // 如果提供了固定尺寸，立即应用
+        if (this._width !== null &&
+            this._height !== null &&
+            this.popupElement &&
+            this.popupElement.nativeElement) {
+            const popupEl = this.popupElement.nativeElement;
+            popupEl.style.width = this._width + "px";
+            popupEl.style.height = this._height + "px";
+            popupEl.style.minWidth = this._width + "px";
+            popupEl.style.maxWidth = this._width + "px";
+            popupEl.style.minHeight = this._height + "px";
+            popupEl.style.maxHeight = this._height + "px";
+        }
+        // 如果外部传入 open 属性为 true，自动打开
+        if (this._open) {
+            setTimeout(() => this.open(), 0);
+        }
+    }
+    ngOnChanges(changes) {
+        // 处理固定尺寸变化
+        if ((changes._width || changes._height) &&
+            this.popupElement &&
+            this.popupElement.nativeElement) {
+            const popupEl = this.popupElement.nativeElement;
+            if (this._width !== null) {
+                popupEl.style.width = this._width + "px";
+                popupEl.style.minWidth = this._width + "px";
+                popupEl.style.maxWidth = this._width + "px";
+            }
+            if (this._height !== null) {
+                popupEl.style.height = this._height + "px";
+                popupEl.style.minHeight = this._height + "px";
+                popupEl.style.maxHeight = this._height + "px";
+            }
+        }
+        // 先处理触发元素变化（确保在打开前更新触发元素）
+        if (changes.triggerElementRef) {
+            const previousTrigger = this.currentTriggerElement;
+            this.updateTriggerElement();
+            // 如果弹窗已经打开，且触发元素发生了变化，立即更新位置
+            if (this.opened === "yes" &&
+                previousTrigger !== this.currentTriggerElement &&
+                this.currentTriggerElement) {
+                // 如果提供了固定尺寸，直接重新计算位置（避免位置跳动）
+                if (this._width !== null && this._height !== null) {
+                    // 先隐藏弹窗（positioning = yes）
+                    this.positioning = "yes";
+                    this.ref.markForCheck();
+                    this.ref.detectChanges(); // 立即应用隐藏状态
+                    requestAnimationFrame(() => {
+                        if (this.currentTriggerElement) {
+                            const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+                            const popupSize = {
+                                width: this._width,
+                                height: this._height,
+                            };
+                            const targetInfo = this.placementInfo;
+                            let finalPlacement = targetInfo.placement;
+                            const finalPosition = targetInfo.position;
+                            if (this.autoAdjust) {
+                                const popupRect = {
+                                    width: popupSize.width,
+                                    height: popupSize.height,
+                                    top: 0,
+                                    left: 0,
+                                    right: popupSize.width,
+                                    bottom: popupSize.height,
+                                    x: 0,
+                                    y: 0,
+                                    toJSON: () => ({}),
+                                };
+                                const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, window.innerWidth, window.innerHeight);
+                                finalPlacement = optimal.placement;
+                            }
+                            this.actualPlacement = finalPlacement;
+                            this.actualPosition = finalPosition;
+                            const position = this.calculatePositionCoordinates(triggerRect, finalPlacement, finalPosition, popupSize);
+                            if (this.popupElement && this.popupElement.nativeElement) {
+                                const popupEl = this.popupElement.nativeElement;
+                                popupEl.style.top = position.top;
+                                popupEl.style.left = position.left;
+                                popupEl.style.transform = `translate(${position.translateX}, ${position.translateY})`;
+                                popupEl.offsetHeight; // 强制同步应用样式
+                                // 位置设置完成后，再显示弹窗
+                                requestAnimationFrame(() => {
+                                    this.positioning = "no";
+                                    this.ref.markForCheck();
+                                });
+                            }
+                        }
+                    });
+                }
+                else {
+                    // 使用新的打开方式更新位置
+                    this.positioning = "yes";
+                    this.ref.markForCheck();
+                    requestAnimationFrame(() => {
+                        requestAnimationFrame(() => {
+                            this.updatePopupPosition();
+                            this.positioning = "no";
+                            this.ref.markForCheck();
+                        });
+                    });
+                }
+            }
+        }
+        // 处理 open 变化（确保在触发元素更新后处理）
+        if (changes._open) {
+            if (this._open && this.opened === "no") {
+                // 确保触发元素已更新
+                this.updateTriggerElement();
+                // 使用 setTimeout 确保所有变更都已处理
+                setTimeout(() => {
+                    // 再次确保触发元素已更新
+                    this.updateTriggerElement();
+                    this.open();
+                }, 0);
+            }
+            else if (!this._open && this.opened === "yes") {
+                this.close();
+            }
+        }
+        // 当加载完成时，更新位置（如果提供了固定尺寸，不需要更新位置）
+        if (changes.loading &&
+            !changes.loading.currentValue &&
+            changes.loading.previousValue) {
+            if (this.opened === "yes") {
+                // 如果提供了固定尺寸，位置已经计算好了，不需要更新
+                if (this._width !== null && this._height !== null) {
+                    this.contentLoad.emit();
+                }
+                else {
+                    // 如果正在定位，不需要更新位置
+                    if (this.positioning === "no") {
+                        requestAnimationFrame(() => {
+                            this.updatePopupPosition();
+                            this.contentLoad.emit();
+                        });
+                    }
+                    else {
+                        // 如果正在定位，等待定位完成后再触发事件
+                        const checkPositioning = () => {
+                            if (this.positioning === "no") {
+                                this.contentLoad.emit();
+                            }
+                            else {
+                                setTimeout(checkPositioning, 10);
+                            }
+                        };
+                        checkPositioning();
+                    }
+                }
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.popupElement && this.popupElement.nativeElement) {
+            this.popupElement.nativeElement.remove();
+        }
+        window.removeEventListener("click", this.onClickOutside);
+        window.removeEventListener("scroll", this.onWindowScroll, true);
+    }
+    updateTriggerElement() {
+        if (this.triggerElementRef) {
+            this.currentTriggerElement = this.triggerElementRef;
+        }
+        else if (this.internalTriggerElement &&
+            this.internalTriggerElement.nativeElement) {
+            this.currentTriggerElement = this.internalTriggerElement.nativeElement;
+        }
+        else {
+            this.currentTriggerElement = null;
+        }
+    }
+    FIXED_CONTAINER_ID = "rs-smart-popup-fixed-container";
+    fixedContainerEl;
+    getFixedContainer() {
+        let containerElement = document.getElementById(this.FIXED_CONTAINER_ID);
+        if (!containerElement) {
+            containerElement = document.createElement("div");
+            containerElement.setAttribute("id", this.FIXED_CONTAINER_ID);
+            document.body.append(containerElement);
+        }
+        return containerElement;
+    }
+    opened = "no";
+    positioning = "no";
+    actualPlacement = "bottom";
+    actualPosition = "start";
+    open(triggerElement) {
+        // 如果传入了触发元素，使用它
+        if (triggerElement) {
+            this.currentTriggerElement = triggerElement;
+        }
+        else {
+            this.updateTriggerElement();
+        }
+        if (!this.currentTriggerElement) {
+            console.warn("SmartPopupComponent: No trigger element found");
+            return;
+        }
+        // 如果已经打开，且提供了固定尺寸，直接重新计算位置（避免关闭再打开导致的跳动）
+        if (this.opened === "yes") {
+            if (this._width !== null && this._height !== null) {
+                // 有固定尺寸，直接重新计算位置，不关闭弹窗
+                // 先隐藏弹窗（positioning = yes）
+                this.positioning = "yes";
+                this.ref.markForCheck();
+                this.ref.detectChanges(); // 立即应用隐藏状态
+                requestAnimationFrame(() => {
+                    // 再次确保触发元素已更新
+                    this.updateTriggerElement();
+                    if (this.currentTriggerElement) {
+                        const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+                        const popupSize = {
+                            width: this._width,
+                            height: this._height,
+                        };
+                        const targetInfo = this.placementInfo;
+                        let finalPlacement = targetInfo.placement;
+                        const finalPosition = targetInfo.position;
+                        if (this.autoAdjust) {
+                            const popupRect = {
+                                width: popupSize.width,
+                                height: popupSize.height,
+                                top: 0,
+                                left: 0,
+                                right: popupSize.width,
+                                bottom: popupSize.height,
+                                x: 0,
+                                y: 0,
+                                toJSON: () => ({}),
+                            };
+                            const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, window.innerWidth, window.innerHeight);
+                            finalPlacement = optimal.placement;
+                        }
+                        this.actualPlacement = finalPlacement;
+                        this.actualPosition = finalPosition;
+                        const position = this.calculatePositionCoordinates(triggerRect, finalPlacement, finalPosition, popupSize);
+                        if (this.popupElement && this.popupElement.nativeElement) {
+                            const popupEl = this.popupElement.nativeElement;
+                            popupEl.style.top = position.top;
+                            popupEl.style.left = position.left;
+                            popupEl.style.transform = `translate(${position.translateX}, ${position.translateY})`;
+                            popupEl.offsetHeight; // 强制同步应用样式
+                            // 位置设置完成后，再显示弹窗
+                            requestAnimationFrame(() => {
+                                this.positioning = "no";
+                                this.ref.markForCheck();
+                            });
+                        }
+                    }
+                });
+                return;
+            }
+            else {
+                // 没有固定尺寸，先关闭再打开
+                this.opened = "no";
+                this.positioning = "no";
+                this.ref.markForCheck();
+                requestAnimationFrame(() => {
+                    this.updateTriggerElement();
+                    this.openPopup();
+                });
+                return;
+            }
+        }
+        // 确保触发元素已更新
+        this.updateTriggerElement();
+        this.openPopup();
+    }
+    openPopup() {
+        // 再次确保触发元素已更新
+        this.updateTriggerElement();
+        if (!this.currentTriggerElement) {
+            console.warn("SmartPopupComponent: No trigger element found when opening popup");
+            return;
+        }
+        // 如果提供了固定尺寸，可以在打开前就计算好位置
+        if (this._width !== null && this._height !== null) {
+            // 先计算位置（不依赖DOM渲染，直接根据triggerElement计算）
+            const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+            const viewportWidth = window.innerWidth;
+            const viewportHeight = window.innerHeight;
+            const popupSize = {
+                width: this._width,
+                height: this._height,
+            };
+            const popupRect = {
+                width: popupSize.width,
+                height: popupSize.height,
+                top: 0,
+                left: 0,
+                right: popupSize.width,
+                bottom: popupSize.height,
+                x: 0,
+                y: 0,
+                toJSON: () => ({}),
+            };
+            const targetInfo = this.placementInfo;
+            let finalPlacement = targetInfo.placement;
+            // 始终使用用户指定的 position，autoAdjust 只调整 placement（方向），不改变对齐方式
+            const finalPosition = targetInfo.position;
+            if (this.autoAdjust) {
+                const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight);
+                // autoAdjust 只调整 placement（上下左右），保持用户指定的 position（对齐方式）
+                finalPlacement = optimal.placement;
+                // finalPosition 保持用户指定的值，不改变
+            }
+            this.actualPlacement = finalPlacement;
+            this.actualPosition = finalPosition;
+            // 计算位置坐标（不依赖DOM，直接计算）
+            const position = this.calculatePositionCoordinates(triggerRect, finalPlacement, finalPosition, popupSize);
+            // 先设置打开状态，但保持隐藏（positioning = yes）
+            // 注意：先设置 positioning = yes，再设置 opened = yes，确保弹窗在位置计算完成前始终隐藏
+            this.positioning = "yes";
+            this.opened = "yes";
+            this.openChange.emit(true);
+            this.ref.markForCheck();
+            // 强制更新视图，确保DOM已更新，但弹窗仍然隐藏（因为 positioning = yes）
+            this.ref.detectChanges();
+            // 设置位置的函数
+            const setPosition = () => {
+                if (this.popupElement && this.popupElement.nativeElement) {
+                    const popupEl = this.popupElement.nativeElement;
+                    // 立即设置尺寸和位置
+                    popupEl.style.width = this._width + "px";
+                    popupEl.style.height = this._height + "px";
+                    popupEl.style.minWidth = this._width + "px";
+                    popupEl.style.maxWidth = this._width + "px";
+                    popupEl.style.minHeight = this._height + "px";
+                    popupEl.style.maxHeight = this._height + "px";
+                    popupEl.style.top = position.top;
+                    popupEl.style.left = position.left;
+                    popupEl.style.transform = `translate(${position.translateX}, ${position.translateY})`;
+                    // 强制同步应用样式，确保位置已设置
+                    popupEl.offsetHeight;
+                    // 位置设置完成后，再显示弹窗（设置 positioning = no）
+                    // 使用 requestAnimationFrame 确保样式已应用
+                    requestAnimationFrame(() => {
+                        this.positioning = "no";
+                        this.ref.markForCheck();
+                    });
+                }
+            };
+            // 如果元素已经存在，立即设置位置
+            if (this.popupElement && this.popupElement.nativeElement) {
+                setPosition();
+            }
+            else {
+                // 如果元素还不存在，等待渲染后再设置位置
+                requestAnimationFrame(() => {
+                    if (this.popupElement && this.popupElement.nativeElement) {
+                        setPosition();
+                    }
+                });
+            }
+        }
+        else {
+            // 没有固定尺寸，需要等待DOM渲染
+            this.positioning = "yes";
+            this.ref.markForCheck();
+            // 立即强制更新视图，确保DOM已更新
+            this.ref.detectChanges();
+            // 使用 requestAnimationFrame 确保在浏览器渲染之前更新位置
+            requestAnimationFrame(() => {
+                // 确保元素已渲染并获取尺寸
+                if (this.popupElement && this.popupElement.nativeElement) {
+                    // 强制重新计算布局，确保元素尺寸已计算
+                    this.popupElement.nativeElement.offsetHeight;
+                    // 计算并设置位置
+                    this.updatePopupPosition();
+                    // 位置设置完成后，移除定位状态，显示弹窗
+                    this.positioning = "no";
+                    this.ref.markForCheck();
+                }
+            });
+        }
+        window.addEventListener("click", this.onClickOutside);
+        window.addEventListener("scroll", this.onWindowScroll, true);
+    }
+    close() {
+        if (this.opened === "no") {
+            return;
+        }
+        this.opened = "no";
+        this.positioning = "no";
+        this.openChange.emit(false);
+        window.removeEventListener("click", this.onClickOutside);
+        window.removeEventListener("scroll", this.onWindowScroll, true);
+        this.ref.markForCheck();
+    }
+    toggle() {
+        if (this.opened === "yes") {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    onClickTrigger(event) {
+        event.stopPropagation();
+        this.toggle();
+    }
+    onClickOutside = (event) => {
+        const target = event.target;
+        const isClickOnTrigger = this.currentTriggerElement && this.currentTriggerElement.contains(target);
+        const isClickOnPopup = this.popupElement &&
+            this.popupElement.nativeElement &&
+            this.popupElement.nativeElement.contains(target);
+        if (!isClickOnTrigger && !isClickOnPopup) {
+            this.close();
+        }
+    };
+    onWindowScroll = (event) => {
+        if (this.opened === "yes") {
+            // 检查滚动是否发生在弹窗内部
+            const target = event.target;
+            const isScrollOnPopup = this.popupElement &&
+                this.popupElement.nativeElement &&
+                this.popupElement.nativeElement.contains(target);
+            // 如果滚动发生在弹窗内部，不更新位置（避免不必要的计算）
+            // 如果滚动发生在外部，更新位置（因为触发元素位置可能改变）
+            if (!isScrollOnPopup) {
+                this.updatePopupPosition();
+            }
+        }
+    };
+    // 处理弹窗内部的滚轮事件
+    onPopupWheel(event) {
+        // 阻止滚轮事件冒泡，避免触发外部滚动处理
+        event.stopPropagation();
+    }
+    // 处理弹窗内部的滚动事件
+    onPopupScroll(event) {
+        // 阻止滚动事件冒泡，避免触发外部滚动处理
+        event.stopPropagation();
+    }
+    // 计算并设置位置（支持固定尺寸，可在打开前调用）
+    calculateAndSetPosition() {
+        if (!this.currentTriggerElement) {
+            return;
+        }
+        const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        // 获取弹窗尺寸（优先使用固定尺寸）
+        const popupSize = {
+            width: this._width !== null
+                ? this._width
+                : this.popupElement && this.popupElement.nativeElement
+                    ? this.popupElement.nativeElement.offsetWidth
+                    : 300,
+            height: this._height !== null
+                ? this._height
+                : this.popupElement && this.popupElement.nativeElement
+                    ? this.popupElement.nativeElement.offsetHeight
+                    : 200,
+        };
+        // 创建虚拟的 popupRect（用于计算）
+        const popupRect = {
+            width: popupSize.width,
+            height: popupSize.height,
+            top: 0,
+            left: 0,
+            right: popupSize.width,
+            bottom: popupSize.height,
+            x: 0,
+            y: 0,
+            toJSON: () => ({}),
+        };
+        // 获取目标位置信息
+        const targetInfo = this.placementInfo;
+        let finalPlacement = targetInfo.placement;
+        // 始终使用用户指定的 position，autoAdjust 只调整 placement（方向），不改变对齐方式
+        const finalPosition = targetInfo.position;
+        if (this.autoAdjust) {
+            const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight);
+            // autoAdjust 只调整 placement（上下左右），保持用户指定的 position（对齐方式）
+            finalPlacement = optimal.placement;
+            // finalPosition 保持用户指定的值，不改变
+        }
+        this.actualPlacement = finalPlacement;
+        this.actualPosition = finalPosition;
+        // 立即设置位置（即使元素还没完全渲染，也要先设置位置）
+        if (this.popupElement && this.popupElement.nativeElement) {
+            this.setPopupPosition(triggerRect, popupRect, finalPlacement, finalPosition, popupSize);
+            // 强制应用样式，确保位置立即生效
+            this.ref.detectChanges();
+        }
+        else {
+            // 如果元素还不存在，延迟设置位置
+            setTimeout(() => {
+                if (this.popupElement && this.popupElement.nativeElement) {
+                    this.setPopupPosition(triggerRect, popupRect, finalPlacement, finalPosition, popupSize);
+                    this.ref.detectChanges();
+                }
+            }, 0);
+        }
+        this.ref.markForCheck();
+    }
+    updatePopupPosition() {
+        if (!this.currentTriggerElement ||
+            !this.popupElement ||
+            !this.popupElement.nativeElement) {
+            return;
+        }
+        // 如果提供了固定尺寸，使用固定尺寸计算
+        if (this._width !== null && this._height !== null) {
+            this.calculateAndSetPosition();
+            return;
+        }
+        const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+        const popupRect = this.popupElement.nativeElement.getBoundingClientRect();
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        // 获取目标位置信息
+        const targetInfo = this.placementInfo;
+        let finalPlacement = targetInfo.placement;
+        // 始终使用用户指定的 position，autoAdjust 只调整 placement（方向），不改变对齐方式
+        const finalPosition = targetInfo.position;
+        if (this.autoAdjust) {
+            const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight);
+            // autoAdjust 只调整 placement（上下左右），保持用户指定的 position（对齐方式）
+            finalPlacement = optimal.placement;
+            // finalPosition 保持用户指定的值，不改变
+        }
+        this.actualPlacement = finalPlacement;
+        this.actualPosition = finalPosition;
+        this.setPopupPosition(triggerRect, popupRect, finalPlacement, finalPosition);
+        this.ref.markForCheck();
+    }
+    calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight) {
+        const targetInfo = this.placementInfo;
+        const preferred = targetInfo.placement;
+        const preferredPosition = targetInfo.position;
+        const space = {
+            top: triggerRect.top,
+            bottom: viewportHeight - triggerRect.bottom,
+            left: triggerRect.left,
+            right: viewportWidth - triggerRect.right,
+        };
+        const popupSize = {
+            width: popupRect.width || 300,
+            height: popupRect.height || 200, // 默认高度
+        };
+        // 检查首选位置是否有足够空间
+        const hasEnoughSpace = (placement) => {
+            switch (placement) {
+                case "top":
+                    return space.top >= popupSize.height + this.offset;
+                case "bottom":
+                    return space.bottom >= popupSize.height + this.offset;
+                case "left":
+                    return space.left >= popupSize.width + this.offset;
+                case "right":
+                    return space.right >= popupSize.width + this.offset;
+            }
+        };
+        // 检查指定位置是否有足够空间
+        const checkPositionSpace = (placement, position) => {
+            if (placement === "top" || placement === "bottom") {
+                // 对于上下位置，检查水平对齐空间
+                const popupWidth = popupSize.width;
+                const spaceLeft = triggerRect.left;
+                const spaceRight = viewportWidth - triggerRect.right;
+                if (position === "center") {
+                    return spaceLeft >= popupWidth / 2 && spaceRight >= popupWidth / 2;
+                }
+                else if (position === "start") {
+                    return spaceLeft >= popupWidth;
+                }
+                else {
+                    // end
+                    return spaceRight >= popupWidth;
+                }
+            }
+            else {
+                // 对于左右位置，检查垂直对齐空间
+                const popupHeight = popupSize.height;
+                const spaceTop = triggerRect.top;
+                const spaceBottom = viewportHeight - triggerRect.bottom;
+                if (position === "center") {
+                    return spaceTop >= popupHeight / 2 && spaceBottom >= popupHeight / 2;
+                }
+                else if (position === "start") {
+                    return spaceTop >= popupHeight;
+                }
+                else {
+                    // end
+                    return spaceBottom >= popupHeight;
+                }
+            }
+        };
+        // 计算位置是否合适（考虑水平/垂直对齐）
+        const calculatePosition = (placement) => {
+            if (placement === "top" || placement === "bottom") {
+                // 对于上下位置，检查水平对齐
+                const popupWidth = popupSize.width;
+                const spaceLeft = triggerRect.left;
+                const spaceRight = viewportWidth - triggerRect.right;
+                // 优先尝试使用用户指定的position
+                if (checkPositionSpace(placement, preferredPosition)) {
+                    return preferredPosition;
+                }
+                // 如果中心对齐有足够空间，优先使用中心
+                if (spaceLeft >= popupWidth / 2 && spaceRight >= popupWidth / 2) {
+                    return "center";
+                }
+                // 如果左侧空间不足，使用右对齐
+                if (spaceLeft < popupWidth / 2) {
+                    return "end";
+                }
+                // 如果右侧空间不足，使用左对齐
+                if (spaceRight < popupWidth / 2) {
+                    return "start";
+                }
+                return preferredPosition;
+            }
+            else {
+                // 对于左右位置，检查垂直对齐
+                const popupHeight = popupSize.height;
+                const spaceTop = triggerRect.top;
+                const spaceBottom = viewportHeight - triggerRect.bottom;
+                // 优先尝试使用用户指定的position
+                if (checkPositionSpace(placement, preferredPosition)) {
+                    return preferredPosition;
+                }
+                // 如果中心对齐有足够空间，优先使用中心
+                if (spaceTop >= popupHeight / 2 && spaceBottom >= popupHeight / 2) {
+                    return "center";
+                }
+                // 如果上方空间不足，使用下对齐
+                if (spaceTop < popupHeight / 2) {
+                    return "end";
+                }
+                // 如果下方空间不足，使用上对齐
+                if (spaceBottom < popupHeight / 2) {
+                    return "start";
+                }
+                return preferredPosition;
+            }
+        };
+        // 如果首选位置有足够空间，优先使用用户指定的position
+        if (hasEnoughSpace(preferred)) {
+            // 即使指定的position空间不足，也尽量保持用户指定的position
+            // 边界约束逻辑会在 calculatePositionCoordinates 中处理位置调整
+            // 这样可以保持用户期望的对齐方式
+            return {
+                placement: preferred,
+                position: preferredPosition,
+            };
+        }
+        // 根据首选位置选择备选位置
+        const alternatives = {
+            bottom: ["top", "right", "left"],
+            top: ["bottom", "right", "left"],
+            right: ["left", "bottom", "top"],
+            left: ["right", "bottom", "top"],
+        };
+        const altList = alternatives[preferred] || [];
+        // 尝试找到第一个有足够空间的备选位置
+        for (const alt of altList) {
+            if (hasEnoughSpace(alt)) {
+                return {
+                    placement: alt,
+                    position: calculatePosition(alt),
+                };
+            }
+        }
+        // 如果都没有足够空间，选择空间最大的位置
+        const maxSpace = Math.max(space.top, space.bottom, space.left, space.right);
+        let bestPlacement;
+        if (maxSpace === space.top)
+            bestPlacement = "top";
+        else if (maxSpace === space.bottom)
+            bestPlacement = "bottom";
+        else if (maxSpace === space.left)
+            bestPlacement = "left";
+        else
+            bestPlacement = "right";
+        return {
+            placement: bestPlacement,
+            position: calculatePosition(bestPlacement),
+        };
+    }
+    // 计算位置坐标（纯计算，不依赖DOM，包含边界约束）
+    // 注意：弹窗使用 position: fixed，所以坐标应该是相对于视口的，不需要加上滚动偏移
+    calculatePositionCoordinates(triggerRect, placement, position, popupSize) {
+        const triggerWidth = triggerRect.width;
+        const triggerHeight = triggerRect.height;
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        let top = 0;
+        let left = 0;
+        let translateX = "0";
+        let translateY = "0";
+        switch (placement) {
+            case "top":
+                // 弹窗在触发元素上方
+                top = triggerRect.top - this.offset;
+                translateY = "-100%";
+                if (position === "start") {
+                    // 左对齐
+                    left = triggerRect.left;
+                    translateX = "0";
+                }
+                else if (position === "center") {
+                    // 居中对齐
+                    left = triggerRect.left + triggerWidth / 2;
+                    translateX = "-50%";
+                }
+                else {
+                    // 右对齐（end）
+                    left = triggerRect.right;
+                    translateX = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                const popupTop = top - popupSize.height;
+                if (popupTop < 0) {
+                    top = popupSize.height + 8; // 距离顶部至少8px
+                    translateY = "0"; // 取消向上偏移
+                }
+                // 水平边界约束：尽量保持原始对齐方式
+                if (position === "start") {
+                    // 左对齐：如果超出右边界，调整到右边界；如果超出左边界，调整到左边界
+                    if (left + popupSize.width > viewportWidth) {
+                        left = viewportWidth - popupSize.width - 8;
+                    }
+                    if (left < 8) {
+                        left = 8;
+                    }
+                }
+                else if (position === "center") {
+                    // 居中对齐：计算实际左边界
+                    const actualLeft = left - popupSize.width / 2;
+                    if (actualLeft < 8) {
+                        // 左边界不足，尽量保持居中，但调整到不超出左边界
+                        left = 8 + popupSize.width / 2;
+                        translateX = "-50%";
+                    }
+                    else if (actualLeft + popupSize.width > viewportWidth - 8) {
+                        // 右边界不足，尽量保持居中，但调整到不超出右边界
+                        left = viewportWidth - 8 - popupSize.width / 2;
+                        translateX = "-50%";
+                    }
+                }
+                else {
+                    // 右对齐（end）：弹窗右边缘与触发元素右边缘对齐
+                    // left 是弹窗的右边缘位置（因为 translateX = "-100%"）
+                    // 弹窗的左边缘在 left - popupSize.width
+                    const popupLeftEdge = left - popupSize.width;
+                    // 如果弹窗左边缘超出左边界，调整位置但保持右对齐
+                    if (popupLeftEdge < 8) {
+                        left = 8 + popupSize.width;
+                        translateX = "-100%";
+                    }
+                    // 如果弹窗右边缘超出右边界，调整位置但保持右对齐
+                    if (left > viewportWidth - 8) {
+                        left = viewportWidth - 8;
+                        translateX = "-100%";
+                    }
+                }
+                break;
+            case "bottom":
+                // 弹窗在触发元素下方
+                top = triggerRect.bottom + this.offset;
+                if (position === "start") {
+                    // 左对齐
+                    left = triggerRect.left;
+                    translateX = "0";
+                }
+                else if (position === "center") {
+                    // 居中对齐
+                    left = triggerRect.left + triggerWidth / 2;
+                    translateX = "-50%";
+                }
+                else {
+                    // 右对齐（end）
+                    left = triggerRect.right;
+                    translateX = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                if (top + popupSize.height > viewportHeight) {
+                    top = viewportHeight - popupSize.height - 8; // 距离底部至少8px
+                }
+                // 水平边界约束：尽量保持原始对齐方式
+                if (position === "start") {
+                    // 左对齐：如果超出右边界，调整到右边界；如果超出左边界，调整到左边界
+                    if (left + popupSize.width > viewportWidth) {
+                        left = viewportWidth - popupSize.width - 8;
+                    }
+                    if (left < 8) {
+                        left = 8;
+                    }
+                }
+                else if (position === "center") {
+                    // 居中对齐：计算实际左边界
+                    const actualLeft = left - popupSize.width / 2;
+                    if (actualLeft < 8) {
+                        // 左边界不足，尽量保持居中，但调整到不超出左边界
+                        left = 8 + popupSize.width / 2;
+                        translateX = "-50%";
+                    }
+                    else if (actualLeft + popupSize.width > viewportWidth - 8) {
+                        // 右边界不足，尽量保持居中，但调整到不超出右边界
+                        left = viewportWidth - 8 - popupSize.width / 2;
+                        translateX = "-50%";
+                    }
+                }
+                else {
+                    // 右对齐（end）：弹窗右边缘与触发元素右边缘对齐
+                    // left 是弹窗的右边缘位置（因为 translateX = "-100%"）
+                    // 弹窗的左边缘在 left - popupSize.width
+                    const popupLeftEdge = left - popupSize.width;
+                    // 优先保持与触发元素右对齐，只在必要时调整
+                    // 如果弹窗右边缘超出右边界，调整位置但保持右对齐
+                    if (left > viewportWidth - 8) {
+                        left = viewportWidth - 8;
+                        translateX = "-100%";
+                    }
+                    // 如果弹窗左边缘超出左边界，且弹窗可以完全显示在视口内，才调整位置
+                    // 这样可以确保在可能的情况下，弹窗始终与触发元素右对齐
+                    if (popupLeftEdge < 8 && popupSize.width < viewportWidth - 16) {
+                        // 只有当弹窗可以完全显示在视口内时，才调整位置
+                        // 否则保持与触发元素右对齐，即使部分超出左边界
+                        left = 8 + popupSize.width;
+                        translateX = "-100%";
+                    }
+                }
+                break;
+            case "left":
+                // 弹窗在触发元素左侧
+                left = triggerRect.left - this.offset;
+                translateX = "-100%";
+                if (position === "start") {
+                    // 上对齐
+                    top = triggerRect.top;
+                    translateY = "0";
+                }
+                else if (position === "center") {
+                    // 居中对齐
+                    top = triggerRect.top + triggerHeight / 2;
+                    translateY = "-50%";
+                }
+                else {
+                    // 下对齐（end）
+                    top = triggerRect.bottom;
+                    translateY = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                const popupLeftSide = left - popupSize.width;
+                if (popupLeftSide < 0) {
+                    left = 8; // 距离左侧至少8px
+                    translateX = "0"; // 取消向左偏移
+                }
+                // 垂直边界约束：尽量保持原始对齐方式
+                if (position === "start") {
+                    // 上对齐：如果超出下边界，调整到下边界；如果超出上边界，调整到上边界
+                    if (top + popupSize.height > viewportHeight) {
+                        top = viewportHeight - popupSize.height - 8;
+                    }
+                    if (top < 8) {
+                        top = 8;
+                    }
+                }
+                else if (position === "center") {
+                    // 居中对齐：计算实际上边界
+                    const actualTop = top - popupSize.height / 2;
+                    if (actualTop < 8) {
+                        // 上边界不足，尽量保持居中，但调整到不超出上边界
+                        top = 8 + popupSize.height / 2;
+                        translateY = "-50%";
+                    }
+                    else if (actualTop + popupSize.height > viewportHeight - 8) {
+                        // 下边界不足，尽量保持居中，但调整到不超出下边界
+                        top = viewportHeight - 8 - popupSize.height / 2;
+                        translateY = "-50%";
+                    }
+                }
+                else {
+                    // 下对齐（end）：如果超出上边界，调整到上边界；如果超出下边界，调整到下边界
+                    const actualTop = top - popupSize.height;
+                    if (actualTop < 8) {
+                        top = 8 + popupSize.height;
+                        translateY = "-100%";
+                    }
+                    if (top > viewportHeight - 8) {
+                        top = viewportHeight - 8;
+                        translateY = "-100%";
+                    }
+                }
+                break;
+            case "right":
+                // 弹窗在触发元素右侧
+                left = triggerRect.right + this.offset;
+                translateX = "0";
+                if (position === "start") {
+                    // 上对齐
+                    top = triggerRect.top;
+                    translateY = "0";
+                }
+                else if (position === "center") {
+                    // 居中对齐
+                    top = triggerRect.top + triggerHeight / 2;
+                    translateY = "-50%";
+                }
+                else {
+                    // 下对齐（end）
+                    top = triggerRect.bottom;
+                    translateY = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                if (left + popupSize.width > viewportWidth) {
+                    left = viewportWidth - popupSize.width - 8; // 距离右侧至少8px
+                }
+                // 垂直边界约束：尽量保持原始对齐方式
+                if (position === "start") {
+                    // 上对齐：如果超出下边界，调整到下边界；如果超出上边界，调整到上边界
+                    if (top + popupSize.height > viewportHeight) {
+                        top = viewportHeight - popupSize.height - 8;
+                    }
+                    if (top < 8) {
+                        top = 8;
+                    }
+                }
+                else if (position === "center") {
+                    // 居中对齐：计算实际上边界
+                    const actualTop = top - popupSize.height / 2;
+                    if (actualTop < 8) {
+                        // 上边界不足，尽量保持居中，但调整到不超出上边界
+                        top = 8 + popupSize.height / 2;
+                        translateY = "-50%";
+                    }
+                    else if (actualTop + popupSize.height > viewportHeight - 8) {
+                        // 下边界不足，尽量保持居中，但调整到不超出下边界
+                        top = viewportHeight - 8 - popupSize.height / 2;
+                        translateY = "-50%";
+                    }
+                }
+                else {
+                    // 下对齐（end）：如果超出上边界，调整到上边界；如果超出下边界，调整到下边界
+                    const actualTop = top - popupSize.height;
+                    if (actualTop < 8) {
+                        top = 8 + popupSize.height;
+                        translateY = "-100%";
+                    }
+                    if (top > viewportHeight - 8) {
+                        top = viewportHeight - 8;
+                        translateY = "-100%";
+                    }
+                }
+                break;
+        }
+        return {
+            top: top + "px",
+            left: left + "px",
+            translateX,
+            translateY,
+        };
+    }
+    setPopupPosition(triggerRect, popupRect, placement, position, popupSize) {
+        const popupEl = this.popupElement && this.popupElement.nativeElement
+            ? this.popupElement.nativeElement
+            : null;
+        if (!popupEl) {
+            return; // 如果元素还不存在，无法设置位置
+        }
+        // 优先使用传入的固定尺寸，否则从DOM获取
+        const popupWidth = popupSize && popupSize.width !== null && popupSize.width !== undefined
+            ? popupSize.width
+            : popupRect.width || popupEl.offsetWidth || 300;
+        const popupHeight = popupSize && popupSize.height !== null && popupSize.height !== undefined
+            ? popupSize.height
+            : popupRect.height || popupEl.offsetHeight || 200;
+        const coordinates = this.calculatePositionCoordinates(triggerRect, placement, position, { width: popupWidth, height: popupHeight });
+        popupEl.style.top = coordinates.top;
+        popupEl.style.left = coordinates.left;
+        popupEl.style.transform = `translate(${coordinates.translateX}, ${coordinates.translateY})`;
+    }
+    onWindowResize() {
+        if (this.opened === "yes") {
+            this.updatePopupPosition();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SmartPopupComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: SmartPopupComponent, selector: "rs-smart-popup", inputs: { _placement: ["placement", "_placement"], _offset: ["offset", "_offset"], _autoAdjust: ["autoAdjust", "_autoAdjust"], triggerElementRef: ["triggerElement", "triggerElementRef"], loading: "loading", _open: ["open", "_open"], _width: ["width", "_width"], _height: ["height", "_height"] }, outputs: { openChange: "openChange", contentLoad: "contentLoad" }, host: { listeners: { "window:resize": "onWindowResize()" } }, viewQueries: [{ propertyName: "internalTriggerElement", first: true, predicate: ["trigger"], descendants: true }, { propertyName: "popupElement", first: true, predicate: ["popup"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<!-- \u89E6\u53D1\u5143\u7D20\u63D2\u69FD -->\r\n<ng-container #trigger>\r\n  <ng-content select=\"[trigger]\"></ng-content>\r\n</ng-container>\r\n\r\n<!-- \u5F39\u7A97\u5185\u5BB9 -->\r\n<div\r\n  #popup\r\n  class=\"rs-smart-popup-content\"\r\n  [attr.data-opened]=\"opened\"\r\n  [attr.data-positioning]=\"positioning\"\r\n  (wheel)=\"onPopupWheel($event)\"\r\n  (scroll)=\"onPopupScroll($event)\"\r\n>\r\n  <div *ngIf=\"loading\" class=\"rs-smart-popup-loading\">\r\n    <div class=\"loading-spinner\"></div>\r\n  </div>\r\n  <div *ngIf=\"!loading\" class=\"rs-smart-popup-body\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n\r\n", styles: [".rs-smart-popup-trigger{display:inline-block;cursor:pointer}::ng-deep #rs-smart-popup-fixed-container{width:0;height:0;z-index:100000;pointer-events:none}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content{pointer-events:auto;position:fixed;z-index:100001;padding:8px;border-radius:8px;background:#fff;box-shadow:0 0 8px #00000040;min-width:200px;max-width:400px;max-height:500px;overflow:auto}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=no]{display:none}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=yes]{display:block}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=yes][data-positioning=yes]{display:none!important}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=yes][data-positioning=no]{display:block;visibility:visible;opacity:1;pointer-events:auto}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-loading{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:20px;min-height:100px}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-loading .loading-spinner{width:24px;height:24px;border:3px solid #f3f3f3;border-top:3px solid #3498db;border-radius:50%;animation:spin 1s linear infinite;margin-bottom:12px}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-loading .loading-text{color:#666;font-size:14px}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-body{width:100%}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SmartPopupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "rs-smart-popup", template: "<!-- \u89E6\u53D1\u5143\u7D20\u63D2\u69FD -->\r\n<ng-container #trigger>\r\n  <ng-content select=\"[trigger]\"></ng-content>\r\n</ng-container>\r\n\r\n<!-- \u5F39\u7A97\u5185\u5BB9 -->\r\n<div\r\n  #popup\r\n  class=\"rs-smart-popup-content\"\r\n  [attr.data-opened]=\"opened\"\r\n  [attr.data-positioning]=\"positioning\"\r\n  (wheel)=\"onPopupWheel($event)\"\r\n  (scroll)=\"onPopupScroll($event)\"\r\n>\r\n  <div *ngIf=\"loading\" class=\"rs-smart-popup-loading\">\r\n    <div class=\"loading-spinner\"></div>\r\n  </div>\r\n  <div *ngIf=\"!loading\" class=\"rs-smart-popup-body\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n\r\n", styles: [".rs-smart-popup-trigger{display:inline-block;cursor:pointer}::ng-deep #rs-smart-popup-fixed-container{width:0;height:0;z-index:100000;pointer-events:none}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content{pointer-events:auto;position:fixed;z-index:100001;padding:8px;border-radius:8px;background:#fff;box-shadow:0 0 8px #00000040;min-width:200px;max-width:400px;max-height:500px;overflow:auto}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=no]{display:none}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=yes]{display:block}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=yes][data-positioning=yes]{display:none!important}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content[data-opened=yes][data-positioning=no]{display:block;visibility:visible;opacity:1;pointer-events:auto}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-loading{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:20px;min-height:100px}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-loading .loading-spinner{width:24px;height:24px;border:3px solid #f3f3f3;border-top:3px solid #3498db;border-radius:50%;animation:spin 1s linear infinite;margin-bottom:12px}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-loading .loading-text{color:#666;font-size:14px}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-body{width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { _placement: [{
+                type: Input,
+                args: ["placement"]
+            }], _offset: [{
+                type: Input,
+                args: ["offset"]
+            }], _autoAdjust: [{
+                type: Input,
+                args: ["autoAdjust"]
+            }], triggerElementRef: [{
+                type: Input,
+                args: ["triggerElement"]
+            }], loading: [{
+                type: Input,
+                args: ["loading"]
+            }], _open: [{
+                type: Input,
+                args: ["open"]
+            }], _width: [{
+                type: Input,
+                args: ["width"]
+            }], _height: [{
+                type: Input,
+                args: ["height"]
+            }], openChange: [{
+                type: Output,
+                args: ["openChange"]
+            }], contentLoad: [{
+                type: Output,
+                args: ["contentLoad"]
+            }], internalTriggerElement: [{
+                type: ViewChild,
+                args: ["trigger", { static: false }]
+            }], popupElement: [{
+                type: ViewChild,
+                args: ["popup", { static: false }]
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ["window:resize"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.component.js","sourceRoot":"","sources":["../../../../../projects/raise-common-lib/src/lib/smart-popup/index.component.ts","../../../../../projects/raise-common-lib/src/lib/smart-popup/index.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterViewInit,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Input,\r\n  OnDestroy,\r\n  OnChanges,\r\n  SimpleChanges,\r\n  Output,\r\n  ViewChild,\r\n  HostListener,\r\n} from \"@angular/core\";\r\n\r\nexport type PlacementType =\r\n  | \"TopLeft\"\r\n  | \"TopCenter\"\r\n  | \"TopRight\"\r\n  | \"BottomLeft\"\r\n  | \"BottomCenter\"\r\n  | \"BottomRight\"\r\n  | \"LeftTop\"\r\n  | \"LeftCenter\"\r\n  | \"LeftBottom\"\r\n  | \"RightTop\"\r\n  | \"RightCenter\"\r\n  | \"RightBottom\";\r\n\r\n@Component({\r\n  selector: \"rs-smart-popup\",\r\n  templateUrl: \"./index.component.html\",\r\n  styleUrls: [\"./index.component.scss\"],\r\n})\r\nexport class SmartPopupComponent\r\n  implements AfterViewInit, OnDestroy, OnChanges\r\n{\r\n  @Input(\"placement\") _placement: PlacementType = \"BottomLeft\";\r\n  @Input(\"offset\") _offset: number = 8;\r\n  @Input(\"autoAdjust\") _autoAdjust: \"yes\" | \"no\" = \"yes\";\r\n  @Input(\"triggerElement\") triggerElementRef: HTMLElement | null = null;\r\n  @Input(\"loading\") loading: boolean = false;\r\n  @Input(\"open\") _open: boolean = false;\r\n  @Input(\"width\") _width: number | null = null;\r\n  @Input(\"height\") _height: number | null = null;\r\n\r\n  // 解析placement格式\r\n  get placementInfo(): {\r\n    placement: \"top\" | \"left\" | \"right\" | \"bottom\";\r\n    position: \"start\" | \"center\" | \"end\";\r\n  } {\r\n    const placementMap: {\r\n      [key: string]: {\r\n        placement: \"top\" | \"left\" | \"right\" | \"bottom\";\r\n        position: \"start\" | \"center\" | \"end\";\r\n      };\r\n    } = {\r\n      TopLeft: { placement: \"top\", position: \"start\" },\r\n      TopCenter: { placement: \"top\", position: \"center\" },\r\n      TopRight: { placement: \"top\", position: \"end\" },\r\n      BottomLeft: { placement: \"bottom\", position: \"start\" },\r\n      BottomCenter: { placement: \"bottom\", position: \"center\" },\r\n      BottomRight: { placement: \"bottom\", position: \"end\" },\r\n      LeftTop: { placement: \"left\", position: \"start\" },\r\n      LeftCenter: { placement: \"left\", position: \"center\" },\r\n      LeftBottom: { placement: \"left\", position: \"end\" },\r\n      RightTop: { placement: \"right\", position: \"start\" },\r\n      RightCenter: { placement: \"right\", position: \"center\" },\r\n      RightBottom: { placement: \"right\", position: \"end\" },\r\n    };\r\n    return (\r\n      placementMap[this._placement] || {\r\n        placement: \"bottom\",\r\n        position: \"start\",\r\n      }\r\n    );\r\n  }\r\n\r\n  get offset() {\r\n    return this._offset || 8;\r\n  }\r\n\r\n  get autoAdjust() {\r\n    return this._autoAdjust === \"yes\";\r\n  }\r\n\r\n  @Output(\"openChange\") openChange = new EventEmitter<boolean>();\r\n  @Output(\"contentLoad\") contentLoad = new EventEmitter<void>();\r\n\r\n  @ViewChild(\"trigger\", { static: false })\r\n  internalTriggerElement: ElementRef<HTMLElement>;\r\n  @ViewChild(\"popup\", { static: false })\r\n  popupElement: ElementRef<HTMLDivElement>;\r\n\r\n  currentTriggerElement: HTMLElement | null = null;\r\n\r\n  constructor(private ref: ChangeDetectorRef) {}\r\n\r\n  ngAfterViewInit() {\r\n    this.fixedContainerEl = this.getFixedContainer();\r\n    this.fixedContainerEl.append(this.popupElement.nativeElement);\r\n    this.updateTriggerElement();\r\n\r\n    // 如果提供了固定尺寸，立即应用\r\n    if (\r\n      this._width !== null &&\r\n      this._height !== null &&\r\n      this.popupElement &&\r\n      this.popupElement.nativeElement\r\n    ) {\r\n      const popupEl = this.popupElement.nativeElement;\r\n      popupEl.style.width = this._width + \"px\";\r\n      popupEl.style.height = this._height + \"px\";\r\n      popupEl.style.minWidth = this._width + \"px\";\r\n      popupEl.style.maxWidth = this._width + \"px\";\r\n      popupEl.style.minHeight = this._height + \"px\";\r\n      popupEl.style.maxHeight = this._height + \"px\";\r\n    }\r\n\r\n    // 如果外部传入 open 属性为 true，自动打开\r\n    if (this._open) {\r\n      setTimeout(() => this.open(), 0);\r\n    }\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    // 处理固定尺寸变化\r\n    if (\r\n      (changes._width || changes._height) &&\r\n      this.popupElement &&\r\n      this.popupElement.nativeElement\r\n    ) {\r\n      const popupEl = this.popupElement.nativeElement;\r\n      if (this._width !== null) {\r\n        popupEl.style.width = this._width + \"px\";\r\n        popupEl.style.minWidth = this._width + \"px\";\r\n        popupEl.style.maxWidth = this._width + \"px\";\r\n      }\r\n      if (this._height !== null) {\r\n        popupEl.style.height = this._height + \"px\";\r\n        popupEl.style.minHeight = this._height + \"px\";\r\n        popupEl.style.maxHeight = this._height + \"px\";\r\n      }\r\n    }\r\n\r\n    // 先处理触发元素变化（确保在打开前更新触发元素）\r\n    if (changes.triggerElementRef) {\r\n      const previousTrigger = this.currentTriggerElement;\r\n      this.updateTriggerElement();\r\n\r\n      // 如果弹窗已经打开，且触发元素发生了变化，立即更新位置\r\n      if (\r\n        this.opened === \"yes\" &&\r\n        previousTrigger !== this.currentTriggerElement &&\r\n        this.currentTriggerElement\r\n      ) {\r\n        // 如果提供了固定尺寸，直接重新计算位置（避免位置跳动）\r\n        if (this._width !== null && this._height !== null) {\r\n          // 先隐藏弹窗（positioning = yes）\r\n          this.positioning = \"yes\";\r\n          this.ref.markForCheck();\r\n          this.ref.detectChanges(); // 立即应用隐藏状态\r\n          \r\n          requestAnimationFrame(() => {\r\n            if (this.currentTriggerElement) {\r\n              const triggerRect = this.currentTriggerElement.getBoundingClientRect();\r\n              const popupSize = {\r\n                width: this._width!,\r\n                height: this._height!,\r\n              };\r\n              const targetInfo = this.placementInfo;\r\n              let finalPlacement = targetInfo.placement;\r\n              const finalPosition = targetInfo.position;\r\n\r\n              if (this.autoAdjust) {\r\n                const popupRect: DOMRect = {\r\n                  width: popupSize.width,\r\n                  height: popupSize.height,\r\n                  top: 0,\r\n                  left: 0,\r\n                  right: popupSize.width,\r\n                  bottom: popupSize.height,\r\n                  x: 0,\r\n                  y: 0,\r\n                  toJSON: () => ({}),\r\n                } as DOMRect;\r\n                const optimal = this.calculateOptimalPlacement(\r\n                  triggerRect,\r\n                  popupRect,\r\n                  window.innerWidth,\r\n                  window.innerHeight\r\n                );\r\n                finalPlacement = optimal.placement;\r\n              }\r\n\r\n              this.actualPlacement = finalPlacement;\r\n              this.actualPosition = finalPosition;\r\n\r\n              const position = this.calculatePositionCoordinates(\r\n                triggerRect,\r\n                finalPlacement,\r\n                finalPosition,\r\n                popupSize\r\n              );\r\n\r\n              if (this.popupElement && this.popupElement.nativeElement) {\r\n                const popupEl = this.popupElement.nativeElement;\r\n                popupEl.style.top = position.top;\r\n                popupEl.style.left = position.left;\r\n                popupEl.style.transform = `translate(${position.translateX}, ${position.translateY})`;\r\n                popupEl.offsetHeight; // 强制同步应用样式\r\n                \r\n                // 位置设置完成后，再显示弹窗\r\n                requestAnimationFrame(() => {\r\n                  this.positioning = \"no\";\r\n                  this.ref.markForCheck();\r\n                });\r\n              }\r\n            }\r\n          });\r\n        } else {\r\n          // 使用新的打开方式更新位置\r\n          this.positioning = \"yes\";\r\n          this.ref.markForCheck();\r\n          requestAnimationFrame(() => {\r\n            requestAnimationFrame(() => {\r\n              this.updatePopupPosition();\r\n              this.positioning = \"no\";\r\n              this.ref.markForCheck();\r\n            });\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    // 处理 open 变化（确保在触发元素更新后处理）\r\n    if (changes._open) {\r\n      if (this._open && this.opened === \"no\") {\r\n        // 确保触发元素已更新\r\n        this.updateTriggerElement();\r\n        // 使用 setTimeout 确保所有变更都已处理\r\n        setTimeout(() => {\r\n          // 再次确保触发元素已更新\r\n          this.updateTriggerElement();\r\n          this.open();\r\n        }, 0);\r\n      } else if (!this._open && this.opened === \"yes\") {\r\n        this.close();\r\n      }\r\n    }\r\n\r\n    // 当加载完成时，更新位置（如果提供了固定尺寸，不需要更新位置）\r\n    if (\r\n      changes.loading &&\r\n      !changes.loading.currentValue &&\r\n      changes.loading.previousValue\r\n    ) {\r\n      if (this.opened === \"yes\") {\r\n        // 如果提供了固定尺寸，位置已经计算好了，不需要更新\r\n        if (this._width !== null && this._height !== null) {\r\n          this.contentLoad.emit();\r\n        } else {\r\n          // 如果正在定位，不需要更新位置\r\n          if (this.positioning === \"no\") {\r\n            requestAnimationFrame(() => {\r\n              this.updatePopupPosition();\r\n              this.contentLoad.emit();\r\n            });\r\n          } else {\r\n            // 如果正在定位，等待定位完成后再触发事件\r\n            const checkPositioning = () => {\r\n              if (this.positioning === \"no\") {\r\n                this.contentLoad.emit();\r\n              } else {\r\n                setTimeout(checkPositioning, 10);\r\n              }\r\n            };\r\n            checkPositioning();\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    if (this.popupElement && this.popupElement.nativeElement) {\r\n      this.popupElement.nativeElement.remove();\r\n    }\r\n    window.removeEventListener(\"click\", this.onClickOutside);\r\n    window.removeEventListener(\"scroll\", this.onWindowScroll, true);\r\n  }\r\n\r\n  updateTriggerElement() {\r\n    if (this.triggerElementRef) {\r\n      this.currentTriggerElement = this.triggerElementRef;\r\n    } else if (\r\n      this.internalTriggerElement &&\r\n      this.internalTriggerElement.nativeElement\r\n    ) {\r\n      this.currentTriggerElement = this.internalTriggerElement.nativeElement;\r\n    } else {\r\n      this.currentTriggerElement = null;\r\n    }\r\n  }\r\n\r\n  FIXED_CONTAINER_ID = \"rs-smart-popup-fixed-container\";\r\n  fixedContainerEl: HTMLElement;\r\n  getFixedContainer() {\r\n    let containerElement = document.getElementById(this.FIXED_CONTAINER_ID);\r\n    if (!containerElement) {\r\n      containerElement = document.createElement(\"div\");\r\n      containerElement.setAttribute(\"id\", this.FIXED_CONTAINER_ID);\r\n      document.body.append(containerElement);\r\n    }\r\n    return containerElement;\r\n  }\r\n\r\n  opened: \"yes\" | \"no\" = \"no\";\r\n  positioning: \"yes\" | \"no\" = \"no\";\r\n  actualPlacement: \"top\" | \"left\" | \"right\" | \"bottom\" = \"bottom\";\r\n  actualPosition: \"start\" | \"center\" | \"end\" = \"start\";\r\n\r\n  open(triggerElement?: HTMLElement) {\r\n    // 如果传入了触发元素，使用它\r\n    if (triggerElement) {\r\n      this.currentTriggerElement = triggerElement;\r\n    } else {\r\n      this.updateTriggerElement();\r\n    }\r\n\r\n    if (!this.currentTriggerElement) {\r\n      console.warn(\"SmartPopupComponent: No trigger element found\");\r\n      return;\r\n    }\r\n\r\n    // 如果已经打开，且提供了固定尺寸，直接重新计算位置（避免关闭再打开导致的跳动）\r\n    if (this.opened === \"yes\") {\r\n      if (this._width !== null && this._height !== null) {\r\n        // 有固定尺寸，直接重新计算位置，不关闭弹窗\r\n        // 先隐藏弹窗（positioning = yes）\r\n        this.positioning = \"yes\";\r\n        this.ref.markForCheck();\r\n        this.ref.detectChanges(); // 立即应用隐藏状态\r\n        \r\n        requestAnimationFrame(() => {\r\n          // 再次确保触发元素已更新\r\n          this.updateTriggerElement();\r\n          if (this.currentTriggerElement) {\r\n            const triggerRect = this.currentTriggerElement.getBoundingClientRect();\r\n            const popupSize = {\r\n              width: this._width!,\r\n              height: this._height!,\r\n            };\r\n            const targetInfo = this.placementInfo;\r\n            let finalPlacement = targetInfo.placement;\r\n            const finalPosition = targetInfo.position;\r\n\r\n            if (this.autoAdjust) {\r\n              const popupRect: DOMRect = {\r\n                width: popupSize.width,\r\n                height: popupSize.height,\r\n                top: 0,\r\n                left: 0,\r\n                right: popupSize.width,\r\n                bottom: popupSize.height,\r\n                x: 0,\r\n                y: 0,\r\n                toJSON: () => ({}),\r\n              } as DOMRect;\r\n              const optimal = this.calculateOptimalPlacement(\r\n                triggerRect,\r\n                popupRect,\r\n                window.innerWidth,\r\n                window.innerHeight\r\n              );\r\n              finalPlacement = optimal.placement;\r\n            }\r\n\r\n            this.actualPlacement = finalPlacement;\r\n            this.actualPosition = finalPosition;\r\n\r\n            const position = this.calculatePositionCoordinates(\r\n              triggerRect,\r\n              finalPlacement,\r\n              finalPosition,\r\n              popupSize\r\n            );\r\n\r\n            if (this.popupElement && this.popupElement.nativeElement) {\r\n              const popupEl = this.popupElement.nativeElement;\r\n              popupEl.style.top = position.top;\r\n              popupEl.style.left = position.left;\r\n              popupEl.style.transform = `translate(${position.translateX}, ${position.translateY})`;\r\n              popupEl.offsetHeight; // 强制同步应用样式\r\n              \r\n              // 位置设置完成后，再显示弹窗\r\n              requestAnimationFrame(() => {\r\n                this.positioning = \"no\";\r\n                this.ref.markForCheck();\r\n              });\r\n            }\r\n          }\r\n        });\r\n        return;\r\n      } else {\r\n        // 没有固定尺寸，先关闭再打开\r\n        this.opened = \"no\";\r\n        this.positioning = \"no\";\r\n        this.ref.markForCheck();\r\n        requestAnimationFrame(() => {\r\n          this.updateTriggerElement();\r\n          this.openPopup();\r\n        });\r\n        return;\r\n      }\r\n    }\r\n\r\n    // 确保触发元素已更新\r\n    this.updateTriggerElement();\r\n    this.openPopup();\r\n  }\r\n\r\n  private openPopup() {\r\n    // 再次确保触发元素已更新\r\n    this.updateTriggerElement();\r\n\r\n    if (!this.currentTriggerElement) {\r\n      console.warn(\r\n        \"SmartPopupComponent: No trigger element found when opening popup\"\r\n      );\r\n      return;\r\n    }\r\n\r\n    // 如果提供了固定尺寸，可以在打开前就计算好位置\r\n    if (this._width !== null && this._height !== null) {\r\n      // 先计算位置（不依赖DOM渲染，直接根据triggerElement计算）\r\n      const triggerRect = this.currentTriggerElement.getBoundingClientRect();\r\n      const viewportWidth = window.innerWidth;\r\n      const viewportHeight = window.innerHeight;\r\n\r\n      const popupSize = {\r\n        width: this._width,\r\n        height: this._height,\r\n      };\r\n\r\n      const popupRect: DOMRect = {\r\n        width: popupSize.width,\r\n        height: popupSize.height,\r\n        top: 0,\r\n        left: 0,\r\n        right: popupSize.width,\r\n        bottom: popupSize.height,\r\n        x: 0,\r\n        y: 0,\r\n        toJSON: () => ({}),\r\n      } as DOMRect;\r\n\r\n      const targetInfo = this.placementInfo;\r\n      let finalPlacement = targetInfo.placement;\r\n      // 始终使用用户指定的 position，autoAdjust 只调整 placement（方向），不改变对齐方式\r\n      const finalPosition = targetInfo.position;\r\n\r\n      if (this.autoAdjust) {\r\n        const optimal = this.calculateOptimalPlacement(\r\n          triggerRect,\r\n          popupRect,\r\n          viewportWidth,\r\n          viewportHeight\r\n        );\r\n        // autoAdjust 只调整 placement（上下左右），保持用户指定的 position（对齐方式）\r\n        finalPlacement = optimal.placement;\r\n        // finalPosition 保持用户指定的值，不改变\r\n      }\r\n\r\n      this.actualPlacement = finalPlacement;\r\n      this.actualPosition = finalPosition;\r\n\r\n      // 计算位置坐标（不依赖DOM，直接计算）\r\n      const position = this.calculatePositionCoordinates(\r\n        triggerRect,\r\n        finalPlacement,\r\n        finalPosition,\r\n        popupSize\r\n      );\r\n\r\n      // 先设置打开状态，但保持隐藏（positioning = yes）\r\n      // 注意：先设置 positioning = yes，再设置 opened = yes，确保弹窗在位置计算完成前始终隐藏\r\n      this.positioning = \"yes\";\r\n      this.opened = \"yes\";\r\n      this.openChange.emit(true);\r\n      this.ref.markForCheck();\r\n\r\n      // 强制更新视图，确保DOM已更新，但弹窗仍然隐藏（因为 positioning = yes）\r\n      this.ref.detectChanges();\r\n\r\n      // 设置位置的函数\r\n      const setPosition = () => {\r\n        if (this.popupElement && this.popupElement.nativeElement) {\r\n          const popupEl = this.popupElement.nativeElement;\r\n\r\n          // 立即设置尺寸和位置\r\n          popupEl.style.width = this._width + \"px\";\r\n          popupEl.style.height = this._height + \"px\";\r\n          popupEl.style.minWidth = this._width + \"px\";\r\n          popupEl.style.maxWidth = this._width + \"px\";\r\n          popupEl.style.minHeight = this._height + \"px\";\r\n          popupEl.style.maxHeight = this._height + \"px\";\r\n          popupEl.style.top = position.top;\r\n          popupEl.style.left = position.left;\r\n          popupEl.style.transform = `translate(${position.translateX}, ${position.translateY})`;\r\n\r\n          // 强制同步应用样式，确保位置已设置\r\n          popupEl.offsetHeight;\r\n\r\n          // 位置设置完成后，再显示弹窗（设置 positioning = no）\r\n          // 使用 requestAnimationFrame 确保样式已应用\r\n          requestAnimationFrame(() => {\r\n            this.positioning = \"no\";\r\n            this.ref.markForCheck();\r\n          });\r\n        }\r\n      };\r\n\r\n      // 如果元素已经存在，立即设置位置\r\n      if (this.popupElement && this.popupElement.nativeElement) {\r\n        setPosition();\r\n      } else {\r\n        // 如果元素还不存在，等待渲染后再设置位置\r\n        requestAnimationFrame(() => {\r\n          if (this.popupElement && this.popupElement.nativeElement) {\r\n            setPosition();\r\n          }\r\n        });\r\n      }\r\n    } else {\r\n      // 没有固定尺寸，需要等待DOM渲染\r\n      this.positioning = \"yes\";\r\n      this.ref.markForCheck();\r\n\r\n      // 立即强制更新视图，确保DOM已更新\r\n      this.ref.detectChanges();\r\n\r\n      // 使用 requestAnimationFrame 确保在浏览器渲染之前更新位置\r\n      requestAnimationFrame(() => {\r\n        // 确保元素已渲染并获取尺寸\r\n        if (this.popupElement && this.popupElement.nativeElement) {\r\n          // 强制重新计算布局，确保元素尺寸已计算\r\n          this.popupElement.nativeElement.offsetHeight;\r\n\r\n          // 计算并设置位置\r\n          this.updatePopupPosition();\r\n\r\n          // 位置设置完成后，移除定位状态，显示弹窗\r\n          this.positioning = \"no\";\r\n          this.ref.markForCheck();\r\n        }\r\n      });\r\n    }\r\n\r\n    window.addEventListener(\"click\", this.onClickOutside);\r\n    window.addEventListener(\"scroll\", this.onWindowScroll, true);\r\n  }\r\n\r\n  close() {\r\n    if (this.opened === \"no\") {\r\n      return;\r\n    }\r\n\r\n    this.opened = \"no\";\r\n    this.positioning = \"no\";\r\n    this.openChange.emit(false);\r\n    window.removeEventListener(\"click\", this.onClickOutside);\r\n    window.removeEventListener(\"scroll\", this.onWindowScroll, true);\r\n    this.ref.markForCheck();\r\n  }\r\n\r\n  toggle() {\r\n    if (this.opened === \"yes\") {\r\n      this.close();\r\n    } else {\r\n      this.open();\r\n    }\r\n  }\r\n\r\n  onClickTrigger(event: MouseEvent) {\r\n    event.stopPropagation();\r\n    this.toggle();\r\n  }\r\n\r\n  onClickOutside = (event: MouseEvent) => {\r\n    const target = event.target as Element;\r\n    const isClickOnTrigger =\r\n      this.currentTriggerElement && this.currentTriggerElement.contains(target);\r\n    const isClickOnPopup =\r\n      this.popupElement &&\r\n      this.popupElement.nativeElement &&\r\n      this.popupElement.nativeElement.contains(target);\r\n\r\n    if (!isClickOnTrigger && !isClickOnPopup) {\r\n      this.close();\r\n    }\r\n  };\r\n\r\n  onWindowScroll = (event: Event) => {\r\n    if (this.opened === \"yes\") {\r\n      // 检查滚动是否发生在弹窗内部\r\n      const target = event.target as Element;\r\n      const isScrollOnPopup =\r\n        this.popupElement &&\r\n        this.popupElement.nativeElement &&\r\n        this.popupElement.nativeElement.contains(target);\r\n\r\n      // 如果滚动发生在弹窗内部，不更新位置（避免不必要的计算）\r\n      // 如果滚动发生在外部，更新位置（因为触发元素位置可能改变）\r\n      if (!isScrollOnPopup) {\r\n        this.updatePopupPosition();\r\n      }\r\n    }\r\n  };\r\n\r\n  // 处理弹窗内部的滚轮事件\r\n  onPopupWheel(event: WheelEvent) {\r\n    // 阻止滚轮事件冒泡，避免触发外部滚动处理\r\n    event.stopPropagation();\r\n  }\r\n\r\n  // 处理弹窗内部的滚动事件\r\n  onPopupScroll(event: Event) {\r\n    // 阻止滚动事件冒泡，避免触发外部滚动处理\r\n    event.stopPropagation();\r\n  }\r\n\r\n  // 计算并设置位置（支持固定尺寸，可在打开前调用）\r\n  private calculateAndSetPosition() {\r\n    if (!this.currentTriggerElement) {\r\n      return;\r\n    }\r\n\r\n    const triggerRect = this.currentTriggerElement.getBoundingClientRect();\r\n    const viewportWidth = window.innerWidth;\r\n    const viewportHeight = window.innerHeight;\r\n\r\n    // 获取弹窗尺寸（优先使用固定尺寸）\r\n    const popupSize = {\r\n      width:\r\n        this._width !== null\r\n          ? this._width\r\n          : this.popupElement && this.popupElement.nativeElement\r\n          ? this.popupElement.nativeElement.offsetWidth\r\n          : 300,\r\n      height:\r\n        this._height !== null\r\n          ? this._height\r\n          : this.popupElement && this.popupElement.nativeElement\r\n          ? this.popupElement.nativeElement.offsetHeight\r\n          : 200,\r\n    };\r\n\r\n    // 创建虚拟的 popupRect（用于计算）\r\n    const popupRect: DOMRect = {\r\n      width: popupSize.width,\r\n      height: popupSize.height,\r\n      top: 0,\r\n      left: 0,\r\n      right: popupSize.width,\r\n      bottom: popupSize.height,\r\n      x: 0,\r\n      y: 0,\r\n      toJSON: () => ({}),\r\n    } as DOMRect;\r\n\r\n    // 获取目标位置信息\r\n    const targetInfo = this.placementInfo;\r\n    let finalPlacement = targetInfo.placement;\r\n    // 始终使用用户指定的 position，autoAdjust 只调整 placement（方向），不改变对齐方式\r\n    const finalPosition = targetInfo.position;\r\n\r\n    if (this.autoAdjust) {\r\n      const optimal = this.calculateOptimalPlacement(\r\n        triggerRect,\r\n        popupRect,\r\n        viewportWidth,\r\n        viewportHeight\r\n      );\r\n      // autoAdjust 只调整 placement（上下左右），保持用户指定的 position（对齐方式）\r\n      finalPlacement = optimal.placement;\r\n      // finalPosition 保持用户指定的值，不改变\r\n    }\r\n\r\n    this.actualPlacement = finalPlacement;\r\n    this.actualPosition = finalPosition;\r\n\r\n    // 立即设置位置（即使元素还没完全渲染，也要先设置位置）\r\n    if (this.popupElement && this.popupElement.nativeElement) {\r\n      this.setPopupPosition(\r\n        triggerRect,\r\n        popupRect,\r\n        finalPlacement,\r\n        finalPosition,\r\n        popupSize\r\n      );\r\n      // 强制应用样式，确保位置立即生效\r\n      this.ref.detectChanges();\r\n    } else {\r\n      // 如果元素还不存在，延迟设置位置\r\n      setTimeout(() => {\r\n        if (this.popupElement && this.popupElement.nativeElement) {\r\n          this.setPopupPosition(\r\n            triggerRect,\r\n            popupRect,\r\n            finalPlacement,\r\n            finalPosition,\r\n            popupSize\r\n          );\r\n          this.ref.detectChanges();\r\n        }\r\n      }, 0);\r\n    }\r\n\r\n    this.ref.markForCheck();\r\n  }\r\n\r\n  updatePopupPosition() {\r\n    if (\r\n      !this.currentTriggerElement ||\r\n      !this.popupElement ||\r\n      !this.popupElement.nativeElement\r\n    ) {\r\n      return;\r\n    }\r\n\r\n    // 如果提供了固定尺寸，使用固定尺寸计算\r\n    if (this._width !== null && this._height !== null) {\r\n      this.calculateAndSetPosition();\r\n      return;\r\n    }\r\n\r\n    const triggerRect = this.currentTriggerElement.getBoundingClientRect();\r\n    const popupRect = this.popupElement.nativeElement.getBoundingClientRect();\r\n    const viewportWidth = window.innerWidth;\r\n    const viewportHeight = window.innerHeight;\r\n\r\n    // 获取目标位置信息\r\n    const targetInfo = this.placementInfo;\r\n    let finalPlacement = targetInfo.placement;\r\n    // 始终使用用户指定的 position，autoAdjust 只调整 placement（方向），不改变对齐方式\r\n    const finalPosition = targetInfo.position;\r\n\r\n    if (this.autoAdjust) {\r\n      const optimal = this.calculateOptimalPlacement(\r\n        triggerRect,\r\n        popupRect,\r\n        viewportWidth,\r\n        viewportHeight\r\n      );\r\n      // autoAdjust 只调整 placement（上下左右），保持用户指定的 position（对齐方式）\r\n      finalPlacement = optimal.placement;\r\n      // finalPosition 保持用户指定的值，不改变\r\n    }\r\n\r\n    this.actualPlacement = finalPlacement;\r\n    this.actualPosition = finalPosition;\r\n    this.setPopupPosition(\r\n      triggerRect,\r\n      popupRect,\r\n      finalPlacement,\r\n      finalPosition\r\n    );\r\n    this.ref.markForCheck();\r\n  }\r\n\r\n  calculateOptimalPlacement(\r\n    triggerRect: DOMRect | ClientRect,\r\n    popupRect: DOMRect | ClientRect,\r\n    viewportWidth: number,\r\n    viewportHeight: number\r\n  ): {\r\n    placement: \"top\" | \"left\" | \"right\" | \"bottom\";\r\n    position: \"start\" | \"center\" | \"end\";\r\n  } {\r\n    const targetInfo = this.placementInfo;\r\n    const preferred = targetInfo.placement;\r\n    const preferredPosition = targetInfo.position;\r\n\r\n    const space = {\r\n      top: triggerRect.top,\r\n      bottom: viewportHeight - triggerRect.bottom,\r\n      left: triggerRect.left,\r\n      right: viewportWidth - triggerRect.right,\r\n    };\r\n\r\n    const popupSize = {\r\n      width: popupRect.width || 300, // 默认宽度，如果还没有渲染\r\n      height: popupRect.height || 200, // 默认高度\r\n    };\r\n\r\n    // 检查首选位置是否有足够空间\r\n    const hasEnoughSpace = (placement: \"top\" | \"left\" | \"right\" | \"bottom\") => {\r\n      switch (placement) {\r\n        case \"top\":\r\n          return space.top >= popupSize.height + this.offset;\r\n        case \"bottom\":\r\n          return space.bottom >= popupSize.height + this.offset;\r\n        case \"left\":\r\n          return space.left >= popupSize.width + this.offset;\r\n        case \"right\":\r\n          return space.right >= popupSize.width + this.offset;\r\n      }\r\n    };\r\n\r\n    // 检查指定位置是否有足够空间\r\n    const checkPositionSpace = (\r\n      placement: \"top\" | \"left\" | \"right\" | \"bottom\",\r\n      position: \"start\" | \"center\" | \"end\"\r\n    ): boolean => {\r\n      if (placement === \"top\" || placement === \"bottom\") {\r\n        // 对于上下位置，检查水平对齐空间\r\n        const popupWidth = popupSize.width;\r\n        const spaceLeft = triggerRect.left;\r\n        const spaceRight = viewportWidth - triggerRect.right;\r\n\r\n        if (position === \"center\") {\r\n          return spaceLeft >= popupWidth / 2 && spaceRight >= popupWidth / 2;\r\n        } else if (position === \"start\") {\r\n          return spaceLeft >= popupWidth;\r\n        } else {\r\n          // end\r\n          return spaceRight >= popupWidth;\r\n        }\r\n      } else {\r\n        // 对于左右位置，检查垂直对齐空间\r\n        const popupHeight = popupSize.height;\r\n        const spaceTop = triggerRect.top;\r\n        const spaceBottom = viewportHeight - triggerRect.bottom;\r\n\r\n        if (position === \"center\") {\r\n          return spaceTop >= popupHeight / 2 && spaceBottom >= popupHeight / 2;\r\n        } else if (position === \"start\") {\r\n          return spaceTop >= popupHeight;\r\n        } else {\r\n          // end\r\n          return spaceBottom >= popupHeight;\r\n        }\r\n      }\r\n    };\r\n\r\n    // 计算位置是否合适（考虑水平/垂直对齐）\r\n    const calculatePosition = (\r\n      placement: \"top\" | \"left\" | \"right\" | \"bottom\"\r\n    ): \"start\" | \"center\" | \"end\" => {\r\n      if (placement === \"top\" || placement === \"bottom\") {\r\n        // 对于上下位置，检查水平对齐\r\n        const popupWidth = popupSize.width;\r\n        const spaceLeft = triggerRect.left;\r\n        const spaceRight = viewportWidth - triggerRect.right;\r\n\r\n        // 优先尝试使用用户指定的position\r\n        if (checkPositionSpace(placement, preferredPosition)) {\r\n          return preferredPosition;\r\n        }\r\n\r\n        // 如果中心对齐有足够空间，优先使用中心\r\n        if (spaceLeft >= popupWidth / 2 && spaceRight >= popupWidth / 2) {\r\n          return \"center\";\r\n        }\r\n        // 如果左侧空间不足，使用右对齐\r\n        if (spaceLeft < popupWidth / 2) {\r\n          return \"end\";\r\n        }\r\n        // 如果右侧空间不足，使用左对齐\r\n        if (spaceRight < popupWidth / 2) {\r\n          return \"start\";\r\n        }\r\n        return preferredPosition;\r\n      } else {\r\n        // 对于左右位置，检查垂直对齐\r\n        const popupHeight = popupSize.height;\r\n        const spaceTop = triggerRect.top;\r\n        const spaceBottom = viewportHeight - triggerRect.bottom;\r\n\r\n        // 优先尝试使用用户指定的position\r\n        if (checkPositionSpace(placement, preferredPosition)) {\r\n          return preferredPosition;\r\n        }\r\n\r\n        // 如果中心对齐有足够空间，优先使用中心\r\n        if (spaceTop >= popupHeight / 2 && spaceBottom >= popupHeight / 2) {\r\n          return \"center\";\r\n        }\r\n        // 如果上方空间不足，使用下对齐\r\n        if (spaceTop < popupHeight / 2) {\r\n          return \"end\";\r\n        }\r\n        // 如果下方空间不足，使用上对齐\r\n        if (spaceBottom < popupHeight / 2) {\r\n          return \"start\";\r\n        }\r\n        return preferredPosition;\r\n      }\r\n    };\r\n\r\n    // 如果首选位置有足够空间，优先使用用户指定的position\r\n    if (hasEnoughSpace(preferred)) {\r\n      // 即使指定的position空间不足，也尽量保持用户指定的position\r\n      // 边界约束逻辑会在 calculatePositionCoordinates 中处理位置调整\r\n      // 这样可以保持用户期望的对齐方式\r\n      return {\r\n        placement: preferred,\r\n        position: preferredPosition,\r\n      };\r\n    }\r\n\r\n    // 根据首选位置选择备选位置\r\n    const alternatives: {\r\n      [key: string]: (\"top\" | \"left\" | \"right\" | \"bottom\")[];\r\n    } = {\r\n      bottom: [\"top\", \"right\", \"left\"],\r\n      top: [\"bottom\", \"right\", \"left\"],\r\n      right: [\"left\", \"bottom\", \"top\"],\r\n      left: [\"right\", \"bottom\", \"top\"],\r\n    };\r\n\r\n    const altList = alternatives[preferred] || [];\r\n\r\n    // 尝试找到第一个有足够空间的备选位置\r\n    for (const alt of altList) {\r\n      if (hasEnoughSpace(alt)) {\r\n        return {\r\n          placement: alt,\r\n          position: calculatePosition(alt),\r\n        };\r\n      }\r\n    }\r\n\r\n    // 如果都没有足够空间，选择空间最大的位置\r\n    const maxSpace = Math.max(space.top, space.bottom, space.left, space.right);\r\n    let bestPlacement: \"top\" | \"left\" | \"right\" | \"bottom\";\r\n    if (maxSpace === space.top) bestPlacement = \"top\";\r\n    else if (maxSpace === space.bottom) bestPlacement = \"bottom\";\r\n    else if (maxSpace === space.left) bestPlacement = \"left\";\r\n    else bestPlacement = \"right\";\r\n\r\n    return {\r\n      placement: bestPlacement,\r\n      position: calculatePosition(bestPlacement),\r\n    };\r\n  }\r\n\r\n  // 计算位置坐标（纯计算，不依赖DOM，包含边界约束）\r\n  // 注意：弹窗使用 position: fixed，所以坐标应该是相对于视口的，不需要加上滚动偏移\r\n  private calculatePositionCoordinates(\r\n    triggerRect: DOMRect | ClientRect,\r\n    placement: \"top\" | \"left\" | \"right\" | \"bottom\",\r\n    position: \"start\" | \"center\" | \"end\",\r\n    popupSize: { width: number; height: number }\r\n  ): { top: string; left: string; translateX: string; translateY: string } {\r\n    const triggerWidth = triggerRect.width;\r\n    const triggerHeight = triggerRect.height;\r\n    const viewportWidth = window.innerWidth;\r\n    const viewportHeight = window.innerHeight;\r\n\r\n    let top = 0;\r\n    let left = 0;\r\n    let translateX = \"0\";\r\n    let translateY = \"0\";\r\n\r\n    switch (placement) {\r\n      case \"top\":\r\n        // 弹窗在触发元素上方\r\n        top = triggerRect.top - this.offset;\r\n        translateY = \"-100%\";\r\n        if (position === \"start\") {\r\n          // 左对齐\r\n          left = triggerRect.left;\r\n          translateX = \"0\";\r\n        } else if (position === \"center\") {\r\n          // 居中对齐\r\n          left = triggerRect.left + triggerWidth / 2;\r\n          translateX = \"-50%\";\r\n        } else {\r\n          // 右对齐（end）\r\n          left = triggerRect.right;\r\n          translateX = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        const popupTop = top - popupSize.height;\r\n        if (popupTop < 0) {\r\n          top = popupSize.height + 8; // 距离顶部至少8px\r\n          translateY = \"0\"; // 取消向上偏移\r\n        }\r\n        // 水平边界约束：尽量保持原始对齐方式\r\n        if (position === \"start\") {\r\n          // 左对齐：如果超出右边界，调整到右边界；如果超出左边界，调整到左边界\r\n          if (left + popupSize.width > viewportWidth) {\r\n            left = viewportWidth - popupSize.width - 8;\r\n          }\r\n          if (left < 8) {\r\n            left = 8;\r\n          }\r\n        } else if (position === \"center\") {\r\n          // 居中对齐：计算实际左边界\r\n          const actualLeft = left - popupSize.width / 2;\r\n          if (actualLeft < 8) {\r\n            // 左边界不足，尽量保持居中，但调整到不超出左边界\r\n            left = 8 + popupSize.width / 2;\r\n            translateX = \"-50%\";\r\n          } else if (actualLeft + popupSize.width > viewportWidth - 8) {\r\n            // 右边界不足，尽量保持居中，但调整到不超出右边界\r\n            left = viewportWidth - 8 - popupSize.width / 2;\r\n            translateX = \"-50%\";\r\n          }\r\n        } else {\r\n          // 右对齐（end）：弹窗右边缘与触发元素右边缘对齐\r\n          // left 是弹窗的右边缘位置（因为 translateX = \"-100%\"）\r\n          // 弹窗的左边缘在 left - popupSize.width\r\n          const popupLeftEdge = left - popupSize.width;\r\n          \r\n          // 如果弹窗左边缘超出左边界，调整位置但保持右对齐\r\n          if (popupLeftEdge < 8) {\r\n            left = 8 + popupSize.width;\r\n            translateX = \"-100%\";\r\n          }\r\n          // 如果弹窗右边缘超出右边界，调整位置但保持右对齐\r\n          if (left > viewportWidth - 8) {\r\n            left = viewportWidth - 8;\r\n            translateX = \"-100%\";\r\n          }\r\n        }\r\n        break;\r\n\r\n      case \"bottom\":\r\n        // 弹窗在触发元素下方\r\n        top = triggerRect.bottom + this.offset;\r\n        if (position === \"start\") {\r\n          // 左对齐\r\n          left = triggerRect.left;\r\n          translateX = \"0\";\r\n        } else if (position === \"center\") {\r\n          // 居中对齐\r\n          left = triggerRect.left + triggerWidth / 2;\r\n          translateX = \"-50%\";\r\n        } else {\r\n          // 右对齐（end）\r\n          left = triggerRect.right;\r\n          translateX = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        if (top + popupSize.height > viewportHeight) {\r\n          top = viewportHeight - popupSize.height - 8; // 距离底部至少8px\r\n        }\r\n        // 水平边界约束：尽量保持原始对齐方式\r\n        if (position === \"start\") {\r\n          // 左对齐：如果超出右边界，调整到右边界；如果超出左边界，调整到左边界\r\n          if (left + popupSize.width > viewportWidth) {\r\n            left = viewportWidth - popupSize.width - 8;\r\n          }\r\n          if (left < 8) {\r\n            left = 8;\r\n          }\r\n        } else if (position === \"center\") {\r\n          // 居中对齐：计算实际左边界\r\n          const actualLeft = left - popupSize.width / 2;\r\n          if (actualLeft < 8) {\r\n            // 左边界不足，尽量保持居中，但调整到不超出左边界\r\n            left = 8 + popupSize.width / 2;\r\n            translateX = \"-50%\";\r\n          } else if (actualLeft + popupSize.width > viewportWidth - 8) {\r\n            // 右边界不足，尽量保持居中，但调整到不超出右边界\r\n            left = viewportWidth - 8 - popupSize.width / 2;\r\n            translateX = \"-50%\";\r\n          }\r\n        } else {\r\n          // 右对齐（end）：弹窗右边缘与触发元素右边缘对齐\r\n          // left 是弹窗的右边缘位置（因为 translateX = \"-100%\"）\r\n          // 弹窗的左边缘在 left - popupSize.width\r\n          const popupLeftEdge = left - popupSize.width;\r\n          \r\n          // 优先保持与触发元素右对齐，只在必要时调整\r\n          // 如果弹窗右边缘超出右边界，调整位置但保持右对齐\r\n          if (left > viewportWidth - 8) {\r\n            left = viewportWidth - 8;\r\n            translateX = \"-100%\";\r\n          }\r\n          // 如果弹窗左边缘超出左边界，且弹窗可以完全显示在视口内，才调整位置\r\n          // 这样可以确保在可能的情况下，弹窗始终与触发元素右对齐\r\n          if (popupLeftEdge < 8 && popupSize.width < viewportWidth - 16) {\r\n            // 只有当弹窗可以完全显示在视口内时，才调整位置\r\n            // 否则保持与触发元素右对齐，即使部分超出左边界\r\n            left = 8 + popupSize.width;\r\n            translateX = \"-100%\";\r\n          }\r\n        }\r\n        break;\r\n\r\n      case \"left\":\r\n        // 弹窗在触发元素左侧\r\n        left = triggerRect.left - this.offset;\r\n        translateX = \"-100%\";\r\n        if (position === \"start\") {\r\n          // 上对齐\r\n          top = triggerRect.top;\r\n          translateY = \"0\";\r\n        } else if (position === \"center\") {\r\n          // 居中对齐\r\n          top = triggerRect.top + triggerHeight / 2;\r\n          translateY = \"-50%\";\r\n        } else {\r\n          // 下对齐（end）\r\n          top = triggerRect.bottom;\r\n          translateY = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        const popupLeftSide = left - popupSize.width;\r\n        if (popupLeftSide < 0) {\r\n          left = 8; // 距离左侧至少8px\r\n          translateX = \"0\"; // 取消向左偏移\r\n        }\r\n        // 垂直边界约束：尽量保持原始对齐方式\r\n        if (position === \"start\") {\r\n          // 上对齐：如果超出下边界，调整到下边界；如果超出上边界，调整到上边界\r\n          if (top + popupSize.height > viewportHeight) {\r\n            top = viewportHeight - popupSize.height - 8;\r\n          }\r\n          if (top < 8) {\r\n            top = 8;\r\n          }\r\n        } else if (position === \"center\") {\r\n          // 居中对齐：计算实际上边界\r\n          const actualTop = top - popupSize.height / 2;\r\n          if (actualTop < 8) {\r\n            // 上边界不足，尽量保持居中，但调整到不超出上边界\r\n            top = 8 + popupSize.height / 2;\r\n            translateY = \"-50%\";\r\n          } else if (actualTop + popupSize.height > viewportHeight - 8) {\r\n            // 下边界不足，尽量保持居中，但调整到不超出下边界\r\n            top = viewportHeight - 8 - popupSize.height / 2;\r\n            translateY = \"-50%\";\r\n          }\r\n        } else {\r\n          // 下对齐（end）：如果超出上边界，调整到上边界；如果超出下边界，调整到下边界\r\n          const actualTop = top - popupSize.height;\r\n          if (actualTop < 8) {\r\n            top = 8 + popupSize.height;\r\n            translateY = \"-100%\";\r\n          }\r\n          if (top > viewportHeight - 8) {\r\n            top = viewportHeight - 8;\r\n            translateY = \"-100%\";\r\n          }\r\n        }\r\n        break;\r\n\r\n      case \"right\":\r\n        // 弹窗在触发元素右侧\r\n        left = triggerRect.right + this.offset;\r\n        translateX = \"0\";\r\n        if (position === \"start\") {\r\n          // 上对齐\r\n          top = triggerRect.top;\r\n          translateY = \"0\";\r\n        } else if (position === \"center\") {\r\n          // 居中对齐\r\n          top = triggerRect.top + triggerHeight / 2;\r\n          translateY = \"-50%\";\r\n        } else {\r\n          // 下对齐（end）\r\n          top = triggerRect.bottom;\r\n          translateY = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        if (left + popupSize.width > viewportWidth) {\r\n          left = viewportWidth - popupSize.width - 8; // 距离右侧至少8px\r\n        }\r\n        // 垂直边界约束：尽量保持原始对齐方式\r\n        if (position === \"start\") {\r\n          // 上对齐：如果超出下边界，调整到下边界；如果超出上边界，调整到上边界\r\n          if (top + popupSize.height > viewportHeight) {\r\n            top = viewportHeight - popupSize.height - 8;\r\n          }\r\n          if (top < 8) {\r\n            top = 8;\r\n          }\r\n        } else if (position === \"center\") {\r\n          // 居中对齐：计算实际上边界\r\n          const actualTop = top - popupSize.height / 2;\r\n          if (actualTop < 8) {\r\n            // 上边界不足，尽量保持居中，但调整到不超出上边界\r\n            top = 8 + popupSize.height / 2;\r\n            translateY = \"-50%\";\r\n          } else if (actualTop + popupSize.height > viewportHeight - 8) {\r\n            // 下边界不足，尽量保持居中，但调整到不超出下边界\r\n            top = viewportHeight - 8 - popupSize.height / 2;\r\n            translateY = \"-50%\";\r\n          }\r\n        } else {\r\n          // 下对齐（end）：如果超出上边界，调整到上边界；如果超出下边界，调整到下边界\r\n          const actualTop = top - popupSize.height;\r\n          if (actualTop < 8) {\r\n            top = 8 + popupSize.height;\r\n            translateY = \"-100%\";\r\n          }\r\n          if (top > viewportHeight - 8) {\r\n            top = viewportHeight - 8;\r\n            translateY = \"-100%\";\r\n          }\r\n        }\r\n        break;\r\n    }\r\n\r\n    return {\r\n      top: top + \"px\",\r\n      left: left + \"px\",\r\n      translateX,\r\n      translateY,\r\n    };\r\n  }\r\n\r\n  setPopupPosition(\r\n    triggerRect: DOMRect | ClientRect,\r\n    popupRect: DOMRect | ClientRect,\r\n    placement: \"top\" | \"left\" | \"right\" | \"bottom\",\r\n    position: \"start\" | \"center\" | \"end\",\r\n    popupSize?: { width: number; height: number }\r\n  ) {\r\n    const popupEl =\r\n      this.popupElement && this.popupElement.nativeElement\r\n        ? this.popupElement.nativeElement\r\n        : null;\r\n    if (!popupEl) {\r\n      return; // 如果元素还不存在，无法设置位置\r\n    }\r\n\r\n    // 优先使用传入的固定尺寸，否则从DOM获取\r\n    const popupWidth =\r\n      popupSize && popupSize.width !== null && popupSize.width !== undefined\r\n        ? popupSize.width\r\n        : popupRect.width || popupEl.offsetWidth || 300;\r\n    const popupHeight =\r\n      popupSize && popupSize.height !== null && popupSize.height !== undefined\r\n        ? popupSize.height\r\n        : popupRect.height || popupEl.offsetHeight || 200;\r\n\r\n    const coordinates = this.calculatePositionCoordinates(\r\n      triggerRect,\r\n      placement,\r\n      position,\r\n      { width: popupWidth, height: popupHeight }\r\n    );\r\n\r\n    popupEl.style.top = coordinates.top;\r\n    popupEl.style.left = coordinates.left;\r\n    popupEl.style.transform = `translate(${coordinates.translateX}, ${coordinates.translateY})`;\r\n  }\r\n\r\n  @HostListener(\"window:resize\")\r\n  onWindowResize() {\r\n    if (this.opened === \"yes\") {\r\n      this.updatePopupPosition();\r\n    }\r\n  }\r\n}\r\n","<!-- 触发元素插槽 -->\r\n<ng-container #trigger>\r\n  <ng-content select=\"[trigger]\"></ng-content>\r\n</ng-container>\r\n\r\n<!-- 弹窗内容 -->\r\n<div\r\n  #popup\r\n  class=\"rs-smart-popup-content\"\r\n  [attr.data-opened]=\"opened\"\r\n  [attr.data-positioning]=\"positioning\"\r\n  (wheel)=\"onPopupWheel($event)\"\r\n  (scroll)=\"onPopupScroll($event)\"\r\n>\r\n  <div *ngIf=\"loading\" class=\"rs-smart-popup-loading\">\r\n    <div class=\"loading-spinner\"></div>\r\n  </div>\r\n  <div *ngIf=\"!loading\" class=\"rs-smart-popup-body\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n\r\n"]}