@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/index-bar/IndexBar.vue.d.ts

@@ -0,0 +1,23 @@
+import type { Key } from '../_util/type';
+import type { IndexBarExpose, IndexBarProps, IndexBarSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = IndexBarSlots;
+declare const __VLS_base: import("vue").DefineComponent<IndexBarProps, IndexBarExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (index: Key) => any;
+    change: (index: Key) => any;
+}, string, import("vue").PublicProps, Readonly<IndexBarProps> & Readonly<{
+    onSelect?: ((index: Key) => any) | undefined;
+    onChange?: ((index: Key) => any) | undefined;
+}>, {
+    sticky: boolean;
+    stickyOffsetTop: number;
+}, {}, {}, {}, 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/index-bar/IndexBar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,189 @@
+import { clamp, getScrollParent, getScrollTop, preventDefault, setScrollTop } from "../_util/index.js";
+import { useEventListener } from "../_util/hooks/useEventListener.js";
+import { useTouch } from "../_util/hooks/useTouch.js";
+import { indexBarContextKey } from "./context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, Transition, computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, provide, ref, renderList, renderSlot, shallowRef, toDisplayString, watch, withCtx } from "vue";
+// src/index-bar/IndexBar.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "am-index-bar-float" };
+var _hoisted_2 = ["data-position"];
+var IndexBar_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmIndexBar",
+	inheritAttrs: false,
+	__name: "IndexBar",
+	props: {
+		indexList: {},
+		sticky: {
+			type: Boolean,
+			default: true
+		},
+		stickyOffsetTop: { default: 0 },
+		zIndex: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["select", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const rootRef = ref();
+		const sidebarRef = ref();
+		const anchors = shallowRef([]);
+		const activeIndex = ref();
+		const viewportHeight = ref();
+		/** nearest scroll container (an element or the window), resolved on mount */
+		const scroller = shallowRef();
+		function sortAnchors(list) {
+			return list.slice().sort((a, b) => {
+				const elA = a.el();
+				const elB = b.el();
+				if (!elA || !elB) return 0;
+				return elA.compareDocumentPosition(elB) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+			});
+		}
+		provide(indexBarContextKey, {
+			register: (anchor) => {
+				anchors.value = sortAnchors([...anchors.value, anchor]);
+				nextTick(updateActive);
+			},
+			unregister: (anchor) => {
+				anchors.value = anchors.value.filter((item) => item !== anchor);
+			},
+			activeIndex,
+			sticky: computed(() => props.sticky)
+		});
+		const indexList = computed(() => props.indexList ?? anchors.value.map((anchor) => anchor.index()));
+		/** top of the scroll viewport: `0` for the window */
+		function getScrollerTop() {
+			const el = scroller.value;
+			return el instanceof Element ? el.getBoundingClientRect().top : 0;
+		}
+		function updateActive() {
+			if (!scroller.value) return;
+			const top = getScrollerTop() + props.stickyOffsetTop;
+			let active;
+			for (const anchor of anchors.value) {
+				const el = anchor.el();
+				if (!el) continue;
+				if (el.getBoundingClientRect().top <= top + 1) active = anchor.index();
+				else break;
+			}
+			if (active !== activeIndex.value) {
+				activeIndex.value = active;
+				if (active !== void 0) emit("change", active);
+			}
+		}
+		function updateViewport() {
+			const el = scroller.value;
+			if (!el) return;
+			const height = el instanceof Element ? el.clientHeight : el.innerHeight;
+			viewportHeight.value = height ? Math.max(height - props.stickyOffsetTop, 0) : void 0;
+		}
+		function handleResize() {
+			updateViewport();
+			updateActive();
+		}
+		useEventListener("scroll", updateActive, {
+			target: scroller,
+			passive: true
+		});
+		useEventListener("resize", handleResize);
+		onMounted(() => {
+			scroller.value = getScrollParent(rootRef.value);
+			handleResize();
+		});
+		watch(() => props.stickyOffsetTop, handleResize);
+		function scrollTo(index) {
+			const el = anchors.value.find((anchor) => String(anchor.index()) === String(index))?.el();
+			if (!el || !scroller.value) return;
+			const offset = el.getBoundingClientRect().top - getScrollerTop() - props.stickyOffsetTop;
+			setScrollTop(scroller.value, Math.max(getScrollTop(scroller.value) + offset, 0));
+			updateActive();
+		}
+		const touch = useTouch();
+		const touching = ref(false);
+		const touchingIndex = ref();
+		let touchEndTime = 0;
+		function select(index) {
+			if (index === void 0 || index === touchingIndex.value) return;
+			touchingIndex.value = index;
+			scrollTo(index);
+			emit("select", index);
+		}
+		function getIndexByPoint(clientY) {
+			const list = indexList.value;
+			const rect = sidebarRef.value?.getBoundingClientRect();
+			if (!rect || !rect.height || !list.length) return void 0;
+			return list[clamp(Math.floor((clientY - rect.top) / (rect.height / list.length)), 0, list.length - 1)];
+		}
+		function getIndexByTarget(target) {
+			const el = target?.closest?.(".am-index-bar-index");
+			const position = el ? Number(el.dataset.position) : NaN;
+			return Number.isNaN(position) ? void 0 : indexList.value[position];
+		}
+		function handleTouchStart(event) {
+			touch.start(event);
+			touching.value = true;
+			touchingIndex.value = void 0;
+			select(getIndexByPoint(touch.startY.value) ?? getIndexByTarget(event.target));
+		}
+		function handleTouchMove(event) {
+			if (!touching.value) return;
+			touch.move(event);
+			preventDefault(event);
+			select(getIndexByPoint(touch.startY.value + touch.deltaY.value));
+		}
+		function handleTouchEnd() {
+			touching.value = false;
+			touchEndTime = Date.now();
+		}
+		function handleClick(event) {
+			if (Date.now() - touchEndTime < 500) return;
+			touchingIndex.value = void 0;
+			select(getIndexByTarget(event.target));
+		}
+		const rootStyle = computed(() => [{
+			"--am-index-bar-sticky-offset-top": `${props.stickyOffsetTop}px`,
+			"--am-index-bar-viewport-height": viewportHeight.value !== void 0 ? `${viewportHeight.value}px` : void 0,
+			"--am-index-bar-z-index": props.zIndex
+		}, props.styles?.root]);
+		__expose({ scrollTo });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: ["am-index-bar", [__props.rootClass, __props.classes?.root]],
+				style: rootStyle.value
+			}), [createElementVNode("div", _hoisted_1, [indexList.value.length ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				ref_key: "sidebarRef",
+				ref: sidebarRef,
+				class: normalizeClass(["am-index-bar-sidebar", __props.classes?.sidebar]),
+				style: normalizeStyle(__props.styles?.sidebar),
+				onTouchstart: handleTouchStart,
+				onTouchmove: handleTouchMove,
+				onTouchend: handleTouchEnd,
+				onTouchcancel: handleTouchEnd,
+				onClick: handleClick
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(indexList.value, (index, position) => {
+				return openBlock(), createElementBlock("span", {
+					key: index,
+					class: normalizeClass(["am-index-bar-index", [{ "am-index-bar-index-active": index === activeIndex.value }, __props.classes?.index]]),
+					style: normalizeStyle(__props.styles?.index),
+					"data-position": position
+				}, toDisplayString(index), 15, _hoisted_2);
+			}), 128))], 38)) : createCommentVNode("", true), createVNode(Transition, { name: "am-fade" }, {
+				default: withCtx(() => [touching.value && touchingIndex.value !== void 0 ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(["am-index-bar-hint", __props.classes?.hint]),
+					style: normalizeStyle(__props.styles?.hint)
+				}, toDisplayString(touchingIndex.value), 7)) : createCommentVNode("", true)]),
+				_: 1
+			})]), renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+export { IndexBar_vue_vue_type_script_setup_true_lang_default as default };

package/dist/index-bar/IndexBarAnchor.js

@@ -0,0 +1,4 @@
+import IndexBarAnchor_vue_vue_type_script_setup_true_lang_default from "./IndexBarAnchor.vue_vue_type_script_setup_true_lang.js";
+// src/index-bar/IndexBarAnchor.vue
+var IndexBarAnchor_default = IndexBarAnchor_vue_vue_type_script_setup_true_lang_default;
+export { IndexBarAnchor_default as default };

package/dist/index-bar/IndexBarAnchor.vue.d.ts

@@ -0,0 +1,13 @@
+import type { IndexBarAnchorProps, IndexBarAnchorSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = IndexBarAnchorSlots;
+declare const __VLS_base: import("vue").DefineComponent<IndexBarAnchorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, 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/index-bar/IndexBarAnchor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,42 @@
+import { indexBarContextKey } from "./context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createElementBlock, createElementVNode, createTextVNode, defineComponent, inject, mergeProps, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, toDisplayString, unref } from "vue";
+// src/index-bar/IndexBarAnchor.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["data-index"];
+var IndexBarAnchor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmIndexBarAnchor",
+	inheritAttrs: false,
+	__name: "IndexBarAnchor",
+	props: {
+		index: {},
+		rootClass: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const context = inject(indexBarContextKey, void 0);
+		const sentinelRef = ref();
+		const record = {
+			index: () => props.index,
+			el: () => sentinelRef.value
+		};
+		onMounted(() => context?.register(record));
+		onBeforeUnmount(() => context?.unregister(record));
+		const active = computed(() => context?.activeIndex.value !== void 0 && context.activeIndex.value === props.index);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createElementVNode("div", {
+				ref_key: "sentinelRef",
+				ref: sentinelRef,
+				class: "am-index-bar-anchor-sentinel",
+				"aria-hidden": "true"
+			}, null, 512), createElementVNode("div", mergeProps(_ctx.$attrs, {
+				class: ["am-index-bar-anchor", [{
+					"am-index-bar-anchor-sticky": unref(context)?.sticky.value,
+					"am-index-bar-anchor-active": active.value
+				}, __props.rootClass]],
+				"data-index": __props.index
+			}), [renderSlot(_ctx.$slots, "default", {}, () => [createTextVNode(toDisplayString(__props.index), 1)])], 16, _hoisted_1)], 64);
+		};
+	}
+});
+export { IndexBarAnchor_vue_vue_type_script_setup_true_lang_default as default };

package/dist/index-bar/context.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, InjectionKey, Ref } from 'vue';
+import type { Key } from '../_util/type';
+export interface IndexBarAnchorRecord {
+    index: () => Key;
+    /** zero-height element marking the natural (non-stuck) position of the anchor */
+    el: () => HTMLElement | undefined;
+}
+export interface IndexBarContext {
+    register: (anchor: IndexBarAnchorRecord) => void;
+    unregister: (anchor: IndexBarAnchorRecord) => void;
+    activeIndex: Ref<Key | undefined>;
+    sticky: ComputedRef<boolean>;
+}
+export declare const indexBarContextKey: InjectionKey<IndexBarContext>;

package/dist/index-bar/context.js

@@ -0,0 +1,3 @@
+// src/index-bar/context.ts
+var indexBarContextKey = Symbol("AmIndexBarContext");
+export { indexBarContextKey };

package/dist/index-bar/index.d.ts

@@ -0,0 +1,73 @@
+export type * from './interface';
+declare const IndexBarAnchor: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").IndexBarAnchorSlots;
+}), object>;
+declare const IndexBar: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").IndexBarProps> & Readonly<{
+        onSelect?: ((index: import("../_util/type.ts").Key) => any) | undefined;
+        onChange?: ((index: import("../_util/type.ts").Key) => any) | undefined;
+    }>, import("./interface").IndexBarExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        select: (index: import("../_util/type.ts").Key) => any;
+        change: (index: import("../_util/type.ts").Key) => any;
+    }, import("vue").PublicProps, {
+        sticky: boolean;
+        stickyOffsetTop: number;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").IndexBarProps> & Readonly<{
+        onSelect?: ((index: import("../_util/type.ts").Key) => any) | undefined;
+        onChange?: ((index: import("../_util/type.ts").Key) => any) | undefined;
+    }>, import("./interface").IndexBarExpose, {}, {}, {}, {
+        sticky: boolean;
+        stickyOffsetTop: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").IndexBarProps> & Readonly<{
+    onSelect?: ((index: import("../_util/type.ts").Key) => any) | undefined;
+    onChange?: ((index: import("../_util/type.ts").Key) => any) | undefined;
+}>, import("./interface").IndexBarExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (index: import("../_util/type.ts").Key) => any;
+    change: (index: import("../_util/type.ts").Key) => any;
+}, string, {
+    sticky: boolean;
+    stickyOffsetTop: number;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").IndexBarSlots;
+}), {
+    Anchor: import("../_util/withInstall").WithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./interface").IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./interface").IndexBarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: import("./interface").IndexBarAnchorSlots;
+    }), object>;
+}>;
+export { IndexBarAnchor };
+export default IndexBar;

package/dist/index-bar/index.js

@@ -0,0 +1,7 @@
+import { withInstall } from "../_util/withInstall.js";
+import IndexBar_default from "./IndexBar.js";
+import IndexBarAnchor_default from "./IndexBarAnchor.js";
+// src/index-bar/index.ts
+var IndexBarAnchor = withInstall(IndexBarAnchor_default, "AmIndexBarAnchor");
+var IndexBar = withInstall(IndexBar_default, "AmIndexBar", { Anchor: IndexBarAnchor });
+export { IndexBarAnchor, IndexBar as default };

package/dist/index-bar/interface.d.ts

@@ -0,0 +1,46 @@
+import type { CSSProperties } from 'vue';
+import type { Key } from '../_util/type';
+export interface IndexBarSemanticClassNames {
+    root?: string;
+    sidebar?: string;
+    index?: string;
+    hint?: string;
+}
+export interface IndexBarSemanticStyles {
+    root?: CSSProperties;
+    sidebar?: CSSProperties;
+    index?: CSSProperties;
+    hint?: CSSProperties;
+}
+export interface IndexBarProps {
+    /** Indexes shown in the side bar. Defaults to the indexes of the anchors inside, in document order. */
+    indexList?: Key[];
+    /** Stick the active anchor to the top of the scroll container */
+    sticky?: boolean;
+    /** Offset from the top of the scroll container (e.g. the height of a fixed NavBar) */
+    stickyOffsetTop?: number;
+    zIndex?: number;
+    rootClass?: string;
+    classes?: IndexBarSemanticClassNames;
+    styles?: IndexBarSemanticStyles;
+}
+export interface IndexBarEmits {
+    /** An index of the side bar was tapped / dragged over */
+    select: [index: Key];
+    /** The active anchor changed while scrolling */
+    change: [index: Key];
+}
+export interface IndexBarSlots {
+    default?: () => any;
+}
+export interface IndexBarExpose {
+    scrollTo: (index: Key) => void;
+}
+export interface IndexBarAnchorProps {
+    index: Key;
+    rootClass?: string;
+}
+export interface IndexBarAnchorSlots {
+    /** Defaults to `index` */
+    default?: () => any;
+}

package/dist/index-bar/style/index.css

@@ -0,0 +1,120 @@
+.am-index-bar {
+  /* component tokens */
+  --am-index-bar-highlight-color: var(--am-color-primary);
+  --am-index-bar-index-size: 16px;
+  --am-index-bar-index-font-size: 10px;
+  --am-index-bar-index-color: var(--am-color-text-secondary);
+  --am-index-bar-anchor-height: 32px;
+  --am-index-bar-anchor-padding-inline: var(--am-padding);
+  --am-index-bar-anchor-font-size: var(--am-font-size);
+  --am-index-bar-anchor-color: var(--am-color-text-secondary);
+  --am-index-bar-anchor-background: var(--am-color-bg-layout);
+  --am-index-bar-hint-size: 48px;
+  --am-index-bar-z-index: 10;
+  --am-index-bar-sticky-offset-top: 0px;
+
+  position: relative;
+  box-sizing: border-box;
+  color: var(--am-color-text);
+  font-size: var(--am-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height);
+}
+
+/* zero-height sticky layer: keeps the side bar inside any scroll container without `position: fixed` */
+.am-index-bar-float {
+  position: sticky;
+  top: var(--am-index-bar-sticky-offset-top);
+  z-index: calc(var(--am-index-bar-z-index) + 1);
+  height: 0;
+}
+
+.am-index-bar-sidebar {
+  position: absolute;
+  top: calc(var(--am-index-bar-viewport-height, 100vh) / 2);
+  inset-inline-end: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: var(--am-padding-xs) var(--am-padding-xxs);
+  transform: translateY(-50%);
+  cursor: pointer;
+  user-select: none;
+  touch-action: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.am-index-bar-index {
+  display: flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  width: var(--am-index-bar-index-size);
+  height: var(--am-index-bar-index-size);
+  color: var(--am-index-bar-index-color);
+  font-size: var(--am-index-bar-index-font-size);
+  line-height: 1;
+  border-radius: 50%;
+  transition:
+    background-color var(--am-motion-duration-fast),
+    color var(--am-motion-duration-fast);
+}
+
+.am-index-bar-index-active {
+  color: var(--am-color-text-light-solid);
+  font-weight: 500;
+  background: var(--am-index-bar-highlight-color);
+}
+
+.am-index-bar-hint {
+  position: absolute;
+  top: calc(var(--am-index-bar-viewport-height, 100vh) / 2);
+  left: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: var(--am-index-bar-hint-size);
+  height: var(--am-index-bar-hint-size);
+  padding: 0 var(--am-padding-xs);
+  box-sizing: border-box;
+  color: var(--am-color-text-light-solid);
+  font-weight: 500;
+  font-size: var(--am-font-size-heading-3);
+  line-height: 1;
+  background: var(--am-color-bg-mask);
+  border-radius: var(--am-border-radius);
+  transform: translate(-50%, -50%);
+  pointer-events: none;
+}
+
+/* ---------- anchor ---------- */
+.am-index-bar-anchor-sentinel {
+  height: 0;
+  pointer-events: none;
+}
+
+.am-index-bar-anchor {
+  box-sizing: border-box;
+  height: var(--am-index-bar-anchor-height, 32px);
+  padding: 0 var(--am-index-bar-anchor-padding-inline, 16px);
+  overflow: hidden;
+  color: var(--am-index-bar-anchor-color, var(--am-color-text-secondary));
+  font-weight: 500;
+  font-size: var(--am-index-bar-anchor-font-size, 14px);
+  font-family: var(--am-font-family);
+  line-height: var(--am-index-bar-anchor-height, 32px);
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  background: var(--am-index-bar-anchor-background, var(--am-color-bg-layout));
+  transition: color var(--am-motion-duration-mid);
+}
+
+.am-index-bar-anchor-sticky {
+  position: sticky;
+  top: var(--am-index-bar-sticky-offset-top, 0px);
+  z-index: var(--am-index-bar-z-index, 10);
+}
+
+.am-index-bar-anchor-sticky.am-index-bar-anchor-active {
+  color: var(--am-index-bar-highlight-color, var(--am-color-primary));
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import type { App } from 'vue';
+import version from './version';
+export type { GetContainer, RenderNodeFn, SizeType, ValidateStatus, VueNode } from './_util/type';
+export * from './components';
+export { useConfig, useDisabled, useSize } from './config-provider';
+export type { FormItemInputContext, Variant } from './form/context';
+export { useFormItemInputContext, useMergedStatus, useVariant } from './form/context';
+export * from './hooks';
+export type { Locale } from './locale';
+export { useLocale } from './locale';
+export { applyTheme, compactAlgorithm, cssVar, darkAlgorithm, defaultAlgorithm, default as theme, useToken } from './theme';
+export type * from './theme';
+export { version };
+export declare function install(app: App): App<any>;
+declare const _default: {
+    version: string;
+    install: typeof install;
+};
+export default _default;