@v-c/trigger 1.0.6 → 1.0.7

package/dist/UniqueProvider/index.cjs

@@ -1,164 +0,0 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
-const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
-const require_context = require("../context.cjs");
-const require_util = require("../util.cjs");
-const require_useAlign = require("../hooks/useAlign.cjs");
-const require_useDelay = require("../hooks/useDelay.cjs");
-const require_index = require("../Popup/index.cjs");
-const require_UniqueContainer = require("./UniqueContainer.cjs");
-const require_useTargetState = require("./useTargetState.cjs");
-let vue = require("vue");
-let _v_c_portal = require("@v-c/portal");
-_v_c_portal = require_rolldown_runtime.__toESM(_v_c_portal);
-let _v_c_util = require("@v-c/util");
-let _v_c_util_dist_Dom_findDOMNode = require("@v-c/util/dist/Dom/findDOMNode");
-var UniqueProvider = /* @__PURE__ */ (0, vue.defineComponent)((props, { slots }) => {
-	const [trigger, open, options, onTargetVisibleChanged] = require_useTargetState.default();
-	const mergedOptions = (0, vue.computed)(() => {
-		if (!options.value || !props.postTriggerProps) return options.value;
-		return props.postTriggerProps(options.value);
-	});
-	const popupEle = (0, vue.shallowRef)(null);
-	const popupSize = (0, vue.ref)(null);
-	const externalPopupRef = (0, vue.shallowRef)(null);
-	const resolveToElement = (node) => {
-		if (!node) return null;
-		if ((0, _v_c_util_dist_Dom_findDOMNode.isDOM)(node)) return node;
-		const exposed = node;
-		if ((0, _v_c_util_dist_Dom_findDOMNode.isDOM)(exposed?.$el)) return exposed.$el;
-		const nativeEl = exposed?.nativeElement;
-		if ((0, _v_c_util_dist_Dom_findDOMNode.isDOM)(nativeEl?.value)) return nativeEl.value;
-		if ((0, _v_c_util_dist_Dom_findDOMNode.isDOM)(nativeEl)) return nativeEl;
-		if (typeof exposed?.getElement === "function") {
-			const el = exposed.getElement();
-			if ((0, _v_c_util_dist_Dom_findDOMNode.isDOM)(el)) return el;
-		}
-		return null;
-	};
-	const setPopupRef = (node) => {
-		const element = resolveToElement(node);
-		if (!element) return;
-		externalPopupRef.value = element;
-		if (popupEle.value !== element) popupEle.value = element;
-	};
-	const isOpenRef = (0, vue.shallowRef)();
-	const delayInvoke = require_useDelay.default();
-	const show = (showOptions, isOpen) => {
-		isOpenRef.value = isOpen;
-		delayInvoke(() => {
-			trigger(showOptions);
-		}, showOptions.delay);
-	};
-	const hide = (delay) => {
-		delayInvoke(() => {
-			if (isOpenRef.value?.()) return;
-			trigger(false);
-		}, delay);
-	};
-	const [ready, offsetX, offsetY, offsetR, offsetB, arrowX, arrowY, , , alignInfo, onAlign] = require_useAlign.default(open, popupEle, (0, vue.computed)(() => mergedOptions.value?.target), (0, vue.computed)(() => mergedOptions.value?.popupPlacement), (0, vue.computed)(() => mergedOptions.value?.builtinPlacements || {}), (0, vue.computed)(() => mergedOptions.value?.popupAlign), void 0, (0, vue.ref)(false));
-	const inMotion = (0, vue.shallowRef)(false);
-	(0, vue.watch)(open, () => {
-		if (open.value) inMotion.value = true;
-	});
-	const triggerAlign = () => {
-		if (!inMotion.value) onAlign();
-	};
-	const onVisibleChanged = (visible) => {
-		onTargetVisibleChanged(visible);
-		inMotion.value = false;
-		onAlign();
-	};
-	const alignedClassName = (0, vue.computed)(() => {
-		if (!mergedOptions.value) return "";
-		return (0, _v_c_util.classNames)(require_util.getAlignPopupClassName(mergedOptions.value?.builtinPlacements || {}, mergedOptions.value.prefixCls || "", alignInfo.value, false), mergedOptions.value?.getPopupClassNameFromAlign?.(alignInfo.value));
-	});
-	const contextValue = {
-		show,
-		hide
-	};
-	(0, vue.watch)(() => mergedOptions.value?.target, () => {
-		onAlign();
-	});
-	const onPrepare = () => {
-		onAlign();
-		return Promise.resolve();
-	};
-	const subPopupElements = (0, vue.ref)({});
-	const parentContext = require_context.useTriggerContext();
-	const triggerContextValue = (0, vue.computed)(() => {
-		return { registerSubPopup: (id, subPopupEle) => {
-			if (subPopupEle) subPopupElements.value[id] = subPopupEle;
-			else delete subPopupElements.value[id];
-			parentContext?.value?.registerSubPopup(id, subPopupEle);
-		} };
-	});
-	return () => {
-		const prefixCls = mergedOptions?.value?.prefixCls;
-		return (0, vue.createVNode)(require_context.UniqueContextProvider, contextValue, { default: () => [slots?.default?.(), !!mergedOptions.value && (0, vue.createVNode)(require_context.TriggerContextProvider, triggerContextValue.value, { default: () => [(0, vue.createVNode)(require_index.default, {
-			"ref": setPopupRef,
-			"portal": _v_c_portal.default,
-			"prefixCls": prefixCls,
-			"popup": mergedOptions.value?.popup,
-			"onEsc": mergedOptions.value?.onEsc,
-			"className": (0, _v_c_util.classNames)(mergedOptions.value?.popupClassName, alignedClassName.value, `${prefixCls}-unique-controlled`),
-			"style": mergedOptions.value?.popupStyle,
-			"target": mergedOptions.value?.target,
-			"open": open.value,
-			"keepDom": true,
-			"fresh": true,
-			"autoDestroy": false,
-			"onVisibleChanged": onVisibleChanged,
-			"ready": ready.value,
-			"offsetX": offsetX.value,
-			"offsetY": offsetY.value,
-			"offsetR": offsetR.value,
-			"offsetB": offsetB.value,
-			"onAlign": triggerAlign,
-			"onPrepare": onPrepare,
-			"onResize": (size) => {
-				popupSize.value = {
-					width: size.offsetWidth,
-					height: size.offsetHeight
-				};
-			},
-			"arrowPos": {
-				x: arrowX.value,
-				y: arrowY.value
-			},
-			"align": alignInfo.value,
-			"zIndex": mergedOptions.value?.zIndex,
-			"mask": mergedOptions.value?.mask,
-			"arrow": mergedOptions.value?.arrow,
-			"motion": mergedOptions.value?.popupMotion,
-			"maskMotion": mergedOptions.value?.maskMotion,
-			"getPopupContainer": mergedOptions.value.getPopupContainer
-		}, { default: () => [(0, vue.createVNode)(require_UniqueContainer.default, {
-			"prefixCls": prefixCls,
-			"isMobile": false,
-			"ready": ready.value,
-			"open": open.value,
-			"align": alignInfo.value,
-			"offsetX": offsetX.value,
-			"offsetY": offsetY.value,
-			"offsetR": offsetR.value,
-			"offsetB": offsetB.value,
-			"arrowPos": {
-				x: arrowX.value,
-				y: arrowY.value
-			},
-			"popupSize": popupSize.value,
-			"motion": mergedOptions.value?.popupMotion,
-			"uniqueContainerClassName": (0, _v_c_util.classNames)(mergedOptions.value?.uniqueContainerClassName, alignedClassName.value),
-			"uniqueContainerStyle": mergedOptions?.value?.uniqueContainerStyle
-		}, null)] })] })] });
-	};
-}, { props: { postTriggerProps: {
-	type: Function,
-	required: false,
-	default: void 0
-} } });
-var UniqueProvider_default = UniqueProvider;
-exports.default = UniqueProvider_default;

package/dist/UniqueProvider/useTargetState.cjs

@@ -1,44 +0,0 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
-const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
-let vue = require("vue");
-function useTargetState() {
-	const options = (0, vue.ref)();
-	const open = (0, vue.ref)(false);
-	const isAnimating = (0, vue.ref)(false);
-	const pendingOptionsRef = (0, vue.ref)();
-	const trigger = (nextOptions) => {
-		const wasOpen = open.value;
-		if (nextOptions === false) {
-			pendingOptionsRef.value = null;
-			open.value = false;
-		} else if (isAnimating.value && wasOpen) pendingOptionsRef.value = nextOptions;
-		else {
-			open.value = true;
-			options.value = nextOptions;
-			pendingOptionsRef.value = null;
-			if (!wasOpen) isAnimating.value = true;
-		}
-	};
-	const onVisibleChanged = (visible) => {
-		if (visible) {
-			isAnimating.value = false;
-			if (pendingOptionsRef.value) {
-				options.value = pendingOptionsRef.value;
-				pendingOptionsRef.value = null;
-			}
-		} else {
-			isAnimating.value = false;
-			pendingOptionsRef.value = null;
-		}
-	};
-	return [
-		trigger,
-		open,
-		options,
-		onVisibleChanged
-	];
-}
-exports.default = useTargetState;

package/dist/_virtual/rolldown_runtime.cjs

@@ -1,21 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-exports.__toESM = __toESM;

package/dist/context.cjs

@@ -1,28 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("./_virtual/rolldown_runtime.cjs");
-let vue = require("vue");
-var TriggerContextKey = Symbol("TriggerContextKey");
-function useTriggerContext() {
-	return (0, vue.inject)(TriggerContextKey, void 0);
-}
-const TriggerContextProvider = (0, vue.defineComponent)((props, { slots }) => {
-	(0, vue.provide)(TriggerContextKey, (0, vue.computed)(() => props));
-	return () => {
-		return slots?.default?.();
-	};
-}, { props: ["registerSubPopup"] });
-const UniqueContextKey = Symbol("UniqueContextKey");
-function useUniqueContext() {
-	return (0, vue.inject)(UniqueContextKey, void 0);
-}
-const UniqueContextProvider = (0, vue.defineComponent)((props, { slots }) => {
-	(0, vue.provide)(UniqueContextKey, props);
-	return () => {
-		return slots?.default?.();
-	};
-}, { props: ["show", "hide"] });
-exports.TriggerContextProvider = TriggerContextProvider;
-exports.UniqueContextKey = UniqueContextKey;
-exports.UniqueContextProvider = UniqueContextProvider;
-exports.useTriggerContext = useTriggerContext;
-exports.useUniqueContext = useUniqueContext;

package/dist/hooks/useAction.cjs

@@ -1,29 +0,0 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
-const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
-let vue = require("vue");
-function toArray(val) {
-	return val ? Array.isArray(val) ? val : [val] : [];
-}
-function normalizeAction(action) {
-	if (typeof action === "string") return action.toLowerCase();
-	return action;
-}
-function useAction(action, showAction, hideAction) {
-	const _showAction = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
-	const _hideAction = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
-	(0, vue.watchEffect)(() => {
-		const mergedShowAction = toArray(showAction?.value ?? action.value).map(normalizeAction);
-		const mergedHideAction = toArray(hideAction?.value ?? action.value).map(normalizeAction);
-		const showActionSet = new Set(mergedShowAction);
-		const hideActionSet = new Set(mergedHideAction);
-		if (showActionSet.has("hover") && !showActionSet.has("click")) showActionSet.add("touch");
-		if (hideActionSet.has("hover") && !hideActionSet.has("click")) hideActionSet.add("touch");
-		_showAction.value = showActionSet;
-		_hideAction.value = hideActionSet;
-	});
-	return [_showAction, _hideAction];
-}
-exports.default = useAction;

package/dist/hooks/useAlign.cjs

@@ -1,378 +0,0 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
-const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
-const require_util = require("../util.cjs");
-let vue = require("vue");
-let _v_c_util_dist_Dom_findDOMNode = require("@v-c/util/dist/Dom/findDOMNode");
-let _v_c_util_dist_Dom_isVisible = require("@v-c/util/dist/Dom/isVisible");
-_v_c_util_dist_Dom_isVisible = require_rolldown_runtime.__toESM(_v_c_util_dist_Dom_isVisible);
-function getUnitOffset(size, offset = 0) {
-	const offsetStr = `${offset}`;
-	const cells = offsetStr.match(/^(.*)\%$/);
-	if (cells) return size * (parseFloat(cells[1]) / 100);
-	return parseFloat(offsetStr);
-}
-function getNumberOffset(rect, offset) {
-	const [offsetX, offsetY] = offset || [];
-	return [getUnitOffset(rect.width, offsetX), getUnitOffset(rect.height, offsetY)];
-}
-function splitPoints(points = "") {
-	return [points[0], points[1]];
-}
-function getAlignPoint(rect, points) {
-	const topBottom = points[0];
-	const leftRight = points[1];
-	let x;
-	let y;
-	if (topBottom === "t") y = rect.y;
-	else if (topBottom === "b") y = rect.y + rect.height;
-	else y = rect.y + rect.height / 2;
-	if (leftRight === "l") x = rect.x;
-	else if (leftRight === "r") x = rect.x + rect.width;
-	else x = rect.x + rect.width / 2;
-	return {
-		x,
-		y
-	};
-}
-function reversePoints(points, index) {
-	const reverseMap = {
-		t: "b",
-		b: "t",
-		l: "r",
-		r: "l"
-	};
-	const clone = [...points];
-	clone[index] = reverseMap[points[index]] || "c";
-	return clone;
-}
-function flatPoints(points) {
-	return points.join("");
-}
-function shouldSwitchPlacement(isOverflow, isVisibleFirst, newVisibleArea, originVisibleArea, newRecommendArea, originRecommendArea) {
-	if (isOverflow) return newVisibleArea > originVisibleArea || newVisibleArea === originVisibleArea && (!isVisibleFirst || newRecommendArea >= originRecommendArea);
-	return newVisibleArea > originVisibleArea || isVisibleFirst && newVisibleArea === originVisibleArea && newRecommendArea > originRecommendArea;
-}
-function useAlign(open, popupEle, target, placement, builtinPlacements, popupAlign, onPopupAlign, mobile) {
-	const offsetInfo = (0, vue.reactive)({
-		ready: false,
-		offsetX: 0,
-		offsetY: 0,
-		offsetR: 0,
-		offsetB: 0,
-		arrowX: 0,
-		arrowY: 0,
-		scaleX: 1,
-		scaleY: 1,
-		align: builtinPlacements.value[placement.value] || {}
-	});
-	const alignCountRef = (0, vue.shallowRef)(0);
-	const scrollerList = (0, vue.computed)(() => {
-		if (!popupEle.value || mobile?.value) return [];
-		return require_util.collectScroller(popupEle.value);
-	});
-	const prevFlipRef = (0, vue.ref)({});
-	const resetFlipCache = () => {
-		prevFlipRef.value = {};
-	};
-	let cacheTargetRect = null;
-	const _onAlign = (cache = false) => {
-		if (cache && !cacheTargetRect) return;
-		if (popupEle.value && target.value && open.value && !mobile?.value) {
-			const popupElement = popupEle.value;
-			const doc = popupElement.ownerDocument;
-			const popupComputedStyle = require_util.getWin(popupElement).getComputedStyle(popupElement);
-			const { position: popupPosition } = popupComputedStyle;
-			const originLeft = popupElement.style.left;
-			const originTop = popupElement.style.top;
-			const originRight = popupElement.style.right;
-			const originBottom = popupElement.style.bottom;
-			const originOverflow = popupElement.style.overflow;
-			const placementInfo = {
-				...builtinPlacements.value[placement.value],
-				...popupAlign?.value
-			};
-			const placeholderElement = doc.createElement("div");
-			popupElement.parentElement?.appendChild(placeholderElement);
-			placeholderElement.style.left = `${popupElement.offsetLeft}px`;
-			placeholderElement.style.top = `${popupElement.offsetTop}px`;
-			placeholderElement.style.position = popupPosition;
-			placeholderElement.style.height = `${popupElement.offsetHeight}px`;
-			placeholderElement.style.width = `${popupElement.offsetWidth}px`;
-			popupElement.style.left = "0";
-			popupElement.style.top = "0";
-			popupElement.style.right = "auto";
-			popupElement.style.bottom = "auto";
-			popupElement.style.overflow = "hidden";
-			let targetRect;
-			if (Array.isArray(target.value)) targetRect = {
-				x: target.value[0],
-				y: target.value[1],
-				width: 0,
-				height: 0
-			};
-			else {
-				const targetRectInfo = target.value.getBoundingClientRect();
-				const rect = cache ? Object.assign(targetRectInfo, cacheTargetRect ?? {}) : targetRectInfo;
-				if (!cache) cacheTargetRect = {
-					width: rect.width,
-					height: rect.height
-				};
-				rect.x = rect.x ?? rect.left;
-				rect.y = rect.y ?? rect.top;
-				targetRect = {
-					x: rect.x,
-					y: rect.y,
-					width: rect.width,
-					height: rect.height
-				};
-			}
-			const rawPopupRect = popupElement.getBoundingClientRect();
-			const { clientWidth, clientHeight, scrollWidth, scrollHeight, scrollTop, scrollLeft } = doc.documentElement;
-			const targetHeight = targetRect.height;
-			const targetWidth = targetRect.width;
-			const visibleRegion = {
-				left: 0,
-				top: 0,
-				right: clientWidth,
-				bottom: clientHeight
-			};
-			const scrollRegion = {
-				left: -scrollLeft,
-				top: -scrollTop,
-				right: scrollWidth - scrollLeft,
-				bottom: scrollHeight - scrollTop
-			};
-			let { htmlRegion } = placementInfo;
-			const VISIBLE = "visible";
-			const VISIBLE_FIRST = "visibleFirst";
-			if (htmlRegion !== "scroll" && htmlRegion !== VISIBLE_FIRST) htmlRegion = VISIBLE;
-			const isVisibleFirst = htmlRegion === VISIBLE_FIRST;
-			const scrollRegionArea = require_util.getVisibleArea(scrollRegion, scrollerList.value);
-			const visibleRegionArea = require_util.getVisibleArea(visibleRegion, scrollerList.value);
-			const visibleArea = htmlRegion === VISIBLE ? visibleRegionArea : scrollRegionArea;
-			const adjustCheckVisibleArea = isVisibleFirst ? visibleRegionArea : visibleArea;
-			popupElement.style.left = "auto";
-			popupElement.style.top = "auto";
-			popupElement.style.right = "0";
-			popupElement.style.bottom = "0";
-			const rawPopupMirrorRect = popupElement.getBoundingClientRect();
-			popupElement.style.left = originLeft;
-			popupElement.style.top = originTop;
-			popupElement.style.right = originRight;
-			popupElement.style.bottom = originBottom;
-			popupElement.style.overflow = originOverflow;
-			popupElement.parentElement?.removeChild(placeholderElement);
-			const popupRect = rawPopupRect;
-			popupRect.x = popupRect.x ?? popupRect.left;
-			popupRect.y = popupRect.y ?? popupRect.top;
-			const { height, width } = popupComputedStyle;
-			const popupHeight = popupRect.height;
-			const popupWidth = popupRect.width;
-			const popupMirrorRect = rawPopupMirrorRect;
-			const scaleX$1 = require_util.toNum(Math.round(popupWidth / parseFloat(width) * 1e3) / 1e3);
-			const scaleY$1 = require_util.toNum(Math.round(popupHeight / parseFloat(height) * 1e3) / 1e3);
-			if (scaleX$1 === 0 || scaleY$1 === 0 || (0, _v_c_util_dist_Dom_findDOMNode.isDOM)(target) && !(0, _v_c_util_dist_Dom_isVisible.default)(target)) return;
-			const { offset, targetOffset } = placementInfo;
-			let [popupOffsetX, popupOffsetY] = getNumberOffset(popupRect, offset);
-			const [targetOffsetX, targetOffsetY] = getNumberOffset(targetRect, targetOffset);
-			targetRect.x -= targetOffsetX;
-			targetRect.y -= targetOffsetY;
-			const [popupPoint, targetPoint] = placementInfo.points || [];
-			const targetPoints = splitPoints(targetPoint);
-			const popupPoints = splitPoints(popupPoint);
-			const targetAlignPoint = getAlignPoint(targetRect, targetPoints);
-			const popupAlignPoint = getAlignPoint(popupRect, popupPoints);
-			const nextAlignInfo = { ...placementInfo };
-			let nextPoints = [popupPoints, targetPoints];
-			let nextOffsetX = targetAlignPoint.x - popupAlignPoint.x + popupOffsetX;
-			let nextOffsetY = targetAlignPoint.y - popupAlignPoint.y + popupOffsetY;
-			function getIntersectionVisibleArea(offsetX$1, offsetY$1, area = visibleArea) {
-				const l = popupRect.x + offsetX$1;
-				const t = popupRect.y + offsetY$1;
-				const r = l + popupWidth;
-				const b = t + popupHeight;
-				const visibleL = Math.max(l, area.left);
-				const visibleT = Math.max(t, area.top);
-				const visibleR = Math.min(r, area.right);
-				const visibleB = Math.min(b, area.bottom);
-				return Math.max(0, (visibleR - visibleL) * (visibleB - visibleT));
-			}
-			const originIntersectionVisibleArea = getIntersectionVisibleArea(nextOffsetX, nextOffsetY);
-			const originIntersectionRecommendArea = getIntersectionVisibleArea(nextOffsetX, nextOffsetY, visibleRegionArea);
-			const targetAlignPointTL = getAlignPoint(targetRect, ["t", "l"]);
-			const popupAlignPointTL = getAlignPoint(popupRect, ["t", "l"]);
-			const targetAlignPointBR = getAlignPoint(targetRect, ["b", "r"]);
-			const popupAlignPointBR = getAlignPoint(popupRect, ["b", "r"]);
-			const { adjustX, adjustY, shiftX, shiftY } = placementInfo.overflow || {};
-			const supportAdjust = (val) => {
-				if (typeof val === "boolean") return val;
-				return val >= 0;
-			};
-			let nextPopupY;
-			let nextPopupBottom;
-			let nextPopupX;
-			let nextPopupRight;
-			function syncNextPopupPosition() {
-				nextPopupY = popupRect.y + nextOffsetY;
-				nextPopupBottom = nextPopupY + popupHeight;
-				nextPopupX = popupRect.x + nextOffsetX;
-				nextPopupRight = nextPopupX + popupWidth;
-			}
-			syncNextPopupPosition();
-			const needAdjustY = supportAdjust(adjustY);
-			const sameTB = popupPoints[0] === targetPoints[0];
-			const overflowBottom = nextPopupBottom > adjustCheckVisibleArea.bottom;
-			if (needAdjustY && popupPoints[0] === "t" && (overflowBottom || prevFlipRef.value.bt)) {
-				let tmpNextOffsetY = nextOffsetY;
-				if (sameTB) tmpNextOffsetY -= popupHeight - targetHeight;
-				else tmpNextOffsetY = targetAlignPointTL.y - popupAlignPointBR.y - popupOffsetY;
-				if (shouldSwitchPlacement(overflowBottom, isVisibleFirst, getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY), originIntersectionVisibleArea, getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY, visibleRegionArea), originIntersectionRecommendArea)) {
-					prevFlipRef.value.bt = true;
-					nextOffsetY = tmpNextOffsetY;
-					popupOffsetY = -popupOffsetY;
-					nextPoints = [reversePoints(nextPoints[0], 0), reversePoints(nextPoints[1], 0)];
-				} else prevFlipRef.value.bt = false;
-			}
-			const overflowTop = nextPopupY < adjustCheckVisibleArea.top;
-			if (needAdjustY && popupPoints[0] === "b" && (overflowTop || prevFlipRef.value.tb)) {
-				let tmpNextOffsetY = nextOffsetY;
-				if (sameTB) tmpNextOffsetY += popupHeight - targetHeight;
-				else tmpNextOffsetY = targetAlignPointBR.y - popupAlignPointTL.y - popupOffsetY;
-				if (shouldSwitchPlacement(overflowTop, isVisibleFirst, getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY), originIntersectionVisibleArea, getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY, visibleRegionArea), originIntersectionRecommendArea)) {
-					prevFlipRef.value.tb = true;
-					nextOffsetY = tmpNextOffsetY;
-					popupOffsetY = -popupOffsetY;
-					nextPoints = [reversePoints(nextPoints[0], 0), reversePoints(nextPoints[1], 0)];
-				} else prevFlipRef.value.tb = false;
-			}
-			const needAdjustX = supportAdjust(adjustX);
-			const sameLR = popupPoints[1] === targetPoints[1];
-			const overflowRight = nextPopupRight > adjustCheckVisibleArea.right;
-			if (needAdjustX && popupPoints[1] === "l" && (overflowRight || prevFlipRef.value.rl)) {
-				let tmpNextOffsetX = nextOffsetX;
-				if (sameLR) tmpNextOffsetX -= popupWidth - targetWidth;
-				else tmpNextOffsetX = targetAlignPointTL.x - popupAlignPointBR.x - popupOffsetX;
-				if (shouldSwitchPlacement(overflowRight, isVisibleFirst, getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY), originIntersectionVisibleArea, getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY, visibleRegionArea), originIntersectionRecommendArea)) {
-					prevFlipRef.value.rl = true;
-					nextOffsetX = tmpNextOffsetX;
-					popupOffsetX = -popupOffsetX;
-					nextPoints = [reversePoints(nextPoints[0], 1), reversePoints(nextPoints[1], 1)];
-				} else prevFlipRef.value.rl = false;
-			}
-			const overflowLeft = nextPopupX < adjustCheckVisibleArea.left;
-			if (needAdjustX && popupPoints[1] === "r" && (overflowLeft || prevFlipRef.value.lr)) {
-				let tmpNextOffsetX = nextOffsetX;
-				if (sameLR) tmpNextOffsetX += popupWidth - targetWidth;
-				else tmpNextOffsetX = targetAlignPointBR.x - popupAlignPointTL.x - popupOffsetX;
-				if (shouldSwitchPlacement(overflowLeft, isVisibleFirst, getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY), originIntersectionVisibleArea, getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY, visibleRegionArea), originIntersectionRecommendArea)) {
-					prevFlipRef.value.lr = true;
-					nextOffsetX = tmpNextOffsetX;
-					popupOffsetX = -popupOffsetX;
-					nextPoints = [reversePoints(nextPoints[0], 1), reversePoints(nextPoints[1], 1)];
-				} else prevFlipRef.value.lr = false;
-			}
-			nextAlignInfo.points = [flatPoints(nextPoints[0]), flatPoints(nextPoints[1])];
-			syncNextPopupPosition();
-			const numShiftX = shiftX === true ? 0 : shiftX;
-			if (typeof numShiftX === "number") {
-				if (nextPopupX < visibleRegionArea.left) {
-					nextOffsetX -= nextPopupX - visibleRegionArea.left - popupOffsetX;
-					if (targetRect.x + targetWidth < visibleRegionArea.left + numShiftX) nextOffsetX += targetRect.x - visibleRegionArea.left + targetWidth - numShiftX;
-				}
-				if (nextPopupRight > visibleRegionArea.right) {
-					nextOffsetX -= nextPopupRight - visibleRegionArea.right - popupOffsetX;
-					if (targetRect.x > visibleRegionArea.right - numShiftX) nextOffsetX += targetRect.x - visibleRegionArea.right + numShiftX;
-				}
-			}
-			const numShiftY = shiftY === true ? 0 : shiftY;
-			if (typeof numShiftY === "number") {
-				if (nextPopupY < visibleRegionArea.top) {
-					nextOffsetY -= nextPopupY - visibleRegionArea.top - popupOffsetY;
-					if (targetRect.y + targetHeight < visibleRegionArea.top + numShiftY) nextOffsetY += targetRect.y - visibleRegionArea.top + targetHeight - numShiftY;
-				}
-				if (nextPopupBottom > visibleRegionArea.bottom) {
-					nextOffsetY -= nextPopupBottom - visibleRegionArea.bottom - popupOffsetY;
-					if (targetRect.y > visibleRegionArea.bottom - numShiftY) nextOffsetY += targetRect.y - visibleRegionArea.bottom + numShiftY;
-				}
-			}
-			const popupLeft = popupRect.x + nextOffsetX;
-			const popupRight = popupLeft + popupWidth;
-			const popupTop = popupRect.y + nextOffsetY;
-			const popupBottom = popupTop + popupHeight;
-			const targetLeft = targetRect.x;
-			const targetRight = targetLeft + targetWidth;
-			const targetTop = targetRect.y;
-			const targetBottom = targetTop + targetHeight;
-			const nextArrowX = (Math.max(popupLeft, targetLeft) + Math.min(popupRight, targetRight)) / 2 - popupLeft;
-			const nextArrowY = (Math.max(popupTop, targetTop) + Math.min(popupBottom, targetBottom)) / 2 - popupTop;
-			onPopupAlign?.(popupEle.value, nextAlignInfo);
-			let offsetX4Right = popupMirrorRect.right - popupRect.x - (nextOffsetX + popupRect.width);
-			let offsetY4Bottom = popupMirrorRect.bottom - popupRect.y - (nextOffsetY + popupRect.height);
-			if (scaleX$1 === 1) {
-				nextOffsetX = Math.floor(nextOffsetX);
-				offsetX4Right = Math.floor(offsetX4Right);
-			}
-			if (scaleY$1 === 1) {
-				nextOffsetY = Math.floor(nextOffsetY);
-				offsetY4Bottom = Math.floor(offsetY4Bottom);
-			}
-			const nextOffsetInfo = {
-				ready: true,
-				offsetX: nextOffsetX / scaleX$1,
-				offsetY: nextOffsetY / scaleY$1,
-				offsetR: offsetX4Right / scaleX$1,
-				offsetB: offsetY4Bottom / scaleY$1,
-				arrowX: nextArrowX / scaleX$1,
-				arrowY: nextArrowY / scaleY$1,
-				scaleX: scaleX$1,
-				scaleY: scaleY$1,
-				align: nextAlignInfo
-			};
-			Object.assign(offsetInfo, nextOffsetInfo);
-		}
-	};
-	const onAlign = _onAlign;
-	const triggerAlign = (cache) => {
-		alignCountRef.value += 1;
-		const id = alignCountRef.value;
-		Promise.resolve().then(() => {
-			if (alignCountRef.value === id) onAlign(cache);
-		});
-	};
-	(0, vue.watch)(popupEle, async (ele) => {
-		if (ele && open.value && !mobile?.value) {
-			await (0, vue.nextTick)();
-			triggerAlign();
-		}
-	});
-	const resetReady = () => {
-		offsetInfo.ready = false;
-	};
-	(0, vue.watch)(placement, () => {
-		resetReady();
-	});
-	(0, vue.watch)(open, () => {
-		if (!open.value) {
-			resetFlipCache();
-			resetReady();
-		}
-	}, { immediate: true });
-	const { ready, offsetX, offsetR, offsetY, offsetB, align, arrowY, arrowX, scaleY, scaleX } = (0, vue.toRefs)(offsetInfo);
-	return [
-		ready,
-		offsetX,
-		offsetY,
-		offsetR,
-		offsetB,
-		arrowX,
-		arrowY,
-		scaleX,
-		scaleY,
-		align,
-		triggerAlign
-	];
-}
-exports.default = useAlign;