niuma-ui 2.0.3 → 2.0.9

package/dist/components/anchor/src/RsAnchor.css

@@ -1,65 +1,96 @@
 
-.rs-anchor[data-v-c95cbe5f] {
+.rs-anchor[data-v-ad557668] {
   position: relative;
   display: flex;
-  gap: 0.7rem;
-  min-width: 8.5rem;
+  gap: var(--rs-anchor-gap);
+  min-width: var(--rs-anchor-min-width);
 }
-.rs-anchor--affix[data-v-c95cbe5f] {
+.rs-anchor--affix[data-v-ad557668] {
   position: sticky;
-  top: var(--rs-space-lg);
+  top: var(--rs-anchor-affix-top);
 }
-.rs-anchor__rail[data-v-c95cbe5f] {
+.rs-anchor--horizontal[data-v-ad557668] {
+  flex-direction: column;
+  min-width: 0;
+  width: 100%;
+}
+.rs-anchor__rail[data-v-ad557668] {
   position: relative;
   flex-shrink: 0;
-  width: 2px;
+  width: var(--rs-anchor-rail-width);
   border-radius: var(--rs-radius-full);
-  background: color-mix(in srgb, var(--rs-border-subtle) 88%, var(--rs-muted));
+  background: var(--rs-anchor-rail);
+}
+.rs-anchor--horizontal .rs-anchor__rail[data-v-ad557668] {
+  width: 100%;
+  height: var(--rs-anchor-rail-width);
 }
-.rs-anchor__ink[data-v-c95cbe5f] {
+.rs-anchor__ink[data-v-ad557668] {
   position: absolute;
   inset-inline-start: 0;
   top: 0;
-  width: 2px;
+  width: var(--rs-anchor-rail-width);
   border-radius: inherit;
-  background: var(--rs-primary);
-  box-shadow: 0 0 0 1px color-mix(in srgb, var(--rs-primary) 18%, transparent);
+  background: var(--rs-anchor-ink);
+  box-shadow: 0 0 0 1px var(--rs-anchor-ink-ring);
   opacity: 0;
+  pointer-events: none;
   transition:
-    transform 180ms ease,
-    height 180ms ease,
-    opacity 180ms ease;
+    transform var(--rs-transition-fast),
+    width var(--rs-transition-fast),
+    height var(--rs-transition-fast),
+    opacity var(--rs-transition-fast);
 }
-.rs-anchor__list[data-v-c95cbe5f] {
+.rs-anchor__list[data-v-ad557668],
+.rs-anchor__item[data-v-ad557668] {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.rs-anchor__list[data-v-ad557668] {
   display: flex;
   flex-direction: column;
   min-width: 0;
   flex: 1;
 }
-.rs-anchor__link[data-v-c95cbe5f] {
+.rs-anchor--horizontal .rs-anchor__list[data-v-ad557668] {
+  flex-direction: row;
+  flex-wrap: wrap;
+  column-gap: var(--rs-space-sm);
+}
+.rs-anchor__link[data-v-ad557668] {
   display: block;
-  padding-block: 0.28rem;
-  color: var(--rs-muted);
+  padding-block: var(--rs-anchor-link-pad-block);
+  padding-inline: var(--rs-anchor-link-pad-inline);
+  color: var(--rs-anchor-link);
   font-size: var(--rs-font-size-xs);
-  line-height: 1.55;
+  line-height: var(--rs-line-height-relaxed);
+  font-weight: var(--rs-font-weight-regular);
   text-decoration: none;
   border-radius: var(--rs-radius-xs);
-  transition: color var(--rs-transition-fast);
+  transition: color var(--rs-transition-fast), background-color var(--rs-transition-fast);
 }
-.rs-anchor__link[data-v-c95cbe5f]:hover {
-  color: var(--rs-text);
+.rs-anchor__link[data-v-ad557668]:hover {
+  color: var(--rs-anchor-link-hover);
 }
-.rs-anchor__link[data-v-c95cbe5f]:focus-visible {
-  outline: 2px solid var(--rs-primary);
+.rs-anchor__link[data-v-ad557668]:focus-visible {
+  outline: var(--rs-focus-ring-width) solid var(--rs-focus-ring);
   outline-offset: 2px;
 }
-.rs-anchor__link--active[data-v-c95cbe5f] {
-  color: var(--rs-primary);
-  font-weight: 600;
+.rs-anchor__link--active[data-v-ad557668] {
+  color: var(--rs-anchor-link-active);
+  font-weight: var(--rs-anchor-link-active-weight);
+}
+.rs-anchor__link--disabled[data-v-ad557668] {
+  opacity: var(--rs-anchor-disabled-opacity);
+  cursor: not-allowed;
+}
+.rs-anchor--lineless .rs-anchor__link--active[data-v-ad557668] {
+  background: var(--rs-anchor-link-active-bg);
 }
-.rs-anchor--lineless .rs-anchor__link[data-v-c95cbe5f] {
-  padding-inline: 0.45rem;
+@media (prefers-reduced-motion: reduce) {
+.rs-anchor__ink[data-v-ad557668],
+  .rs-anchor__link[data-v-ad557668] {
+    transition: none;
 }
-.rs-anchor--lineless .rs-anchor__link--active[data-v-c95cbe5f] {
-  background: color-mix(in srgb, var(--rs-primary) 10%, transparent);
 }

package/dist/components/anchor/src/RsAnchor.d.ts

@@ -1,4 +1,4 @@
-import { type RsAnchorItem } from './anchor-utils';
+import { type RsAnchorDirection, type RsAnchorExpose, type RsAnchorItem, type RsAnchorScrollBehavior } from './anchor-utils';
 type __VLS_Props = {
     items: RsAnchorItem[];
     /** 判定「已滚过」的顶部偏移（px） */
@@ -9,6 +9,8 @@ type __VLS_Props = {
     bounds?: number;
     /** sticky 吸附 */
     affix?: boolean;
+    /** sticky 距滚动容器顶的距离（px），写入 --rs-anchor-affix-top */
+    affixOffset?: number;
     /** 无轨道墨点（仅文字高亮） */
     lineless?: boolean;
     /**
@@ -16,13 +18,30 @@ type __VLS_Props = {
      * Hash 路由（Vue Router createWebHashHistory）必须为 false，否则会丢掉当前路由。
      */
     changeHash?: boolean;
+    /** changeHash 时用 replaceState（默认）还是 pushState */
+    replace?: boolean;
+    direction?: RsAnchorDirection;
+    /** 覆盖滚动行为；未传时减少动态用 auto，否则 smooth */
+    scrollBehavior?: RsAnchorScrollBehavior;
+    /** 覆盖滚动判定后的激活 href */
+    getCurrentAnchor?: (activeHref: string) => string;
     getContainer?: () => HTMLElement | Window | null | undefined;
+    id?: string;
+    ariaLabel?: string;
 };
 type __VLS_ModelProps = {
     modelValue?: string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare var __VLS_1: {
+    item: import("./anchor-utils").RsAnchorFlatItem;
+    active: boolean;
+    href: string;
+};
+type __VLS_Slots = {} & {
+    item?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, RsAnchorExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (href: string) => any;
     click: (href: string, event: MouseEvent) => any;
     "update:modelValue": (value: string) => any;
@@ -31,11 +50,19 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
     onClick?: ((href: string, event: MouseEvent) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
+    replace: boolean;
     offset: number;
     bounds: number;
     affix: boolean;
     lineless: boolean;
     changeHash: boolean;
+    direction: RsAnchorDirection;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/anchor/src/RsAnchor.impl.js

@@ -1,19 +1,18 @@
 import { useRsI18n } from "../../../composables/useRsI18n.js";
-import { computeScrollTopForTarget, flattenAnchorItems, hrefToAnchorId, pickActiveAnchorHref, resolveAnchorContainer, scrollContainerTo, targetTopInContainer } from "./anchor-utils.js";
-import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeModels, nextTick, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, ref, renderList, toDisplayString, unref, useModel, watch } from "vue";
+import { collectAnchorTops, computeScrollTopForTarget, flattenAnchorItems, hrefToAnchorId, isAnchorScrolledToEnd, isAnchorWindow, pickActiveAnchorHref, resolveAnchorContainer, scrollContainerTo, writeAnchorHash } from "./anchor-utils.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, defineComponent, mergeModels, nextTick, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, ref, renderList, renderSlot, toDisplayString, useModel, watch } from "vue";
 //#region src/components/anchor/src/RsAnchor.vue?vue&type=script&setup=true&lang.ts
-var _hoisted_1 = ["aria-label"];
-var _hoisted_2 = {
-	key: 0,
-	class: "rs-anchor__rail",
-	"aria-hidden": "true"
-};
-var _hoisted_3 = { class: "rs-anchor__list" };
-var _hoisted_4 = [
+var _hoisted_1 = ["id", "aria-label"];
+var _hoisted_2 = { class: "rs-anchor__list" };
+var _hoisted_3 = [
 	"href",
 	"data-rs-anchor-href",
+	"aria-current",
+	"aria-disabled",
 	"onClick"
 ];
+var CLICK_LOCK_IDLE_MS = 120;
+var CLICK_LOCK_FALLBACK_MS = 360;
 var RsAnchor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	name: "RsAnchor",
 	__name: "RsAnchor",
@@ -26,6 +25,7 @@ var RsAnchor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineC
 			type: Boolean,
 			default: true
 		},
+		affixOffset: {},
 		lineless: {
 			type: Boolean,
 			default: false
@@ -34,153 +34,271 @@ var RsAnchor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineC
 			type: Boolean,
 			default: true
 		},
-		getContainer: {}
+		replace: {
+			type: Boolean,
+			default: true
+		},
+		direction: { default: "vertical" },
+		scrollBehavior: {},
+		getCurrentAnchor: {},
+		getContainer: {},
+		id: {},
+		ariaLabel: {}
 	}, {
 		"modelValue": { default: "" },
 		"modelModifiers": {}
 	}),
 	emits: /*@__PURE__*/ mergeModels(["change", "click"], ["update:modelValue"]),
-	setup(__props, { emit: __emit }) {
+	setup(__props, { expose: __expose, emit: __emit }) {
 		const props = __props;
 		const activeHref = useModel(__props, "modelValue");
 		const emit = __emit;
 		const { t } = useRsI18n();
 		const rootRef = ref(null);
+		const railRef = ref(null);
 		const inkStyle = ref({});
+		const linkRefs = /* @__PURE__ */ new Map();
 		const flatItems = computed(() => flattenAnchorItems(props.items));
 		const resolvedTargetOffset = computed(() => props.targetOffset ?? props.offset);
+		const navLabel = computed(() => props.ariaLabel || t("anchor.label"));
+		const rootStyle = computed(() => {
+			if (props.affixOffset == null) return void 0;
+			return { "--rs-anchor-affix-top": `${props.affixOffset}px` };
+		});
+		const targetCache = /* @__PURE__ */ new Map();
 		let scrollTarget = null;
-		let ticking = false;
+		let rafId = 0;
+		let resizeObserver = null;
+		let clickLockHref = "";
+		let clickLockTimer = 0;
 		function findTarget(href) {
+			const cached = targetCache.get(href);
+			if (cached?.isConnected) return cached;
 			const id = hrefToAnchorId(href);
 			if (!id || typeof document === "undefined") return null;
-			return document.getElementById(id);
+			const el = document.getElementById(id);
+			if (el) targetCache.set(href, el);
+			else targetCache.delete(href);
+			return el;
 		}
-		function findLinkByHref(root, href) {
-			const links = root.querySelectorAll("[data-rs-anchor-href]");
-			for (const link of links) if (link.dataset.rsAnchorHref === href) return link;
-			return null;
-		}
-		function collectTops(container) {
-			return flatItems.value.map((item) => {
-				const el = findTarget(item.href);
-				if (!el) return null;
-				return {
-					href: item.href,
-					top: targetTopInContainer(el, container)
-				};
-			}).filter((entry) => Boolean(entry));
+		function setLinkRef(href, el) {
+			if (el instanceof HTMLElement) {
+				linkRefs.set(href, el);
+				return;
+			}
+			linkRefs.delete(href);
 		}
 		function setActive(href) {
-			if (!href || href === activeHref.value) return;
-			activeHref.value = href;
-			emit("change", href);
+			const next = props.getCurrentAnchor?.(href) ?? href;
+			if (!next || next === activeHref.value) return;
+			activeHref.value = next;
+			emit("change", next);
 		}
 		function syncInk() {
-			const root = rootRef.value;
-			if (!root || props.lineless) return;
-			const current = activeHref.value || flatItems.value[0]?.href;
+			if (props.lineless) return;
+			const current = activeHref.value || flatItems.value.find((item) => !item.disabled)?.href;
 			if (!current) {
 				inkStyle.value = { opacity: "0" };
 				return;
 			}
-			const link = findLinkByHref(root, current);
-			if (!link) {
+			const link = linkRefs.get(current);
+			const rail = railRef.value;
+			if (!link || !rail) {
 				inkStyle.value = { opacity: "0" };
 				return;
 			}
+			const linkRect = link.getBoundingClientRect();
+			const railRect = rail.getBoundingClientRect();
+			if (props.direction === "horizontal") {
+				inkStyle.value = {
+					opacity: "1",
+					width: `${Math.max(0, linkRect.width)}px`,
+					height: "100%",
+					transform: `translate3d(${linkRect.left - railRect.left}px, 0, 0)`
+				};
+				return;
+			}
 			inkStyle.value = {
 				opacity: "1",
-				transform: `translateY(${link.offsetTop}px)`,
-				height: `${link.offsetHeight}px`
+				width: "100%",
+				height: `${Math.max(0, linkRect.height)}px`,
+				transform: `translate3d(0, ${linkRect.top - railRect.top}px, 0)`
 			};
 		}
+		function releaseClickLock() {
+			clickLockHref = "";
+			if (clickLockTimer) {
+				window.clearTimeout(clickLockTimer);
+				clickLockTimer = 0;
+			}
+			syncFromScroll();
+		}
+		function armClickLock(href) {
+			clickLockHref = href;
+			if (clickLockTimer) window.clearTimeout(clickLockTimer);
+			if (typeof window === "undefined") return;
+			clickLockTimer = window.setTimeout(releaseClickLock, CLICK_LOCK_FALLBACK_MS);
+		}
+		function bumpClickLock() {
+			if (!clickLockHref || typeof window === "undefined") return;
+			if (clickLockTimer) window.clearTimeout(clickLockTimer);
+			clickLockTimer = window.setTimeout(releaseClickLock, CLICK_LOCK_IDLE_MS);
+		}
 		function syncFromScroll() {
-			if (!scrollTarget) return;
-			const next = pickActiveAnchorHref(collectTops(scrollTarget), props.offset + props.bounds);
+			if (!scrollTarget || clickLockHref) return;
+			const next = pickActiveAnchorHref(collectAnchorTops(flatItems.value, scrollTarget, findTarget), props.offset + props.bounds, { atEnd: isAnchorScrolledToEnd(scrollTarget) });
 			if (next) setActive(next);
-			nextTick(syncInk);
+		}
+		function cancelScrollFrame() {
+			if (!rafId) return;
+			cancelAnimationFrame(rafId);
+			rafId = 0;
 		}
 		function onScroll() {
-			if (ticking) return;
-			ticking = true;
-			requestAnimationFrame(() => {
-				ticking = false;
+			if (clickLockHref) {
+				bumpClickLock();
+				return;
+			}
+			if (rafId) return;
+			rafId = requestAnimationFrame(() => {
+				rafId = 0;
 				syncFromScroll();
 			});
 		}
+		function unbindContainer() {
+			cancelScrollFrame();
+			clickLockHref = "";
+			if (clickLockTimer) {
+				window.clearTimeout(clickLockTimer);
+				clickLockTimer = 0;
+			}
+			scrollTarget?.removeEventListener("scroll", onScroll);
+			scrollTarget = null;
+			resizeObserver?.disconnect();
+			resizeObserver = null;
+		}
 		function bindContainer() {
-			unbindContainer();
-			try {
-				scrollTarget = resolveAnchorContainer(props.getContainer);
-			} catch {
-				scrollTarget = null;
+			const next = resolveAnchorContainer(props.getContainer);
+			if (next === scrollTarget && scrollTarget) {
+				syncFromScroll();
 				return;
 			}
+			unbindContainer();
+			scrollTarget = next;
+			if (!scrollTarget) return;
 			scrollTarget.addEventListener("scroll", onScroll, { passive: true });
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(() => {
+					if (clickLockHref) return;
+					onScroll();
+					nextTick(syncInk);
+				});
+				if (!isAnchorWindow(scrollTarget)) resizeObserver.observe(scrollTarget);
+				if (rootRef.value) resizeObserver.observe(rootRef.value);
+			}
 			syncFromScroll();
 		}
-		function unbindContainer() {
-			scrollTarget?.removeEventListener("scroll", onScroll);
-			scrollTarget = null;
-		}
-		function onSelect(href, event) {
-			event.preventDefault();
-			emit("click", href, event);
+		function scrollToHref(href) {
+			if (flatItems.value.find((entry) => entry.href === href)?.disabled) return;
 			const target = findTarget(href);
 			const container = scrollTarget ?? resolveAnchorContainer(props.getContainer);
-			if (target) scrollContainerTo(container, computeScrollTopForTarget(target, container, resolvedTargetOffset.value));
+			if (target && container) scrollContainerTo(container, computeScrollTopForTarget(target, container, resolvedTargetOffset.value), props.scrollBehavior);
 			setActive(href);
-			if (props.changeHash && typeof history !== "undefined") {
-				const id = hrefToAnchorId(href);
-				const url = new URL(window.location.href);
-				url.hash = id;
-				history.replaceState(history.state, "", `${url.pathname}${url.search}#${id}`);
-			}
+			armClickLock(href);
+			if (props.changeHash) writeAnchorHash(href, props.replace);
+			nextTick(syncInk);
+		}
+		function onSelect(href, event, disabled) {
+			event.preventDefault();
+			emit("click", href, event);
+			if (disabled) return;
+			scrollToHref(href);
+		}
+		function onWindowResize() {
+			if (clickLockHref) bumpClickLock();
+			else onScroll();
 			nextTick(syncInk);
 		}
 		onMounted(() => {
 			bindContainer();
-			window.addEventListener("resize", onScroll, { passive: true });
+			nextTick(bindContainer);
+			if (typeof window !== "undefined") window.addEventListener("resize", onWindowResize, { passive: true });
 		});
 		onUnmounted(() => {
 			unbindContainer();
-			window.removeEventListener("resize", onScroll);
+			targetCache.clear();
+			linkRefs.clear();
+			if (typeof window !== "undefined") window.removeEventListener("resize", onWindowResize);
+		});
+		watch(() => props.getContainer?.() ?? null, (next, prev) => {
+			if (next === prev) return;
+			nextTick(bindContainer);
+		});
+		watch(() => flatItems.value.map((item) => `${item.href}\0${item.title}\0${item.depth}\0${item.disabled ? 1 : 0}`).join("\n"), (signature) => {
+			targetCache.clear();
+			if (!signature) {
+				unbindContainer();
+				return;
+			}
+			nextTick(bindContainer);
 		});
 		watch(() => [
-			props.items,
-			props.getContainer,
 			props.offset,
-			props.bounds
+			props.bounds,
+			props.direction,
+			props.lineless
 		], () => {
-			nextTick(bindContainer);
-		}, { deep: true });
+			nextTick(syncFromScroll);
+		});
 		watch(activeHref, () => {
 			nextTick(syncInk);
 		});
+		__expose({ scrollTo: scrollToHref });
 		return (_ctx, _cache) => {
 			return flatItems.value.length ? (openBlock(), createElementBlock("nav", {
 				key: 0,
+				id: __props.id,
 				ref_key: "rootRef",
 				ref: rootRef,
 				class: normalizeClass(["rs-anchor", {
 					"rs-anchor--affix": __props.affix,
-					"rs-anchor--lineless": __props.lineless
+					"rs-anchor--lineless": __props.lineless,
+					"rs-anchor--horizontal": __props.direction === "horizontal"
 				}]),
-				"aria-label": unref(t)("anchor.label")
-			}, [!__props.lineless ? (openBlock(), createElementBlock("div", _hoisted_2, [createElementVNode("span", {
+				style: normalizeStyle(rootStyle.value),
+				"aria-label": navLabel.value
+			}, [!__props.lineless ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				ref_key: "railRef",
+				ref: railRef,
+				class: "rs-anchor__rail",
+				"aria-hidden": "true"
+			}, [createElementVNode("span", {
 				class: "rs-anchor__ink",
 				style: normalizeStyle(inkStyle.value)
-			}, null, 4)])) : createCommentVNode("", true), createElementVNode("div", _hoisted_3, [(openBlock(true), createElementBlock(Fragment, null, renderList(flatItems.value, (item) => {
-				return openBlock(), createElementBlock("a", {
+			}, null, 4)], 512)) : createCommentVNode("", true), createElementVNode("ul", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(flatItems.value, (item) => {
+				return openBlock(), createElementBlock("li", {
 					key: item.href,
-					class: normalizeClass(["rs-anchor__link", { "rs-anchor__link--active": item.href === activeHref.value }]),
-					style: normalizeStyle({ paddingInlineStart: `${.7 + item.depth * .75}rem` }),
+					class: "rs-anchor__item"
+				}, [createElementVNode("a", {
+					class: normalizeClass(["rs-anchor__link", {
+						"rs-anchor__link--active": item.href === activeHref.value,
+						"rs-anchor__link--disabled": item.disabled
+					}]),
+					style: normalizeStyle(__props.direction === "vertical" ? { paddingInlineStart: `calc(var(--rs-anchor-link-pad-inline) + ${item.depth} * var(--rs-anchor-indent))` } : void 0),
 					href: item.href,
+					ref_for: true,
+					ref: (el) => setLinkRef(item.href, el),
 					"data-rs-anchor-href": item.href,
-					onClick: ($event) => onSelect(item.href, $event)
-				}, toDisplayString(item.title), 15, _hoisted_4);
-			}), 128))])], 10, _hoisted_1)) : createCommentVNode("", true);
+					"aria-current": item.href === activeHref.value ? "location" : void 0,
+					"aria-disabled": item.disabled ? "true" : void 0,
+					onClick: ($event) => onSelect(item.href, $event, item.disabled)
+				}, [renderSlot(_ctx.$slots, "item", {
+					item,
+					active: item.href === activeHref.value,
+					href: item.href
+				}, () => [createTextVNode(toDisplayString(item.title), 1)], true)], 14, _hoisted_3)]);
+			}), 128))])], 14, _hoisted_1)) : createCommentVNode("", true);
 		};
 	}
 });

package/dist/components/anchor/src/RsAnchor.js

@@ -3,6 +3,6 @@ import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_exp
 import RsAnchor_vue_vue_type_script_setup_true_lang_default from "./RsAnchor.impl.js";
 
 //#region src/components/anchor/src/RsAnchor.vue
-var RsAnchor_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsAnchor_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-c95cbe5f"]]);
+var RsAnchor_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsAnchor_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-ad557668"]]);
 //#endregion
 export { RsAnchor_default as default };

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

@@ -1,26 +1,58 @@
 export interface RsAnchorItem {
     href: string;
     title: string;
+    disabled?: boolean;
     children?: RsAnchorItem[];
 }
 export interface RsAnchorFlatItem {
     href: string;
     title: string;
     depth: number;
+    disabled?: boolean;
 }
-/** `#overview` / `path#overview` → `overview` */
+export type RsAnchorDirection = 'vertical' | 'horizontal';
+export type RsAnchorScrollBehavior = 'smooth' | 'auto';
+export interface RsAnchorExpose {
+    /** 滚到对应章节并激活。禁用项或找不到目标时不滚动。 */
+    scrollTo: (href: string) => void;
+}
+/** 模板 ref 实例：expose + 根节点 */
+export type RsAnchorInstance = RsAnchorExpose & {
+    $el: HTMLElement;
+};
+/** `#overview` / `path#overview` / `#%E6%A6%82%E8%BF%B0` → `overview` / `概述` */
 export declare function hrefToAnchorId(href: string): string;
 export declare function flattenAnchorItems(items: RsAnchorItem[], depth?: number): RsAnchorFlatItem[];
 /**
  * 滚动监听：取最后一个 top <= offset 的标题。
  * entries 须按文档顺序（与 DOM 一致），top 为相对滚动容器顶部的距离。
+ * atEnd：容器已贴底时最后一节往往到不了判定线，仍应高亮最后一项。
  */
 export declare function pickActiveAnchorHref(entries: ReadonlyArray<{
     href: string;
     top: number;
-}>, offset: number): string;
-export declare function resolveAnchorContainer(getContainer?: () => HTMLElement | Window | null | undefined): HTMLElement | Window;
+}>, offset: number, options?: {
+    atEnd?: boolean;
+}): string;
+/** 用 scrollY / nodeType 判断，避免跨 iframe 的 `instanceof Window`。 */
+export declare function isAnchorWindow(container: unknown): container is Window;
+export declare function resolveAnchorContainer(getContainer?: () => HTMLElement | Window | null | undefined): HTMLElement | Window | null;
 export declare function readContainerScrollTop(container: HTMLElement | Window): number;
+export declare function readContainerScrollExtent(container: HTMLElement | Window): {
+    top: number;
+    max: number;
+};
+/** 贴底判定。slack 吃掉亚像素，避免最后一项永远亮不起来。 */
+export declare function isAnchorScrolledToEnd(container: HTMLElement | Window, slack?: number): boolean;
 export declare function targetTopInContainer(target: HTMLElement, container: HTMLElement | Window): number;
-export declare function scrollContainerTo(container: HTMLElement | Window, top: number): void;
+export declare function prefersAnchorReducedMotion(): boolean;
+export declare function resolveAnchorScrollBehavior(behavior?: RsAnchorScrollBehavior): ScrollBehavior;
+export declare function scrollContainerTo(container: HTMLElement | Window, top: number, behavior?: RsAnchorScrollBehavior): void;
 export declare function computeScrollTopForTarget(target: HTMLElement, container: HTMLElement | Window, targetOffset: number): number;
+export declare function collectAnchorTops(items: ReadonlyArray<{
+    href: string;
+}>, container: HTMLElement | Window, findTarget: (href: string) => HTMLElement | null): Array<{
+    href: string;
+    top: number;
+}>;
+export declare function writeAnchorHash(href: string, replace: boolean): void;