raise-common-lib 0.0.217 → 0.0.219

package/esm2015/lib/smart-popup/index.component.js

@@ -0,0 +1,1089 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/smart-popup/index.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { ChangeDetectorRef, Component, ElementRef, EventEmitter, Input, Output, ViewChild, HostListener, } from "@angular/core";
+export class SmartPopupComponent {
+    /**
+     * @param {?} ref
+     */
+    constructor(ref) {
+        this.ref = ref;
+        this._placement = "BottomLeft";
+        this._offset = 8;
+        this._autoAdjust = "yes";
+        this.triggerElementRef = null;
+        this.loading = false;
+        this._open = false;
+        this._width = null;
+        this._height = null;
+        this.openChange = new EventEmitter();
+        this.contentLoad = new EventEmitter();
+        this.currentTriggerElement = null;
+        this.FIXED_CONTAINER_ID = "rs-smart-popup-fixed-container";
+        this.opened = "no";
+        this.positioning = "no";
+        this.actualPlacement = "bottom";
+        this.actualPosition = "start";
+        this.onClickOutside = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        (event) => {
+            /** @type {?} */
+            const target = (/** @type {?} */ (event.target));
+            /** @type {?} */
+            const isClickOnTrigger = this.currentTriggerElement && this.currentTriggerElement.contains(target);
+            /** @type {?} */
+            const isClickOnPopup = this.popupElement &&
+                this.popupElement.nativeElement &&
+                this.popupElement.nativeElement.contains(target);
+            if (!isClickOnTrigger && !isClickOnPopup) {
+                this.close();
+            }
+        });
+        this.onWindowScroll = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        (event) => {
+            if (this.opened === "yes") {
+                // 检查滚动是否发生在弹窗内部
+                /** @type {?} */
+                const target = (/** @type {?} */ (event.target));
+                /** @type {?} */
+                const isScrollOnPopup = this.popupElement &&
+                    this.popupElement.nativeElement &&
+                    this.popupElement.nativeElement.contains(target);
+                // 如果滚动发生在弹窗内部，不更新位置（避免不必要的计算）
+                // 如果滚动发生在外部，更新位置（因为触发元素位置可能改变）
+                if (!isScrollOnPopup) {
+                    this.updatePopupPosition();
+                }
+            }
+        });
+    }
+    // 解析placement格式
+    /**
+     * @return {?}
+     */
+    get placementInfo() {
+        /** @type {?} */
+        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",
+        });
+    }
+    /**
+     * @return {?}
+     */
+    get offset() {
+        return this._offset || 8;
+    }
+    /**
+     * @return {?}
+     */
+    get autoAdjust() {
+        return this._autoAdjust === "yes";
+    }
+    /**
+     * @return {?}
+     */
+    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) {
+            /** @type {?} */
+            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((/**
+             * @return {?}
+             */
+            () => this.open()), 0);
+        }
+    }
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    ngOnChanges(changes) {
+        // 处理固定尺寸变化
+        if ((changes._width || changes._height) &&
+            this.popupElement &&
+            this.popupElement.nativeElement) {
+            /** @type {?} */
+            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) {
+            /** @type {?} */
+            const previousTrigger = this.currentTriggerElement;
+            this.updateTriggerElement();
+            // 如果弹窗已经打开，且触发元素发生了变化，立即更新位置
+            if (this.opened === "yes" &&
+                previousTrigger !== this.currentTriggerElement &&
+                this.currentTriggerElement) {
+                // 使用新的打开方式更新位置
+                this.positioning = "yes";
+                this.ref.markForCheck();
+                requestAnimationFrame((/**
+                 * @return {?}
+                 */
+                () => {
+                    requestAnimationFrame((/**
+                     * @return {?}
+                     */
+                    () => {
+                        this.updatePopupPosition();
+                        this.positioning = "no";
+                        this.ref.markForCheck();
+                    }));
+                }));
+            }
+        }
+        // 处理 open 变化（确保在触发元素更新后处理）
+        if (changes._open) {
+            if (this._open && this.opened === "no") {
+                // 确保触发元素已更新
+                this.updateTriggerElement();
+                // 使用 setTimeout 确保所有变更都已处理
+                setTimeout((/**
+                 * @return {?}
+                 */
+                () => {
+                    // 再次确保触发元素已更新
+                    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((/**
+                         * @return {?}
+                         */
+                        () => {
+                            this.updatePopupPosition();
+                            this.contentLoad.emit();
+                        }));
+                    }
+                    else {
+                        // 如果正在定位，等待定位完成后再触发事件
+                        /** @type {?} */
+                        const checkPositioning = (/**
+                         * @return {?}
+                         */
+                        () => {
+                            if (this.positioning === "no") {
+                                this.contentLoad.emit();
+                            }
+                            else {
+                                setTimeout(checkPositioning, 10);
+                            }
+                        });
+                        checkPositioning();
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        if (this.popupElement && this.popupElement.nativeElement) {
+            this.popupElement.nativeElement.remove();
+        }
+        window.removeEventListener("click", this.onClickOutside);
+        window.removeEventListener("scroll", this.onWindowScroll, true);
+    }
+    /**
+     * @return {?}
+     */
+    updateTriggerElement() {
+        if (this.triggerElementRef) {
+            this.currentTriggerElement = this.triggerElementRef;
+        }
+        else if (this.internalTriggerElement &&
+            this.internalTriggerElement.nativeElement) {
+            this.currentTriggerElement = this.internalTriggerElement.nativeElement;
+        }
+        else {
+            this.currentTriggerElement = null;
+        }
+    }
+    /**
+     * @return {?}
+     */
+    getFixedContainer() {
+        /** @type {?} */
+        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;
+    }
+    /**
+     * @param {?=} triggerElement
+     * @return {?}
+     */
+    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") {
+            // 先关闭弹窗
+            this.opened = "no";
+            this.positioning = "no";
+            this.ref.markForCheck();
+            // 立即在新位置打开
+            requestAnimationFrame((/**
+             * @return {?}
+             */
+            () => {
+                // 再次确保触发元素已更新
+                this.updateTriggerElement();
+                this.openPopup();
+            }));
+            return;
+        }
+        // 确保触发元素已更新
+        this.updateTriggerElement();
+        this.openPopup();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    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计算）
+            /** @type {?} */
+            const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+            /** @type {?} */
+            const viewportWidth = window.innerWidth;
+            /** @type {?} */
+            const viewportHeight = window.innerHeight;
+            /** @type {?} */
+            const popupSize = {
+                width: this._width,
+                height: this._height,
+            };
+            /** @type {?} */
+            const popupRect = (/** @type {?} */ ({
+                width: popupSize.width,
+                height: popupSize.height,
+                top: 0,
+                left: 0,
+                right: popupSize.width,
+                bottom: popupSize.height,
+                x: 0,
+                y: 0,
+                toJSON: (/**
+                 * @return {?}
+                 */
+                () => ({})),
+            }));
+            /** @type {?} */
+            const targetInfo = this.placementInfo;
+            /** @type {?} */
+            let finalPlacement = targetInfo.placement;
+            /** @type {?} */
+            let finalPosition = targetInfo.position;
+            if (this.autoAdjust) {
+                /** @type {?} */
+                const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight);
+                finalPlacement = optimal.placement;
+                finalPosition = optimal.position;
+            }
+            this.actualPlacement = finalPlacement;
+            this.actualPosition = finalPosition;
+            // 计算位置坐标（不依赖DOM，直接计算）
+            /** @type {?} */
+            const position = this.calculatePositionCoordinates(triggerRect, finalPlacement, finalPosition, popupSize);
+            // 先设置打开状态，但保持隐藏（positioning = yes）
+            this.opened = "yes";
+            this.positioning = "yes";
+            this.openChange.emit(true);
+            this.ref.markForCheck();
+            // 强制更新视图，确保DOM已更新
+            this.ref.detectChanges();
+            // 如果元素已经存在，立即设置位置（不等待 requestAnimationFrame）
+            if (this.popupElement && this.popupElement.nativeElement) {
+                /** @type {?} */
+                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;
+                // 位置设置完成后，立即显示弹窗
+                this.positioning = "no";
+                this.ref.markForCheck();
+            }
+            else {
+                // 如果元素还不存在，等待渲染
+                requestAnimationFrame((/**
+                 * @return {?}
+                 */
+                () => {
+                    if (this.popupElement && this.popupElement.nativeElement) {
+                        /** @type {?} */
+                        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;
+                        // 位置设置完成后，立即显示弹窗
+                        this.positioning = "no";
+                        this.ref.markForCheck();
+                    }
+                }));
+            }
+        }
+        else {
+            // 没有固定尺寸，需要等待DOM渲染
+            this.positioning = "yes";
+            this.ref.markForCheck();
+            // 立即强制更新视图，确保DOM已更新
+            this.ref.detectChanges();
+            // 使用 requestAnimationFrame 确保在浏览器渲染之前更新位置
+            requestAnimationFrame((/**
+             * @return {?}
+             */
+            () => {
+                // 确保元素已渲染并获取尺寸
+                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);
+    }
+    /**
+     * @return {?}
+     */
+    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();
+    }
+    /**
+     * @return {?}
+     */
+    toggle() {
+        if (this.opened === "yes") {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onClickTrigger(event) {
+        event.stopPropagation();
+        this.toggle();
+    }
+    // 处理弹窗内部的滚轮事件
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onPopupWheel(event) {
+        // 阻止滚轮事件冒泡，避免触发外部滚动处理
+        event.stopPropagation();
+    }
+    // 处理弹窗内部的滚动事件
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onPopupScroll(event) {
+        // 阻止滚动事件冒泡，避免触发外部滚动处理
+        event.stopPropagation();
+    }
+    // 计算并设置位置（支持固定尺寸，可在打开前调用）
+    /**
+     * @private
+     * @return {?}
+     */
+    calculateAndSetPosition() {
+        if (!this.currentTriggerElement) {
+            return;
+        }
+        /** @type {?} */
+        const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+        /** @type {?} */
+        const viewportWidth = window.innerWidth;
+        /** @type {?} */
+        const viewportHeight = window.innerHeight;
+        // 获取弹窗尺寸（优先使用固定尺寸）
+        /** @type {?} */
+        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（用于计算）
+        /** @type {?} */
+        const popupRect = (/** @type {?} */ ({
+            width: popupSize.width,
+            height: popupSize.height,
+            top: 0,
+            left: 0,
+            right: popupSize.width,
+            bottom: popupSize.height,
+            x: 0,
+            y: 0,
+            toJSON: (/**
+             * @return {?}
+             */
+            () => ({})),
+        }));
+        // 获取目标位置信息
+        /** @type {?} */
+        const targetInfo = this.placementInfo;
+        /** @type {?} */
+        let finalPlacement = targetInfo.placement;
+        /** @type {?} */
+        let finalPosition = targetInfo.position;
+        if (this.autoAdjust) {
+            /** @type {?} */
+            const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight);
+            finalPlacement = optimal.placement;
+            finalPosition = optimal.position;
+        }
+        this.actualPlacement = finalPlacement;
+        this.actualPosition = finalPosition;
+        // 立即设置位置（即使元素还没完全渲染，也要先设置位置）
+        if (this.popupElement && this.popupElement.nativeElement) {
+            this.setPopupPosition(triggerRect, popupRect, finalPlacement, finalPosition, popupSize);
+            // 强制应用样式，确保位置立即生效
+            this.ref.detectChanges();
+        }
+        else {
+            // 如果元素还不存在，延迟设置位置
+            setTimeout((/**
+             * @return {?}
+             */
+            () => {
+                if (this.popupElement && this.popupElement.nativeElement) {
+                    this.setPopupPosition(triggerRect, popupRect, finalPlacement, finalPosition, popupSize);
+                    this.ref.detectChanges();
+                }
+            }), 0);
+        }
+        this.ref.markForCheck();
+    }
+    /**
+     * @return {?}
+     */
+    updatePopupPosition() {
+        if (!this.currentTriggerElement ||
+            !this.popupElement ||
+            !this.popupElement.nativeElement) {
+            return;
+        }
+        // 如果提供了固定尺寸，使用固定尺寸计算
+        if (this._width !== null && this._height !== null) {
+            this.calculateAndSetPosition();
+            return;
+        }
+        /** @type {?} */
+        const triggerRect = this.currentTriggerElement.getBoundingClientRect();
+        /** @type {?} */
+        const popupRect = this.popupElement.nativeElement.getBoundingClientRect();
+        /** @type {?} */
+        const viewportWidth = window.innerWidth;
+        /** @type {?} */
+        const viewportHeight = window.innerHeight;
+        // 获取目标位置信息
+        /** @type {?} */
+        const targetInfo = this.placementInfo;
+        /** @type {?} */
+        let finalPlacement = targetInfo.placement;
+        /** @type {?} */
+        let finalPosition = targetInfo.position;
+        if (this.autoAdjust) {
+            /** @type {?} */
+            const optimal = this.calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight);
+            finalPlacement = optimal.placement;
+            finalPosition = optimal.position;
+        }
+        this.actualPlacement = finalPlacement;
+        this.actualPosition = finalPosition;
+        this.setPopupPosition(triggerRect, popupRect, finalPlacement, finalPosition);
+        this.ref.markForCheck();
+    }
+    /**
+     * @param {?} triggerRect
+     * @param {?} popupRect
+     * @param {?} viewportWidth
+     * @param {?} viewportHeight
+     * @return {?}
+     */
+    calculateOptimalPlacement(triggerRect, popupRect, viewportWidth, viewportHeight) {
+        /** @type {?} */
+        const targetInfo = this.placementInfo;
+        /** @type {?} */
+        const preferred = targetInfo.placement;
+        /** @type {?} */
+        const preferredPosition = targetInfo.position;
+        /** @type {?} */
+        const space = {
+            top: triggerRect.top,
+            bottom: viewportHeight - triggerRect.bottom,
+            left: triggerRect.left,
+            right: viewportWidth - triggerRect.right,
+        };
+        /** @type {?} */
+        const popupSize = {
+            width: popupRect.width || 300,
+            // 默认宽度，如果还没有渲染
+            height: popupRect.height || 200,
+        };
+        // 检查首选位置是否有足够空间
+        /** @type {?} */
+        const hasEnoughSpace = (/**
+         * @param {?} placement
+         * @return {?}
+         */
+        (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;
+            }
+        });
+        // 检查指定位置是否有足够空间
+        /** @type {?} */
+        const checkPositionSpace = (/**
+         * @param {?} placement
+         * @param {?} position
+         * @return {?}
+         */
+        (placement, position) => {
+            if (placement === "top" || placement === "bottom") {
+                // 对于上下位置，检查水平对齐空间
+                /** @type {?} */
+                const popupWidth = popupSize.width;
+                /** @type {?} */
+                const spaceLeft = triggerRect.left;
+                /** @type {?} */
+                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 {
+                // 对于左右位置，检查垂直对齐空间
+                /** @type {?} */
+                const popupHeight = popupSize.height;
+                /** @type {?} */
+                const spaceTop = triggerRect.top;
+                /** @type {?} */
+                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;
+                }
+            }
+        });
+        // 计算位置是否合适（考虑水平/垂直对齐）
+        /** @type {?} */
+        const calculatePosition = (/**
+         * @param {?} placement
+         * @return {?}
+         */
+        (placement) => {
+            if (placement === "top" || placement === "bottom") {
+                // 对于上下位置，检查水平对齐
+                /** @type {?} */
+                const popupWidth = popupSize.width;
+                /** @type {?} */
+                const spaceLeft = triggerRect.left;
+                /** @type {?} */
+                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 {
+                // 对于左右位置，检查垂直对齐
+                /** @type {?} */
+                const popupHeight = popupSize.height;
+                /** @type {?} */
+                const spaceTop = triggerRect.top;
+                /** @type {?} */
+                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是否有足够空间
+            if (checkPositionSpace(preferred, preferredPosition)) {
+                return {
+                    placement: preferred,
+                    position: preferredPosition,
+                };
+            }
+            // 如果指定的position空间不足，自动计算最佳position
+            return {
+                placement: preferred,
+                position: calculatePosition(preferred),
+            };
+        }
+        // 根据首选位置选择备选位置
+        /** @type {?} */
+        const alternatives = {
+            bottom: ["top", "right", "left"],
+            top: ["bottom", "right", "left"],
+            right: ["left", "bottom", "top"],
+            left: ["right", "bottom", "top"],
+        };
+        /** @type {?} */
+        const altList = alternatives[preferred] || [];
+        // 尝试找到第一个有足够空间的备选位置
+        for (const alt of altList) {
+            if (hasEnoughSpace(alt)) {
+                return {
+                    placement: alt,
+                    position: calculatePosition(alt),
+                };
+            }
+        }
+        // 如果都没有足够空间，选择空间最大的位置
+        /** @type {?} */
+        const maxSpace = Math.max(space.top, space.bottom, space.left, space.right);
+        /** @type {?} */
+        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，包含边界约束）
+    /**
+     * @private
+     * @param {?} triggerRect
+     * @param {?} placement
+     * @param {?} position
+     * @param {?} popupSize
+     * @return {?}
+     */
+    calculatePositionCoordinates(triggerRect, placement, position, popupSize) {
+        /** @type {?} */
+        const triggerWidth = triggerRect.width;
+        /** @type {?} */
+        const triggerHeight = triggerRect.height;
+        /** @type {?} */
+        const viewportWidth = window.innerWidth;
+        /** @type {?} */
+        const viewportHeight = window.innerHeight;
+        /** @type {?} */
+        const scrollX = window.scrollX;
+        /** @type {?} */
+        const scrollY = window.scrollY;
+        /** @type {?} */
+        let top = 0;
+        /** @type {?} */
+        let left = 0;
+        /** @type {?} */
+        let translateX = "0";
+        /** @type {?} */
+        let translateY = "0";
+        switch (placement) {
+            case "top":
+                top = triggerRect.top + scrollY - this.offset;
+                translateY = "-100%";
+                if (position === "start") {
+                    left = triggerRect.left + scrollX;
+                }
+                else if (position === "center") {
+                    left = triggerRect.left + scrollX + triggerWidth / 2;
+                    translateX = "-50%";
+                }
+                else {
+                    left = triggerRect.left + scrollX + triggerWidth;
+                    translateX = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                if (top - popupSize.height < scrollY) {
+                    top = scrollY + 8; // 距离顶部至少8px
+                }
+                if (left < scrollX) {
+                    left = scrollX + 8;
+                    translateX = "0";
+                }
+                else if (left + popupSize.width > scrollX + viewportWidth) {
+                    left = scrollX + viewportWidth - popupSize.width - 8;
+                    translateX = "0";
+                }
+                break;
+            case "bottom":
+                top = triggerRect.bottom + scrollY + this.offset;
+                if (position === "start") {
+                    left = triggerRect.left + scrollX;
+                }
+                else if (position === "center") {
+                    left = triggerRect.left + scrollX + triggerWidth / 2;
+                    translateX = "-50%";
+                }
+                else {
+                    left = triggerRect.left + scrollX + triggerWidth;
+                    translateX = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                if (top + popupSize.height > scrollY + viewportHeight) {
+                    top = scrollY + viewportHeight - popupSize.height - 8; // 距离底部至少8px
+                }
+                if (left < scrollX) {
+                    left = scrollX + 8;
+                    translateX = "0";
+                }
+                else if (left + popupSize.width > scrollX + viewportWidth) {
+                    left = scrollX + viewportWidth - popupSize.width - 8;
+                    translateX = "0";
+                }
+                break;
+            case "left":
+                left = triggerRect.left + scrollX - this.offset;
+                translateX = "-100%";
+                if (position === "start") {
+                    top = triggerRect.top + scrollY;
+                }
+                else if (position === "center") {
+                    top = triggerRect.top + scrollY + triggerHeight / 2;
+                    translateY = "-50%";
+                }
+                else {
+                    top = triggerRect.top + scrollY + triggerHeight;
+                    translateY = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                if (left - popupSize.width < scrollX) {
+                    left = scrollX + 8; // 距离左侧至少8px
+                }
+                if (top < scrollY) {
+                    top = scrollY + 8;
+                    translateY = "0";
+                }
+                else if (top + popupSize.height > scrollY + viewportHeight) {
+                    top = scrollY + viewportHeight - popupSize.height - 8;
+                    translateY = "0";
+                }
+                break;
+            case "right":
+                left = triggerRect.right + scrollX + this.offset;
+                if (position === "start") {
+                    top = triggerRect.top + scrollY;
+                }
+                else if (position === "center") {
+                    top = triggerRect.top + scrollY + triggerHeight / 2;
+                    translateY = "-50%";
+                }
+                else {
+                    top = triggerRect.top + scrollY + triggerHeight;
+                    translateY = "-100%";
+                }
+                // 边界约束：确保弹窗不超出视口
+                if (left + popupSize.width > scrollX + viewportWidth) {
+                    left = scrollX + viewportWidth - popupSize.width - 8; // 距离右侧至少8px
+                }
+                if (top < scrollY) {
+                    top = scrollY + 8;
+                    translateY = "0";
+                }
+                else if (top + popupSize.height > scrollY + viewportHeight) {
+                    top = scrollY + viewportHeight - popupSize.height - 8;
+                    translateY = "0";
+                }
+                break;
+        }
+        return {
+            top: top + "px",
+            left: left + "px",
+            translateX,
+            translateY,
+        };
+    }
+    /**
+     * @param {?} triggerRect
+     * @param {?} popupRect
+     * @param {?} placement
+     * @param {?} position
+     * @param {?=} popupSize
+     * @return {?}
+     */
+    setPopupPosition(triggerRect, popupRect, placement, position, popupSize) {
+        /** @type {?} */
+        const popupEl = this.popupElement && this.popupElement.nativeElement
+            ? this.popupElement.nativeElement
+            : null;
+        if (!popupEl) {
+            return; // 如果元素还不存在，无法设置位置
+        }
+        // 优先使用传入的固定尺寸，否则从DOM获取
+        /** @type {?} */
+        const popupWidth = popupSize && popupSize.width !== null && popupSize.width !== undefined
+            ? popupSize.width
+            : popupRect.width || popupEl.offsetWidth || 300;
+        /** @type {?} */
+        const popupHeight = popupSize && popupSize.height !== null && popupSize.height !== undefined
+            ? popupSize.height
+            : popupRect.height || popupEl.offsetHeight || 200;
+        /** @type {?} */
+        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})`;
+    }
+    /**
+     * @return {?}
+     */
+    onWindowResize() {
+        if (this.opened === "yes") {
+            this.updatePopupPosition();
+        }
+    }
+}
+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 0 rgba(0,0,0,.25);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;-webkit-animation:.2s ease-out popup-fade-in;animation:.2s ease-out popup-fade-in}::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%;-webkit-animation:1s linear infinite spin;animation:1s linear infinite spin;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}@-webkit-keyframes spin{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}@keyframes spin{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}::ng-deep #rs-smart-popup-fixed-container .rs-smart-popup-content .rs-smart-popup-body{width:100%}@-webkit-keyframes popup-fade-in{from{opacity:0;transform:translate(var(--translate-x,0),var(--translate-y,0)) scale(.95)}to{opacity:1;transform:translate(var(--translate-x,0),var(--translate-y,0)) scale(1)}}@keyframes popup-fade-in{from{opacity:0;transform:translate(var(--translate-x,0),var(--translate-y,0)) scale(.95)}to{opacity:1;transform:translate(var(--translate-x,0),var(--translate-y,0)) scale(1)}}"]
+            }] }
+];
+/** @nocollapse */
+SmartPopupComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+SmartPopupComponent.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",] }]
+};
+if (false) {
+    /** @type {?} */
+    SmartPopupComponent.prototype._placement;
+    /** @type {?} */
+    SmartPopupComponent.prototype._offset;
+    /** @type {?} */
+    SmartPopupComponent.prototype._autoAdjust;
+    /** @type {?} */
+    SmartPopupComponent.prototype.triggerElementRef;
+    /** @type {?} */
+    SmartPopupComponent.prototype.loading;
+    /** @type {?} */
+    SmartPopupComponent.prototype._open;
+    /** @type {?} */
+    SmartPopupComponent.prototype._width;
+    /** @type {?} */
+    SmartPopupComponent.prototype._height;
+    /** @type {?} */
+    SmartPopupComponent.prototype.openChange;
+    /** @type {?} */
+    SmartPopupComponent.prototype.contentLoad;
+    /** @type {?} */
+    SmartPopupComponent.prototype.internalTriggerElement;
+    /** @type {?} */
+    SmartPopupComponent.prototype.popupElement;
+    /** @type {?} */
+    SmartPopupComponent.prototype.currentTriggerElement;
+    /** @type {?} */
+    SmartPopupComponent.prototype.FIXED_CONTAINER_ID;
+    /** @type {?} */
+    SmartPopupComponent.prototype.fixedContainerEl;
+    /** @type {?} */
+    SmartPopupComponent.prototype.opened;
+    /** @type {?} */
+    SmartPopupComponent.prototype.positioning;
+    /** @type {?} */
+    SmartPopupComponent.prototype.actualPlacement;
+    /** @type {?} */
+    SmartPopupComponent.prototype.actualPosition;
+    /** @type {?} */
+    SmartPopupComponent.prototype.onClickOutside;
+    /** @type {?} */
+    SmartPopupComponent.prototype.onWindowScroll;
+    /**
+     * @type {?}
+     * @private
+     */
+    SmartPopupComponent.prototype.ref;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.component.js","sourceRoot":"ng://raise-common-lib/","sources":["lib/smart-popup/index.component.ts"],"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        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    // 处理 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      // 先关闭弹窗\r\n      this.opened = \"no\";\r\n      this.positioning = \"no\";\r\n      this.ref.markForCheck();\r\n      // 立即在新位置打开\r\n      requestAnimationFrame(() => {\r\n        // 再次确保触发元素已更新\r\n        this.updateTriggerElement();\r\n        this.openPopup();\r\n      });\r\n      return;\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      let 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        finalPlacement = optimal.placement;\r\n        finalPosition = optimal.position;\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      this.opened = \"yes\";\r\n      this.positioning = \"yes\";\r\n      this.openChange.emit(true);\r\n      this.ref.markForCheck();\r\n\r\n      // 强制更新视图，确保DOM已更新\r\n      this.ref.detectChanges();\r\n\r\n      // 如果元素已经存在，立即设置位置（不等待 requestAnimationFrame）\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        // 位置设置完成后，立即显示弹窗\r\n        this.positioning = \"no\";\r\n        this.ref.markForCheck();\r\n      } else {\r\n        // 如果元素还不存在，等待渲染\r\n        requestAnimationFrame(() => {\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            // 位置设置完成后，立即显示弹窗\r\n            this.positioning = \"no\";\r\n            this.ref.markForCheck();\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    let 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      finalPlacement = optimal.placement;\r\n      finalPosition = optimal.position;\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    let 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      finalPlacement = optimal.placement;\r\n      finalPosition = optimal.position;\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是否有足够空间\r\n      if (checkPositionSpace(preferred, preferredPosition)) {\r\n        return {\r\n          placement: preferred,\r\n          position: preferredPosition,\r\n        };\r\n      }\r\n      // 如果指定的position空间不足，自动计算最佳position\r\n      return {\r\n        placement: preferred,\r\n        position: calculatePosition(preferred),\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  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    const scrollX = window.scrollX;\r\n    const scrollY = window.scrollY;\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        top = triggerRect.top + scrollY - this.offset;\r\n        translateY = \"-100%\";\r\n        if (position === \"start\") {\r\n          left = triggerRect.left + scrollX;\r\n        } else if (position === \"center\") {\r\n          left = triggerRect.left + scrollX + triggerWidth / 2;\r\n          translateX = \"-50%\";\r\n        } else {\r\n          left = triggerRect.left + scrollX + triggerWidth;\r\n          translateX = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        if (top - popupSize.height < scrollY) {\r\n          top = scrollY + 8; // 距离顶部至少8px\r\n        }\r\n        if (left < scrollX) {\r\n          left = scrollX + 8;\r\n          translateX = \"0\";\r\n        } else if (left + popupSize.width > scrollX + viewportWidth) {\r\n          left = scrollX + viewportWidth - popupSize.width - 8;\r\n          translateX = \"0\";\r\n        }\r\n        break;\r\n\r\n      case \"bottom\":\r\n        top = triggerRect.bottom + scrollY + this.offset;\r\n        if (position === \"start\") {\r\n          left = triggerRect.left + scrollX;\r\n        } else if (position === \"center\") {\r\n          left = triggerRect.left + scrollX + triggerWidth / 2;\r\n          translateX = \"-50%\";\r\n        } else {\r\n          left = triggerRect.left + scrollX + triggerWidth;\r\n          translateX = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        if (top + popupSize.height > scrollY + viewportHeight) {\r\n          top = scrollY + viewportHeight - popupSize.height - 8; // 距离底部至少8px\r\n        }\r\n        if (left < scrollX) {\r\n          left = scrollX + 8;\r\n          translateX = \"0\";\r\n        } else if (left + popupSize.width > scrollX + viewportWidth) {\r\n          left = scrollX + viewportWidth - popupSize.width - 8;\r\n          translateX = \"0\";\r\n        }\r\n        break;\r\n\r\n      case \"left\":\r\n        left = triggerRect.left + scrollX - this.offset;\r\n        translateX = \"-100%\";\r\n        if (position === \"start\") {\r\n          top = triggerRect.top + scrollY;\r\n        } else if (position === \"center\") {\r\n          top = triggerRect.top + scrollY + triggerHeight / 2;\r\n          translateY = \"-50%\";\r\n        } else {\r\n          top = triggerRect.top + scrollY + triggerHeight;\r\n          translateY = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        if (left - popupSize.width < scrollX) {\r\n          left = scrollX + 8; // 距离左侧至少8px\r\n        }\r\n        if (top < scrollY) {\r\n          top = scrollY + 8;\r\n          translateY = \"0\";\r\n        } else if (top + popupSize.height > scrollY + viewportHeight) {\r\n          top = scrollY + viewportHeight - popupSize.height - 8;\r\n          translateY = \"0\";\r\n        }\r\n        break;\r\n\r\n      case \"right\":\r\n        left = triggerRect.right + scrollX + this.offset;\r\n        if (position === \"start\") {\r\n          top = triggerRect.top + scrollY;\r\n        } else if (position === \"center\") {\r\n          top = triggerRect.top + scrollY + triggerHeight / 2;\r\n          translateY = \"-50%\";\r\n        } else {\r\n          top = triggerRect.top + scrollY + triggerHeight;\r\n          translateY = \"-100%\";\r\n        }\r\n        // 边界约束：确保弹窗不超出视口\r\n        if (left + popupSize.width > scrollX + viewportWidth) {\r\n          left = scrollX + viewportWidth - popupSize.width - 8; // 距离右侧至少8px\r\n        }\r\n        if (top < scrollY) {\r\n          top = scrollY + 8;\r\n          translateY = \"0\";\r\n        } else if (top + popupSize.height > scrollY + viewportHeight) {\r\n          top = scrollY + viewportHeight - popupSize.height - 8;\r\n          translateY = \"0\";\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"]}