@astryx-vue/core 0.2.6 → 0.4.0

package/dist/useMenuPress-8foxY8z4.js

@@ -0,0 +1,764 @@
+import { getCurrentScope, onScopeDispose, toValue } from "vue";
+//#region src/composables/useLongPress.ts
+const DEFAULT_DELAY_MS = 500;
+const DEFAULT_MOVE_CANCEL_PX = 10;
+function touchPoint(event) {
+	const touch = event.touches?.[0] ?? event.changedTouches?.[0];
+	return touch == null ? null : {
+		x: touch.clientX,
+		y: touch.clientY
+	};
+}
+/**
+* 对应原版 Astryx 的 `hooks/useLongPress`。
+*
+* Detect a single-finger long press.
+*
+* iOS Safari never synthesizes a `contextmenu` event for a held finger, so a
+* long press is the only touch affordance that can open a cursor-positioned
+* surface. The press is cancelled when the finger travels past the tolerance,
+* lifts, a second finger lands, or the touch is cancelled.
+*
+* 两种绑法，同一个检测器：直接要触摸监听时把 `handlers` 摊到元素上；
+* 自己已经在跑指针事件状态机时（`useMenuPress` 就是）调 `start` / `moveTo` / `cancel`。
+* 按住时长、移动容差、计时器都在这里，所以长按在右键菜单和菜单触发器上是同一个意思。
+*/
+function useLongPress(options) {
+	const delayMs = options.delayMs ?? DEFAULT_DELAY_MS;
+	const moveCancelPx = options.moveCancelPx ?? DEFAULT_MOVE_CANCEL_PX;
+	let timer = null;
+	let origin = null;
+	function isDisabled() {
+		return toValue(options.isDisabled) === true || toValue(options.disabled) === true;
+	}
+	function cancel() {
+		if (timer != null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		origin = null;
+	}
+	function start(point) {
+		if (isDisabled()) return;
+		cancel();
+		origin = {
+			x: point.x,
+			y: point.y
+		};
+		timer = setTimeout(() => {
+			const from = origin;
+			timer = null;
+			if (from == null) return;
+			options.onLongPress({
+				x: from.x,
+				y: from.y
+			});
+		}, delayMs);
+	}
+	function moveTo(point) {
+		if (origin == null) return false;
+		if (Math.abs(point.x - origin.x) > moveCancelPx || Math.abs(point.y - origin.y) > moveCancelPx) {
+			cancel();
+			return false;
+		}
+		return true;
+	}
+	/**
+	* A press needs exactly one finger. A second one cancels it, the way a
+	* lift does.
+	*/
+	function onTouchStart(event) {
+		if ((event.touches?.length ?? 0) !== 1) {
+			cancel();
+			return;
+		}
+		const point = touchPoint(event);
+		if (point != null) start(point);
+	}
+	function onTouchMove(event) {
+		if (origin == null) return;
+		if ((event.touches?.length ?? 0) > 1) {
+			cancel();
+			return;
+		}
+		const point = touchPoint(event);
+		if (point != null) moveTo(point);
+	}
+	function onTouchEnd() {
+		cancel();
+	}
+	function onTouchCancel() {
+		cancel();
+	}
+	if (getCurrentScope() != null) onScopeDispose(cancel);
+	return {
+		cancel,
+		handlers: {
+			onTouchCancel,
+			onTouchEnd,
+			onTouchMove,
+			onTouchStart
+		},
+		moveTo,
+		start
+	};
+}
+//#endregion
+//#region src/composables/internal/gestureCounter.ts
+/**
+* 手势计数器：每一次新的按下或按键，计数加一。
+*
+* 同一次按压里，浏览器的点外关闭和触发器自己的 click 谁先到是没准的。
+* 比时间窗口只能猜，数手势不用猜：「属于关闭那次手势的 click」就是
+* 「计数还停在关闭那一刻的 click」，不管主线程中间卡了多久。
+*
+* 监听挂在 document 的捕获阶段，在任何处理函数读它之前先加一。第一次读的时候才装，服务端不装。
+*/
+let gesture = 0;
+let isListening = false;
+function advance() {
+	gesture += 1;
+}
+function markClicked() {}
+function listen() {
+	if (isListening || typeof document === "undefined") return;
+	isListening = true;
+	document.addEventListener("pointerdown", advance, true);
+	document.addEventListener("keydown", advance, true);
+	document.addEventListener("click", markClicked, true);
+}
+/** 当前这次手势的编号。两次读到同一个数，说明它们在同一次按压（或同一次按键）里。 */
+function currentGesture() {
+	listen();
+	return gesture;
+}
+const AUTOSCROLL_STEP_PX = 6;
+const AUTOSCROLL_INTERVAL_MS = 16;
+/** `onTick` 在每次真的滚动之后调用：行在静止的指针下面移动了，要重新看指针下是哪一行。 */
+function createMenuAutoscroll(onTick) {
+	let running = null;
+	function stop() {
+		if (running != null) {
+			clearInterval(running.timer);
+			running = null;
+		}
+	}
+	function directionFor(event, scroller) {
+		const rect = scroller.getBoundingClientRect();
+		if (rect.height <= 0) return 0;
+		if (event.clientY <= rect.top + 24) return -1;
+		if (event.clientY >= rect.bottom - 24) return 1;
+		return 0;
+	}
+	function update(event, scroller) {
+		const direction = scroller == null ? 0 : directionFor(event, scroller);
+		if (direction === 0 || scroller == null) {
+			stop();
+			return;
+		}
+		if (running?.direction === direction) return;
+		stop();
+		const tick = () => {
+			const before = scroller.scrollTop;
+			scroller.scrollTop = before + direction * AUTOSCROLL_STEP_PX;
+			if (scroller.scrollTop === before) {
+				stop();
+				return;
+			}
+			onTick();
+		};
+		running = {
+			direction,
+			timer: setInterval(tick, AUTOSCROLL_INTERVAL_MS)
+		};
+		tick();
+	}
+	return {
+		stop,
+		update
+	};
+}
+/** 默认的滚动容器：菜单根自己溢出时就是它。 */
+function overflowingMenu(menu) {
+	if (menu == null) return null;
+	return menu.scrollHeight > menu.clientHeight + 1 ? menu : null;
+}
+let isModelActivation = false;
+/**
+* 按压模型派发的那次行激活是不是正在进行。只在那次派发的同步过程中为真，
+* 所以把激活转交给里面链接的行，能分清这是模型的 click 还是浏览器多出来的那个。
+*/
+function isMenuPressActivation() {
+	return isModelActivation;
+}
+/** 在「模型激活」标记下执行一段同步代码。 */
+function runAsMenuPressActivation(run) {
+	isModelActivation = true;
+	try {
+		run();
+	} finally {
+		isModelActivation = false;
+	}
+}
+let swallower = null;
+function disarm() {
+	if (swallower == null) return;
+	swallower.isArmed = false;
+	if (swallower.timer != null) {
+		clearTimeout(swallower.timer);
+		swallower.timer = null;
+	}
+}
+function onWindowClickCapture(event) {
+	if (swallower == null || !swallower.isArmed) return;
+	if (event.detail === 0 || isModelActivation) return;
+	event.preventDefault();
+	event.stopImmediatePropagation();
+	disarm();
+}
+/** 布下吞 click 的口子。同一个文档只装一次监听。 */
+function armStrayClick(doc) {
+	const view = doc.defaultView;
+	if (view == null) return;
+	if (swallower == null || swallower.doc !== doc) {
+		if (swallower != null) {
+			swallower.doc.defaultView?.removeEventListener("click", onWindowClickCapture, true);
+			swallower.doc.removeEventListener("pointerdown", disarm, true);
+		}
+		view.addEventListener("click", onWindowClickCapture, true);
+		doc.addEventListener("pointerdown", disarm, true);
+		swallower = {
+			doc,
+			isArmed: false,
+			timer: null
+		};
+	}
+	disarm();
+	swallower.isArmed = true;
+	swallower.timer = setTimeout(disarm, 400);
+}
+/** 撤掉已经布下的口子。卸载和测试里用。 */
+function resetMenuPress() {
+	disarm();
+}
+//#endregion
+//#region src/composables/internal/menuPressDom.ts
+/** 带这个标记的菜单根用的是按压模型。嵌套的飞出层靠它分清一次按压归哪一层。 */
+const MENU_PRESS_MARKER = "data-astryx-menu-press";
+const MENU_PRESS_ROOT_SELECTOR = `[${MENU_PRESS_MARKER}]`;
+/** 菜单里可用的行：三种菜单项角色，且没有 `aria-disabled="true"`。 */
+const MENU_PRESS_ITEM_SELECTOR = [
+	"menuitem",
+	"menuitemradio",
+	"menuitemcheckbox"
+].map((role) => `[role="${role}"]:not([aria-disabled="true"])`).join(",");
+const FOCUSABLE_ROW_SELECTOR = "[tabindex], a[href], button, input, select, textarea, [contenteditable]";
+const INNER_CONTROL_SELECTOR = "a[href], button, [tabindex]";
+function normalizePointerType(type) {
+	return type === "mouse" || type === "touch" || type === "pen" ? type : null;
+}
+/** 最外层带标记的根。飞出层如果是父菜单的 DOM 后代，算同一个菜单。 */
+function getOutermostRoot(menu) {
+	let root = menu;
+	for (;;) {
+		const parent = root.parentElement?.closest(MENU_PRESS_ROOT_SELECTOR);
+		if (parent == null) return root;
+		root = parent;
+	}
+}
+/**
+* 指针所在位置下的元素。
+*
+* 手指的指针事件一直发给它落下的那个元素，所以要按坐标找当前在它下面的是谁。
+* 测试环境的 `elementFromPoint` 没有布局，答不出来时退回事件目标。
+*/
+function elementUnder(event, doc, hitTest) {
+	const hit = hitTest != null ? hitTest(event.clientX, event.clientY) : typeof doc.elementFromPoint === "function" ? doc.elementFromPoint(event.clientX, event.clientY) : null;
+	if (hit != null) return hit;
+	return event.target instanceof Element ? event.target : null;
+}
+/** 指针下面是哪一行、在不在菜单里、在不在触发器上。 */
+function resolvePoint(event, doc, input) {
+	const element = elementUnder(event, doc, input.hitTest);
+	const root = input.menu == null ? null : getOutermostRoot(input.menu);
+	const isInMenu = root != null && element != null && root.contains(element);
+	const isOnTrigger = input.trigger != null && element != null && input.trigger.contains(element);
+	let row = null;
+	if (isInMenu && element != null) {
+		row = element.closest(input.itemSelector);
+		if (row != null && !root.contains(row)) row = null;
+	}
+	return {
+		row,
+		isInMenu,
+		isOnTrigger
+	};
+}
+/**
+* 默认的高亮：菜单里高亮就是 DOM 焦点（`preventScroll`）。
+* 行本身不可聚焦时聚焦里面的控件；指针下没有行时把焦点放在菜单根上，这样没有一行亮着。
+*/
+function focusHighlight(row, menu, doc) {
+	const target = row == null ? menu : row.matches(FOCUSABLE_ROW_SELECTOR) ? row : row.querySelector(INNER_CONTROL_SELECTOR);
+	if (target != null && target !== doc.activeElement) target.focus({ preventScroll: true });
+}
+/**
+* 默认的执行：像这一行自己被点了一样，派发一次 click，带上松开时的按键和修饰键。
+* `detail: 0` 表示这是派发出来的激活（键盘的也是 0），吞 click 的口子会放它过去。
+*/
+function dispatchRowClick(row, release) {
+	runAsMenuPressActivation(() => {
+		row.dispatchEvent(new MouseEvent("click", {
+			bubbles: true,
+			cancelable: true,
+			composed: true,
+			detail: 0,
+			button: release.button ?? 0,
+			clientX: release.clientX,
+			clientY: release.clientY,
+			screenX: release.screenX,
+			screenY: release.screenY,
+			ctrlKey: release.ctrlKey,
+			shiftKey: release.shiftKey,
+			altKey: release.altKey,
+			metaKey: release.metaKey
+		}));
+	});
+}
+/** 手指按住触发器打开菜单之后，页面不能再在这根手指下面滚动。返回撤掉的函数。 */
+function preventTouchScroll(doc) {
+	const prevent = (event) => {
+		if (event.cancelable) event.preventDefault();
+	};
+	doc.addEventListener("touchmove", prevent, {
+		passive: false,
+		capture: true
+	});
+	return () => doc.removeEventListener("touchmove", prevent, true);
+}
+//#endregion
+//#region src/composables/internal/menuPressGesture.ts
+/**
+* 菜单按压的纯状态机。不碰 DOM，每一步都能脱离浏览器单测。
+*
+* 所有菜单和选择器共用这一套：指针**松开**时下面是哪一行，就由哪一行执行；
+* 按住期间高亮跟着指针走。macOS 和 iOS 的菜单就是这样。
+*
+* 状态：
+* - `idle`：没有手势。
+* - `triggerPress`：手指按在触发器上，菜单还没开。鼠标不经过这一步，按下就开。
+* - `open`：菜单在按住的指针下面打开了（鼠标按下，或手指按满长按时间），指针还没进菜单。
+* - `tracking`：指针按着，高亮跟着它。
+*
+* 落定规则：打开菜单的那次按压，只有指针进过菜单、或者按满 `MENU_PRESS_SETTLE_MS`，
+* 松开时才执行；否则什么都不执行，菜单保持打开。没有这条，一个在指针下面弹出的菜单
+* 会替用户挑一行谁都没选的。
+*
+* 行是不透明的 `T`：调用方把指针下可用的那一行找出来喂进来，`null` 表示指针在分割线、
+* 标题、禁用行上，或者在菜单外。
+*/
+/** 打开菜单的那次按压至少要按多久，松开时才能执行。 */
+const MENU_PRESS_SETTLE_MS = 300;
+const IDLE_MENU_PRESS = { phase: "idle" };
+const NONE = { type: "none" };
+function idle(effect) {
+	return {
+		gesture: { phase: "idle" },
+		effect
+	};
+}
+function highlightEffect(row) {
+	return row == null ? { type: "clear" } : {
+		type: "highlight",
+		row
+	};
+}
+/**
+* 高亮跟着指针时的松开：在可用行上就执行；在菜单的空白处什么都不执行；
+* 在菜单外什么都不执行，鼠标还会关掉菜单（手指不关）。松回触发器上从不关。
+*/
+function release(pointerType, event) {
+	if (event.row != null) return idle({
+		type: "act",
+		row: event.row
+	});
+	if (event.isInMenu || event.isOnTrigger) return idle({
+		type: "settle",
+		stray: true,
+		dismiss: false
+	});
+	return idle({
+		type: "settle",
+		stray: true,
+		dismiss: pointerType === "mouse"
+	});
+}
+function stepIdle(gesture, event) {
+	if (event.type !== "down") return {
+		gesture,
+		effect: NONE
+	};
+	if (event.target === "menu") return {
+		gesture: {
+			phase: "tracking",
+			pointerType: event.pointerType,
+			origin: "menu",
+			row: event.row
+		},
+		effect: highlightEffect(event.row)
+	};
+	if (event.pointerType === "mouse") return {
+		gesture: {
+			phase: "open",
+			pointerType: "mouse",
+			openedAt: event.time
+		},
+		effect: { type: "open" }
+	};
+	return {
+		gesture: {
+			phase: "triggerPress",
+			pointerType: event.pointerType,
+			startedAt: event.time
+		},
+		effect: NONE
+	};
+}
+function stepTriggerPress(gesture, event) {
+	switch (event.type) {
+		case "opened": return {
+			gesture: {
+				phase: "open",
+				pointerType: gesture.pointerType,
+				openedAt: event.time
+			},
+			effect: NONE
+		};
+		case "up": return idle({
+			type: "settle",
+			stray: false,
+			dismiss: false
+		});
+		case "cancel": return idle({
+			type: "settle",
+			stray: false,
+			dismiss: false
+		});
+		default: return {
+			gesture,
+			effect: NONE
+		};
+	}
+}
+function stepOpen(gesture, event) {
+	switch (event.type) {
+		case "move":
+			if (!event.isInMenu) return {
+				gesture,
+				effect: NONE
+			};
+			return {
+				gesture: {
+					phase: "tracking",
+					pointerType: gesture.pointerType,
+					origin: "trigger",
+					row: event.row
+				},
+				effect: highlightEffect(event.row)
+			};
+		case "up":
+			if (event.time - gesture.openedAt < 300) return idle({
+				type: "settle",
+				stray: true,
+				dismiss: false
+			});
+			return release(gesture.pointerType, event);
+		case "cancel": return idle({
+			type: "settle",
+			stray: false,
+			dismiss: false
+		});
+		default: return {
+			gesture,
+			effect: NONE
+		};
+	}
+}
+function stepTracking(gesture, event) {
+	switch (event.type) {
+		case "move":
+			if (event.row === gesture.row) return {
+				gesture,
+				effect: NONE
+			};
+			return {
+				gesture: {
+					...gesture,
+					row: event.row
+				},
+				effect: highlightEffect(event.row)
+			};
+		case "up": return release(gesture.pointerType, event);
+		case "cancel": return idle({
+			type: "settle",
+			stray: false,
+			dismiss: false
+		});
+		default: return {
+			gesture,
+			effect: NONE
+		};
+	}
+}
+/** 往前走一步。纯函数：同样的输入，同样的输出。 */
+function menuPressStep(gesture, event) {
+	switch (gesture.phase) {
+		case "idle": return stepIdle(gesture, event);
+		case "triggerPress": return stepTriggerPress(gesture, event);
+		case "open": return stepOpen(gesture, event);
+		case "tracking": return stepTracking(gesture, event);
+	}
+}
+//#endregion
+//#region src/composables/useMenuPress.ts
+/** 手指在触发器上按多久菜单才打开。 */
+const MENU_PRESS_LONG_PRESS_MS = 500;
+/**
+* 对应原版 Astryx 的 `hooks/useMenuPress`。纯状态机见 `internal/menuPressGesture.ts`。
+*
+* 菜单里的一次按压，不管从触发器还是从菜单里开始，从头管到尾：
+* - 按 `pointerId` 在文档层跟踪。手指的事件一直发给它落下的元素，所以只有文档看得见它滑到了哪。
+* - 高亮跟着指针走。
+* - **松开**位置那一行执行，就像它自己被点了一样，带上松开时的修饰键；浏览器为这次手势补的 click 被吞掉。
+* - 鼠标按下触发器就打开；手指按住满 `longPressDelayMs` 才打开，然后可以一路滑进菜单挑行。
+* - pointercancel、第二根手指、窗口失焦都以什么都不执行结束。滚动交给浏览器（菜单根上的 `touch-action`）。
+* - 菜单会滚动时，按住的指针停在上下边缘附近，菜单自动朝那边滚。
+*/
+function useMenuPress(options) {
+	let gesture = IDLE_MENU_PRESS;
+	let pointerId = null;
+	let detach = null;
+	let stopTouchPrevent = null;
+	let lastPointerEvent = null;
+	let triggerGesture = null;
+	/** 结束了上一次手势的那根「第二根手指」不能开始下一次。 */
+	let ignoredPointerId = null;
+	const isEnabled = () => toValue(options.isEnabled) ?? true;
+	const getDocument = () => options.menuRef.value?.ownerDocument ?? options.triggerRef?.value?.ownerDocument ?? document;
+	function pointAt(event) {
+		return resolvePoint(event, getDocument(), {
+			hitTest: options.hitTest,
+			itemSelector: options.itemSelector ?? MENU_PRESS_ITEM_SELECTOR,
+			menu: options.menuRef.value,
+			trigger: options.triggerRef?.value ?? null
+		});
+	}
+	const autoscroll = createMenuAutoscroll(() => {
+		if (lastPointerEvent != null) stepMove(lastPointerEvent);
+	});
+	const longPress = useLongPress({
+		delayMs: options.longPressDelayMs ?? MENU_PRESS_LONG_PRESS_MS,
+		onLongPress: fireLongPress
+	});
+	function endGesture() {
+		longPress.cancel();
+		stopTouchPrevent?.();
+		stopTouchPrevent = null;
+		autoscroll.stop();
+		detach?.();
+		detach = null;
+		pointerId = null;
+		lastPointerEvent = null;
+		gesture = IDLE_MENU_PRESS;
+	}
+	function highlight(row) {
+		if (options.onHighlight != null) options.onHighlight(row);
+		else focusHighlight(row, options.menuRef.value, getDocument());
+	}
+	function activate(row, release) {
+		if (options.onActivate != null) runAsMenuPressActivation(() => options.onActivate(row, release));
+		else dispatchRowClick(row, release);
+	}
+	function applyEffect(effect, native) {
+		const doc = getDocument();
+		switch (effect.type) {
+			case "none": return;
+			case "open": {
+				const pointerType = gesture.phase === "open" ? gesture.pointerType : "mouse";
+				triggerGesture = currentGesture();
+				if (!(options.onTriggerPress?.(pointerType) ?? false)) endGesture();
+				return;
+			}
+			case "highlight":
+				highlight(effect.row);
+				return;
+			case "clear":
+				highlight(null);
+				return;
+			case "act":
+				endGesture();
+				armStrayClick(doc);
+				if (native != null) activate(effect.row, native);
+				return;
+			case "settle":
+				endGesture();
+				if (effect.stray) armStrayClick(doc);
+				if (effect.dismiss) options.onDismiss?.();
+		}
+	}
+	function step(event, native) {
+		const result = menuPressStep(gesture, event);
+		gesture = result.gesture;
+		applyEffect(result.effect, native);
+	}
+	function stepMove(event) {
+		const point = pointAt(event);
+		step({
+			type: "move",
+			row: point.row,
+			isInMenu: point.isInMenu,
+			time: Date.now()
+		}, event);
+	}
+	function onDocumentMove(event) {
+		if (event.pointerId !== pointerId) return;
+		lastPointerEvent = event;
+		if (gesture.phase === "triggerPress") {
+			if (!longPress.moveTo({
+				x: event.clientX,
+				y: event.clientY
+			})) step({ type: "cancel" });
+			return;
+		}
+		stepMove(event);
+		if (gesture.phase === "tracking") autoscroll.update(event, options.getScroller != null ? options.getScroller() : overflowingMenu(options.menuRef.value));
+		else autoscroll.stop();
+	}
+	function onDocumentUp(event) {
+		if (event.pointerId !== pointerId) return;
+		const point = pointAt(event);
+		step({
+			type: "up",
+			row: point.row,
+			isInMenu: point.isInMenu,
+			isOnTrigger: point.isOnTrigger,
+			time: Date.now()
+		}, event);
+	}
+	function onDocumentCancel(event) {
+		if (event.pointerId === pointerId) step({ type: "cancel" });
+	}
+	function onOtherPointerDown(event) {
+		if (event.pointerId !== pointerId) {
+			ignoredPointerId = event.pointerId;
+			step({ type: "cancel" });
+		}
+	}
+	function onWindowBlur() {
+		step({ type: "cancel" });
+	}
+	function attach(id) {
+		detach?.();
+		const doc = getDocument();
+		const view = doc.defaultView;
+		pointerId = id;
+		doc.addEventListener("pointermove", onDocumentMove, true);
+		doc.addEventListener("pointerup", onDocumentUp, true);
+		doc.addEventListener("pointercancel", onDocumentCancel, true);
+		doc.addEventListener("pointerdown", onOtherPointerDown, true);
+		view?.addEventListener("blur", onWindowBlur);
+		detach = () => {
+			doc.removeEventListener("pointermove", onDocumentMove, true);
+			doc.removeEventListener("pointerup", onDocumentUp, true);
+			doc.removeEventListener("pointercancel", onDocumentCancel, true);
+			doc.removeEventListener("pointerdown", onOtherPointerDown, true);
+			view?.removeEventListener("blur", onWindowBlur);
+		};
+	}
+	function fireLongPress() {
+		if (gesture.phase !== "triggerPress") return;
+		triggerGesture = currentGesture();
+		if (!(options.onTriggerPress?.(gesture.pointerType) ?? false)) {
+			step({ type: "cancel" });
+			return;
+		}
+		stopTouchPrevent = preventTouchScroll(getDocument());
+		step({
+			type: "opened",
+			time: Date.now()
+		});
+	}
+	function consumeIgnored(event) {
+		if (event.pointerId !== ignoredPointerId) return false;
+		ignoredPointerId = null;
+		return true;
+	}
+	function onPointerDown(event) {
+		const menu = options.menuRef.value;
+		if (!isEnabled() || menu == null || consumeIgnored(event)) return;
+		if (gesture.phase !== "idle") {
+			step({ type: "cancel" });
+			return;
+		}
+		const pointerType = normalizePointerType(event.pointerType);
+		if (pointerType == null || pointerType === "mouse" && (event.button ?? 0) !== 0) return;
+		if ((event.target instanceof Element ? event.target : null)?.closest(MENU_PRESS_ROOT_SELECTOR) !== menu) return;
+		if (pointerType !== "mouse") event.preventDefault();
+		attach(event.pointerId);
+		lastPointerEvent = event;
+		step({
+			type: "down",
+			target: "menu",
+			pointerType,
+			row: pointAt(event).row,
+			time: Date.now()
+		}, event);
+	}
+	function onTriggerPointerDown(event) {
+		if (consumeIgnored(event) || !isEnabled() || gesture.phase !== "idle" || options.onTriggerPress == null) return;
+		const pointerType = normalizePointerType(event.pointerType);
+		if (pointerType == null || (event.button ?? 0) !== 0) return;
+		if (pointerType === "mouse" && event.ctrlKey) return;
+		attach(event.pointerId);
+		lastPointerEvent = event;
+		if (pointerType !== "mouse") longPress.start({
+			x: event.clientX,
+			y: event.clientY
+		});
+		step({
+			type: "down",
+			target: "trigger",
+			pointerType,
+			row: null,
+			time: Date.now()
+		}, event);
+	}
+	/** 手指按住触发器是在开菜单，不是要浏览器自己的长按菜单。鼠标右键不碰。 */
+	function onTriggerContextMenu(event) {
+		if (gesture.phase !== "idle" && gesture.pointerType !== "mouse") event.preventDefault();
+	}
+	function isTriggerClickFromPress() {
+		return triggerGesture != null && triggerGesture === currentGesture();
+	}
+	function cancel() {
+		if (gesture.phase !== "idle") step({ type: "cancel" });
+		endGesture();
+	}
+	currentGesture();
+	if (getCurrentScope() != null) onScopeDispose(endGesture);
+	return {
+		cancel,
+		isTriggerClickFromPress,
+		menuProps: {
+			"data-astryx-menu-press": "",
+			"onPointerdown": onPointerDown
+		},
+		onPointerDown,
+		triggerProps: {
+			onContextmenu: onTriggerContextMenu,
+			onPointerdown: onTriggerPointerDown
+		}
+	};
+}
+//#endregion
+export { isMenuPressActivation as a, MENU_PRESS_MARKER as i, MENU_PRESS_SETTLE_MS as n, resetMenuPress as o, menuPressStep as r, useLongPress as s, useMenuPress as t };