niuma-ui 2.0.4 → 2.0.9

package/dist/components/tooltip/src/RsTooltip.impl.js

@@ -1,18 +1,29 @@
-import { TooltipContent, TooltipPortal, TooltipRoot, TooltipTrigger } from "../../_shared/src/reka.js";
 import { useRsI18n } from "../../../composables/useRsI18n.js";
 import RsIcon_default from "../../icon/src/RsIcon.js";
-import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, toDisplayString, unref, useSlots, withCtx } from "vue";
+import { placeAlignedPopup, toContainerPoint } from "../../_shared/src/overlay-utils.js";
+import { clampTooltipDelay, isKeyboardFocusVisible, rsTooltipGroupKey, tooltipCssLength } from "./tooltip-utils.js";
+import { Fragment, Teleport, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, getCurrentInstance, inject, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, onUpdated, openBlock, ref, renderSlot, toDisplayString, useId, useSlots, watch } from "vue";
 //#region src/components/tooltip/src/RsTooltip.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = {
 	key: 0,
-	class: "rs-tooltip__with-icon"
+	class: "rs-tooltip__label"
 };
-var _hoisted_2 = {
+var _hoisted_2 = ["aria-label"];
+var _hoisted_3 = [
+	"id",
+	"data-side",
+	"data-align",
+	"data-ready",
+	"data-rs-theme",
+	"dir"
+];
+var _hoisted_4 = {
 	key: 0,
-	class: "rs-tooltip__label"
+	class: "rs-tooltip__arrow",
+	"aria-hidden": "true"
 };
-var _hoisted_3 = ["aria-label"];
 var RsTooltip_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsTooltip",
 	__name: "RsTooltip",
 	props: {
 		content: {},
@@ -23,10 +34,7 @@ var RsTooltip_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ define
 			type: Boolean,
 			default: false
 		},
-		ignoreNonKeyboardFocus: {
-			type: Boolean,
-			default: true
-		},
+		ignoreNonKeyboardFocus: { type: Boolean },
 		nowrap: {
 			type: Boolean,
 			default: false
@@ -36,54 +44,415 @@ var RsTooltip_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ define
 			default: false
 		},
 		iconName: { default: "info" },
-		ariaLabel: {}
+		ariaLabel: {},
+		open: { type: Boolean },
+		delayDuration: {},
+		interactive: {
+			type: Boolean,
+			default: true
+		},
+		arrow: {
+			type: Boolean,
+			default: false
+		},
+		maxWidth: {},
+		getContainer: {},
+		id: {}
 	},
-	setup(__props) {
+	emits: ["update:open", "openChange"],
+	setup(__props, { expose: __expose, emit: __emit }) {
 		const props = __props;
+		const emit = __emit;
+		const instance = getCurrentInstance();
 		const slots = useSlots();
 		const { t } = useRsI18n();
+		const group = inject(rsTooltipGroupKey, null);
+		const autoId = useId();
+		const rootRef = ref(null);
+		const triggerRef = ref(null);
+		const contentRef = ref(null);
+		const innerOpen = ref(false);
+		const positioned = ref(false);
+		const placedSide = ref(props.side);
+		const popupStyle = ref({});
+		const popupTheme = ref("");
+		const popupDir = ref("ltr");
+		/** 布尔 prop 未传时运行时是 false，不能用 undefined 判断受控。看 vnode 上有没有这次传入。 */
+		function passedProp(name) {
+			const raw = instance?.vnode.props;
+			if (!raw) return false;
+			if (Object.prototype.hasOwnProperty.call(raw, name)) return true;
+			const kebab = name.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+			return Object.prototype.hasOwnProperty.call(raw, kebab);
+		}
+		const isControlled = computed(() => {
+			props.open;
+			return passedProp("open") || passedProp("onUpdate:open");
+		});
+		const visible = computed(() => isControlled.value ? Boolean(props.open) : innerOpen.value);
 		const hasLabelSlot = computed(() => Boolean(slots.default));
+		const hasBody = computed(() => Boolean(props.content?.trim()) || Boolean(slots.content));
+		const tipDomId = computed(() => props.id?.trim() || `rs-tooltip-${autoId}`);
 		const iconAriaLabel = computed(() => props.ariaLabel?.trim() || props.content?.trim() || t("tooltip.help", "Help"));
-		return (_ctx, _cache) => {
-			return openBlock(), createBlock(unref(TooltipRoot), {
-				disabled: __props.disabled,
-				"ignore-non-keyboard-focus": __props.ignoreNonKeyboardFocus
+		const ignoreFocus = computed(() => {
+			props.ignoreNonKeyboardFocus;
+			if (passedProp("ignoreNonKeyboardFocus")) return Boolean(props.ignoreNonKeyboardFocus);
+			return group?.ignoreNonKeyboardFocus ?? true;
+		});
+		const openDelay = computed(() => clampTooltipDelay(props.delayDuration ?? group?.delayDuration, 300));
+		const contentStyle = computed(() => {
+			const style = { ...popupStyle.value };
+			if (props.maxWidth != null && props.maxWidth !== "") style.maxWidth = tooltipCssLength(props.maxWidth);
+			return style;
+		});
+		const portalTarget = computed(() => resolvePortal() ?? "body");
+		let applied = false;
+		let followBound = false;
+		let hovering = false;
+		let boundEl = null;
+		let openTimer = null;
+		let closeTimer = null;
+		let posRaf = 0;
+		let resizeObserver = null;
+		function currentTrigger() {
+			if (props.icon) return triggerRef.value;
+			const child = rootRef.value?.firstElementChild;
+			return child instanceof HTMLElement ? child : null;
+		}
+		function clearOpenTimer() {
+			if (openTimer == null) return;
+			clearTimeout(openTimer);
+			openTimer = null;
+		}
+		function clearCloseTimer() {
+			if (closeTimer == null) return;
+			clearTimeout(closeTimer);
+			closeTimer = null;
+		}
+		function clearTimers() {
+			clearOpenTimer();
+			clearCloseTimer();
+		}
+		function cancelRaf() {
+			if (typeof window === "undefined" || !posRaf) return;
+			window.cancelAnimationFrame(posRaf);
+			posRaf = 0;
+		}
+		function readDir(el) {
+			if (typeof document === "undefined") return "ltr";
+			if (el?.closest("[dir=\"rtl\"], [data-rs-dir=\"rtl\"]")) return "rtl";
+			const root = document.documentElement;
+			if (root.dir === "rtl" || root.getAttribute("data-rs-dir") === "rtl") return "rtl";
+			return "ltr";
+		}
+		function shouldDescribe() {
+			if (!props.icon) return true;
+			const name = iconAriaLabel.value.trim();
+			const body = props.content?.trim() || "";
+			if (!body) return true;
+			return name !== body;
+		}
+		function syncDescribedBy(on) {
+			const el = currentTrigger();
+			if (!el) return;
+			const id = tipDomId.value;
+			const parts = (el.getAttribute("aria-describedby") || "").split(/\s+/).filter((part) => part && part !== id);
+			if (on && shouldDescribe()) parts.push(id);
+			if (parts.length) el.setAttribute("aria-describedby", parts.join(" "));
+			else el.removeAttribute("aria-describedby");
+		}
+		function resolvePortal() {
+			if (typeof document === "undefined") return null;
+			try {
+				return props.getContainer?.() ?? null;
+			} catch {
+				return null;
+			}
+		}
+		function updatePosition() {
+			if (typeof window === "undefined" || !applied) return;
+			const trigger = currentTrigger();
+			const popup = contentRef.value;
+			if (!trigger || !popup) return;
+			const anchor = trigger.getBoundingClientRect();
+			const size = popup.getBoundingClientRect();
+			const rtl = readDir(trigger) === "rtl";
+			const box = placeAlignedPopup({
+				top: anchor.top,
+				left: anchor.left,
+				width: anchor.width,
+				height: anchor.height
 			}, {
-				default: withCtx(() => [__props.icon ? (openBlock(), createElementBlock("span", _hoisted_1, [hasLabelSlot.value ? (openBlock(), createElementBlock("span", _hoisted_2, [renderSlot(_ctx.$slots, "default")])) : createCommentVNode("", true), createVNode(unref(TooltipTrigger), { "as-child": "" }, {
-					default: withCtx(() => [createElementVNode("button", {
-						type: "button",
-						class: "rs-tooltip__icon-trigger",
-						"aria-label": iconAriaLabel.value
-					}, [createVNode(RsIcon_default, {
-						name: __props.iconName,
-						size: 12
-					}, null, 8, ["name"])], 8, _hoisted_3)]),
-					_: 1
-				})])) : (openBlock(), createBlock(unref(TooltipTrigger), {
-					key: 1,
-					"as-child": ""
-				}, {
-					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
-					_: 3
-				})), createVNode(unref(TooltipPortal), null, {
-					default: withCtx(() => [createVNode(unref(TooltipContent), {
-						class: normalizeClass(["rs-tooltip__content", { "rs-tooltip__content--nowrap": __props.nowrap }]),
-						side: __props.side,
-						align: __props.align,
-						"side-offset": __props.sideOffset
-					}, {
-						default: withCtx(() => [renderSlot(_ctx.$slots, "content", {}, () => [createTextVNode(toDisplayString(__props.content), 1)])]),
-						_: 3
-					}, 8, [
-						"class",
-						"side",
-						"align",
-						"side-offset"
-					])]),
-					_: 3
-				})]),
-				_: 3
-			}, 8, ["disabled", "ignore-non-keyboard-focus"]);
+				width: size.width,
+				height: size.height
+			}, {
+				width: window.innerWidth,
+				height: window.innerHeight
+			}, {
+				side: props.side,
+				align: props.align,
+				sideOffset: props.sideOffset,
+				padding: 8,
+				rtl
+			});
+			const container = popup.parentElement;
+			const origin = container && container !== document.body && container !== document.documentElement ? {
+				top: container.getBoundingClientRect().top,
+				left: container.getBoundingClientRect().left
+			} : null;
+			const point = toContainerPoint(Math.round(box.top), Math.round(box.left), origin);
+			popupTheme.value = trigger.closest("[data-rs-theme]")?.getAttribute("data-rs-theme") || "";
+			popupDir.value = rtl ? "rtl" : "ltr";
+			const top = `${point.top}px`;
+			const left = `${point.left}px`;
+			if (positioned.value && popupStyle.value.top === top && popupStyle.value.left === left && placedSide.value === box.side) return;
+			placedSide.value = box.side;
+			popupStyle.value = {
+				top,
+				left
+			};
+			positioned.value = true;
+		}
+		function schedulePosition() {
+			if (typeof window === "undefined" || posRaf || !applied) return;
+			posRaf = window.requestAnimationFrame(() => {
+				posRaf = 0;
+				if (applied) updatePosition();
+			});
+		}
+		function observeContent() {
+			resizeObserver?.disconnect();
+			resizeObserver = null;
+			const el = contentRef.value;
+			if (!el || typeof ResizeObserver === "undefined") return;
+			resizeObserver = new ResizeObserver(() => schedulePosition());
+			resizeObserver.observe(el);
+		}
+		function bindFollow(on) {
+			if (typeof window === "undefined" || typeof document === "undefined") return;
+			if (on === followBound) return;
+			followBound = on;
+			const passiveCapture = {
+				capture: true,
+				passive: true
+			};
+			if (on) {
+				window.addEventListener("scroll", schedulePosition, passiveCapture);
+				window.addEventListener("resize", schedulePosition, passiveCapture);
+				window.addEventListener("keydown", onDocKeydown, true);
+				document.addEventListener("pointerdown", onDocPointerDown, true);
+				return;
+			}
+			window.removeEventListener("scroll", schedulePosition, passiveCapture);
+			window.removeEventListener("resize", schedulePosition, passiveCapture);
+			window.removeEventListener("keydown", onDocKeydown, true);
+			document.removeEventListener("pointerdown", onDocPointerDown, true);
+			cancelRaf();
+			resizeObserver?.disconnect();
+			resizeObserver = null;
+		}
+		function syncSideEffects(next) {
+			if (applied === next) return;
+			applied = next;
+			if (next) {
+				placedSide.value = props.side;
+				group?.notifyOpen();
+				bindFollow(true);
+				nextTick(() => {
+					if (!applied) return;
+					syncDescribedBy(true);
+					updatePosition();
+					observeContent();
+				});
+				return;
+			}
+			group?.notifyClose();
+			syncDescribedBy(false);
+			positioned.value = false;
+			bindFollow(false);
+		}
+		function requestOpen(next) {
+			if (next && (props.disabled || !hasBody.value)) return;
+			if (visible.value === next) return;
+			if (!isControlled.value) innerOpen.value = next;
+			emit("update:open", next);
+			emit("openChange", next);
+		}
+		function scheduleOpen() {
+			clearCloseTimer();
+			if (props.disabled || !hasBody.value || visible.value) return;
+			clearOpenTimer();
+			const delay = group?.shouldSkipDelay() ? 0 : openDelay.value;
+			openTimer = setTimeout(() => {
+				openTimer = null;
+				requestOpen(true);
+			}, delay);
+		}
+		function scheduleClose() {
+			clearOpenTimer();
+			if (!visible.value) return;
+			clearCloseTimer();
+			const grace = props.interactive ? 120 : 0;
+			if (grace <= 0) {
+				requestOpen(false);
+				return;
+			}
+			closeTimer = setTimeout(() => {
+				closeTimer = null;
+				requestOpen(false);
+			}, grace);
+		}
+		function closeNow() {
+			clearTimers();
+			hovering = false;
+			requestOpen(false);
+		}
+		function onPointerEnter(event) {
+			if (event.pointerType === "touch") return;
+			hovering = true;
+			scheduleOpen();
+		}
+		function onPointerMove(event) {
+			if (event.pointerType === "touch") return;
+			if (hovering) return;
+			hovering = true;
+			scheduleOpen();
+		}
+		function onPointerLeave(event) {
+			if (event.pointerType === "touch") return;
+			hovering = false;
+			scheduleClose();
+		}
+		function onPointerDown(event) {
+			if (event.pointerType !== "touch") return;
+			if (visible.value) closeNow();
+			else scheduleOpen();
+		}
+		function onFocus(event) {
+			if (!isKeyboardFocusVisible(event.target instanceof Element ? event.target : event.currentTarget, ignoreFocus.value)) return;
+			scheduleOpen();
+		}
+		function onBlur() {
+			hovering = false;
+			scheduleClose();
+		}
+		function onContentEnter() {
+			if (!props.interactive) return;
+			clearCloseTimer();
+		}
+		function onContentLeave() {
+			if (!props.interactive) return;
+			scheduleClose();
+		}
+		function onDocKeydown(event) {
+			if (event.key !== "Escape" || !applied) return;
+			event.preventDefault();
+			event.stopPropagation();
+			closeNow();
+		}
+		function onDocPointerDown(event) {
+			const target = event.target;
+			if (!(target instanceof Node)) return;
+			if (currentTrigger()?.contains(target)) return;
+			if (contentRef.value?.contains(target)) return;
+			closeNow();
+		}
+		function unbindTrigger() {
+			if (!boundEl) return;
+			boundEl.removeEventListener("pointerenter", onPointerEnter);
+			boundEl.removeEventListener("pointermove", onPointerMove);
+			boundEl.removeEventListener("pointerleave", onPointerLeave);
+			boundEl.removeEventListener("pointerdown", onPointerDown);
+			boundEl.removeEventListener("focus", onFocus);
+			boundEl.removeEventListener("blur", onBlur);
+			boundEl = null;
+		}
+		function bindTrigger(el) {
+			if (boundEl === el) return;
+			unbindTrigger();
+			if (!el) return;
+			boundEl = el;
+			el.addEventListener("pointerenter", onPointerEnter);
+			el.addEventListener("pointermove", onPointerMove);
+			el.addEventListener("pointerleave", onPointerLeave);
+			el.addEventListener("pointerdown", onPointerDown);
+			el.addEventListener("focus", onFocus);
+			el.addEventListener("blur", onBlur);
+		}
+		function syncTriggerBinding() {
+			bindTrigger(currentTrigger());
+		}
+		watch(visible, (next) => syncSideEffects(next), { immediate: true });
+		watch(() => props.disabled || !hasBody.value, (blocked) => {
+			if (!blocked) return;
+			clearTimers();
+			requestOpen(false);
+		});
+		watch(() => [
+			props.side,
+			props.align,
+			props.sideOffset
+		], () => {
+			if (applied) schedulePosition();
+		});
+		onMounted(syncTriggerBinding);
+		onUpdated(syncTriggerBinding);
+		onBeforeUnmount(() => {
+			clearTimers();
+			unbindTrigger();
+			if (applied) {
+				applied = false;
+				group?.notifyClose();
+				syncDescribedBy(false);
+				bindFollow(false);
+			}
+		});
+		__expose({
+			open: () => {
+				clearTimers();
+				requestOpen(true);
+			},
+			close: () => closeNow()
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: normalizeClass(["rs-tooltip", {
+					"rs-tooltip--icon": __props.icon,
+					"rs-tooltip__with-icon": __props.icon
+				}])
+			}, [__props.icon ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [hasLabelSlot.value ? (openBlock(), createElementBlock("span", _hoisted_1, [renderSlot(_ctx.$slots, "default", {}, void 0, true)])) : createCommentVNode("", true), createElementVNode("button", {
+				ref_key: "triggerRef",
+				ref: triggerRef,
+				type: "button",
+				class: "rs-tooltip__icon-trigger",
+				"aria-label": iconAriaLabel.value
+			}, [createVNode(RsIcon_default, {
+				name: __props.iconName,
+				size: 12
+			}, null, 8, ["name"])], 8, _hoisted_2)], 64)) : renderSlot(_ctx.$slots, "default", {}, void 0, true, 1), visible.value ? (openBlock(), createBlock(Teleport, {
+				key: 2,
+				to: portalTarget.value
+			}, [createElementVNode("div", {
+				id: tipDomId.value,
+				ref_key: "contentRef",
+				ref: contentRef,
+				role: "tooltip",
+				class: normalizeClass(["rs-tooltip__content", {
+					"rs-tooltip__content--nowrap": __props.nowrap,
+					"rs-tooltip__content--arrow": __props.arrow,
+					"rs-tooltip__content--interactive": __props.interactive
+				}]),
+				"data-side": placedSide.value,
+				"data-align": __props.align,
+				"data-ready": positioned.value ? "true" : "false",
+				"data-rs-theme": popupTheme.value || void 0,
+				dir: popupDir.value,
+				style: normalizeStyle(contentStyle.value),
+				onPointerenter: onContentEnter,
+				onPointerleave: onContentLeave
+			}, [renderSlot(_ctx.$slots, "content", {}, () => [createTextVNode(toDisplayString(__props.content), 1)], true), __props.arrow ? (openBlock(), createElementBlock("span", _hoisted_4)) : createCommentVNode("", true)], 46, _hoisted_3)], 8, ["to"])) : createCommentVNode("", true)], 2);
 		};
 	}
 });

package/dist/components/tooltip/src/RsTooltip.js

@@ -1,7 +1,8 @@
 import './RsTooltip.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
 import RsTooltip_vue_vue_type_script_setup_true_lang_default from "./RsTooltip.impl.js";
 
 //#region src/components/tooltip/src/RsTooltip.vue
-var RsTooltip_default = RsTooltip_vue_vue_type_script_setup_true_lang_default;
+var RsTooltip_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsTooltip_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-3bb6995e"]]);
 //#endregion
 export { RsTooltip_default as default };

package/dist/components/tooltip/src/RsTooltipProvider.d.ts

@@ -2,14 +2,14 @@ type __VLS_Props = {
     delayDuration?: number;
     skipDelayDuration?: number;
     /**
-     * 仅键盘 focus-visible 时因焦点打开 tip。
-     * 默认 true：避免 Dialog/Popover 关闭回焦、切页签等非键盘焦点误开（对齐 Reka 推荐与 RsButton tooltip）。
+     * 仅键盘 :focus-visible 时因焦点打开。
+     * 单条 RsTooltip 传了同名 prop 时以单条为准。
      */
     ignoreNonKeyboardFocus?: boolean;
 };
-declare var __VLS_8: {};
+declare var __VLS_1: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     ignoreNonKeyboardFocus: boolean;

package/dist/components/tooltip/src/RsTooltipProvider.impl.js

@@ -1,7 +1,8 @@
-import { TooltipProvider } from "../../_shared/src/reka.js";
-import { createBlock, defineComponent, openBlock, renderSlot, unref, withCtx } from "vue";
+import { clampTooltipDelay, rsTooltipGroupKey } from "./tooltip-utils.js";
+import { defineComponent, onUnmounted, provide, ref, renderSlot } from "vue";
 //#region src/components/tooltip/src/RsTooltipProvider.vue?vue&type=script&setup=true&lang.ts
 var RsTooltipProvider_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsTooltipProvider",
 	__name: "RsTooltipProvider",
 	props: {
 		delayDuration: { default: 300 },
@@ -12,19 +13,55 @@ var RsTooltipProvider_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*
 		}
 	},
 	setup(__props) {
+		const props = __props;
+		const warm = ref(false);
+		let openCount = 0;
+		let graceTimer = null;
+		function clearGrace() {
+			if (graceTimer == null) return;
+			clearTimeout(graceTimer);
+			graceTimer = null;
+		}
+		function notifyOpen() {
+			openCount += 1;
+			clearGrace();
+			warm.value = true;
+		}
+		function notifyClose() {
+			openCount = Math.max(0, openCount - 1);
+			if (openCount > 0) return;
+			clearGrace();
+			const wait = clampTooltipDelay(props.skipDelayDuration, 0);
+			if (wait <= 0) {
+				warm.value = false;
+				return;
+			}
+			graceTimer = setTimeout(() => {
+				graceTimer = null;
+				if (openCount === 0) warm.value = false;
+			}, wait);
+		}
+		provide(rsTooltipGroupKey, {
+			get delayDuration() {
+				return clampTooltipDelay(props.delayDuration, 300);
+			},
+			get skipDelayDuration() {
+				return clampTooltipDelay(props.skipDelayDuration, 0);
+			},
+			get ignoreNonKeyboardFocus() {
+				return props.ignoreNonKeyboardFocus;
+			},
+			shouldSkipDelay: () => warm.value,
+			notifyOpen,
+			notifyClose
+		});
+		onUnmounted(() => {
+			clearGrace();
+			openCount = 0;
+			warm.value = false;
+		});
 		return (_ctx, _cache) => {
-			return openBlock(), createBlock(unref(TooltipProvider), {
-				"delay-duration": __props.delayDuration,
-				"skip-delay-duration": __props.skipDelayDuration,
-				"ignore-non-keyboard-focus": __props.ignoreNonKeyboardFocus
-			}, {
-				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
-				_: 3
-			}, 8, [
-				"delay-duration",
-				"skip-delay-duration",
-				"ignore-non-keyboard-focus"
-			]);
+			return renderSlot(_ctx.$slots, "default");
 		};
 	}
 });

package/dist/components/tooltip/src/tooltip-utils.d.ts

@@ -0,0 +1,30 @@
+import type { InjectionKey } from 'vue';
+export declare const RS_TOOLTIP_SIDES: readonly ["top", "right", "bottom", "left"];
+export declare const RS_TOOLTIP_ALIGNS: readonly ["start", "center", "end"];
+export type RsTooltipSide = (typeof RS_TOOLTIP_SIDES)[number];
+export type RsTooltipAlign = (typeof RS_TOOLTIP_ALIGNS)[number];
+export declare const RS_TOOLTIP_DEFAULT_DELAY = 300;
+export declare const RS_TOOLTIP_DEFAULT_SKIP_DELAY = 0;
+export declare const RS_TOOLTIP_MAX_DELAY_MS = 60000;
+/** 指针从触发器移到气泡的空隙。关掉 interactive 时为 0。 */
+export declare const RS_TOOLTIP_POINTER_GRACE_MS = 120;
+export type RsTooltipGetContainer = () => HTMLElement | null | undefined;
+export interface RsTooltipExpose {
+    open: () => void;
+    close: () => void;
+}
+/** 模板 ref：expose。根在非图标模式下是 display:contents，不把 $el 当布局盒。 */
+export type RsTooltipInstance = RsTooltipExpose;
+export interface RsTooltipGroup {
+    readonly delayDuration: number;
+    readonly skipDelayDuration: number;
+    readonly ignoreNonKeyboardFocus: boolean;
+    shouldSkipDelay: () => boolean;
+    notifyOpen: () => void;
+    notifyClose: () => void;
+}
+export declare const rsTooltipGroupKey: InjectionKey<RsTooltipGroup>;
+export declare function clampTooltipDelay(value: number | undefined, fallback: number): number;
+export declare function tooltipCssLength(value: number | string): string;
+/** ignore 为 true 时只认 :focus-visible，避免对话框回焦误开。 */
+export declare function isKeyboardFocusVisible(el: EventTarget | null, ignoreNonKeyboardFocus: boolean): boolean;

package/dist/components/tooltip/src/tooltip-utils.js

@@ -0,0 +1,23 @@
+//#region src/components/tooltip/src/tooltip-utils.ts
+var RS_TOOLTIP_MAX_DELAY_MS = 6e4;
+var rsTooltipGroupKey = Symbol("rs-tooltip-group");
+function clampTooltipDelay(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	return Math.min(RS_TOOLTIP_MAX_DELAY_MS, Math.max(0, value));
+}
+function tooltipCssLength(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return `${value}px`;
+	return String(value).trim() || "0px";
+}
+/** ignore 为 true 时只认 :focus-visible，避免对话框回焦误开。 */
+function isKeyboardFocusVisible(el, ignoreNonKeyboardFocus) {
+	if (!(el instanceof Element)) return false;
+	if (!ignoreNonKeyboardFocus) return true;
+	try {
+		return el.matches(":focus-visible");
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { RS_TOOLTIP_MAX_DELAY_MS, clampTooltipDelay, isKeyboardFocusVisible, rsTooltipGroupKey, tooltipCssLength };

package/dist/components/tree/index.d.ts

@@ -1,3 +1,3 @@
 export { default as RsTree } from './src/RsTree.js';
-export type { RsTreeCheckState, RsTreeDragTrigger, RsTreeDropPosition, RsTreeFieldNames, RsTreeFlatNode, RsTreeFocusMove, RsTreeNode, RsTreeNodeIndex, RsTreeSize, } from './src/tree-utils';
-export { buildTreeNodeIndex, collectDescendantKeys, collectExpandableKeys, collectHalfCheckedKeys, defaultTreeFilterNode, filterTreeNodes, flattenTreeNodeIds, flattenVisibleTreeNodes, getTreeChildren, getTreeKey, getTreeLabel, hasTreeChildren, isTreeAncestorKey, resolveAccordionExpandedKeys, resolveTreeCheckState, resolveTreeFieldNames, resolveTreeFocusKey, resolveTreeIndent, resolveTreeRowHeight, resolveTreeVirtualEnabled, sliceVirtualTreeNodes, splitTreeLabelHighlight, shouldShowTreeCheckbox, toggleTreeCheck, } from './src/tree-utils';
+export type { RsTreeCheckState, RsTreeDragTrigger, RsTreeDropPosition, RsTreeExpose, RsTreeFieldNames, RsTreeFlatNode, RsTreeFocusMove, RsTreeInstance, RsTreeNode, RsTreeNodeIndex, RsTreeSize, } from './src/tree-utils';
+export { buildTreeNodeIndex, collectDescendantKeys, collectExpandableKeys, collectHalfCheckedKeys, defaultTreeFilterNode, filterTreeNodes, flattenTreeNodeIds, flattenVisibleTreeNodes, getTreeChildren, getTreeKey, getTreeLabel, hasTreeChildren, isTreeAncestorKey, resolveAccordionExpandedKeys, resolveTreeCheckState, resolveTreeFieldNames, resolveTreeFocusKey, resolveTreeIndent, resolveTreeTypeaheadKey, resolveTreeRowHeight, resolveTreeVirtualEnabled, sliceVirtualTreeNodes, splitTreeLabelHighlight, shouldShowTreeCheckbox, toggleTreeCheck, } from './src/tree-utils';