niuma-ui 1.3.8 → 2.0.0

package/dist/components/alert/src/RsAlert.css

@@ -0,0 +1,111 @@
+
+.rs-alert[data-v-2fd45305] {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--rs-alert-gap, var(--rs-space-sm));
+  padding: var(--rs-alert-padding-y, var(--rs-space-md))
+    var(--rs-alert-padding-x, var(--rs-space-lg));
+  border-radius: var(--rs-alert-radius, var(--rs-radius));
+  box-sizing: border-box;
+}
+.rs-alert--bordered[data-v-2fd45305] {
+  border: 1px solid transparent;
+}
+.rs-alert__icon[data-v-2fd45305] {
+  display: inline-flex;
+  flex-shrink: 0;
+  margin-top: 0.125rem;
+}
+.rs-alert__body[data-v-2fd45305] {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.rs-alert__title[data-v-2fd45305] {
+  font-size: var(--rs-font-size-sm);
+  font-weight: var(--rs-font-weight-semibold);
+  line-height: var(--rs-line-height-tight);
+  color: inherit;
+}
+.rs-alert__content[data-v-2fd45305] {
+  margin-top: var(--rs-space-xs);
+  font-size: var(--rs-font-size-sm);
+  line-height: var(--rs-line-height-normal);
+  color: var(--rs-alert-content-fg, var(--rs-muted));
+}
+.rs-alert__close[data-v-2fd45305] {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0;
+  padding: 0.125rem;
+  border: 0;
+  border-radius: var(--rs-radius-sm);
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+  opacity: 0.7;
+  outline: none;
+}
+.rs-alert__close[data-v-2fd45305]:hover {
+  opacity: 1;
+  background: color-mix(in srgb, currentColor 10%, transparent);
+}
+.rs-alert__close[data-v-2fd45305]:focus-visible {
+  box-shadow: 0 0 0 var(--rs-focus-ring-width, 2px) var(--rs-focus-ring);
+}
+.rs-alert--default[data-v-2fd45305] {
+  background: var(--rs-surface-hover);
+  color: var(--rs-text);
+  border-color: var(--rs-border);
+}
+.rs-alert--default .rs-alert__content[data-v-2fd45305] {
+  color: var(--rs-alert-content-fg, var(--rs-muted));
+}
+.rs-alert--info[data-v-2fd45305] {
+  background: var(--rs-info-container);
+  color: var(--rs-on-info-container);
+  border-color: color-mix(
+    in srgb,
+    var(--rs-info) var(--rs-alert-border-alpha, 35%),
+    transparent
+  );
+}
+.rs-alert--info .rs-alert__content[data-v-2fd45305] {
+  color: color-mix(in srgb, var(--rs-on-info-container) 78%, transparent);
+}
+.rs-alert--success[data-v-2fd45305] {
+  background: var(--rs-success-container);
+  color: var(--rs-on-success-container);
+  border-color: color-mix(
+    in srgb,
+    var(--rs-success) var(--rs-alert-border-alpha, 35%),
+    transparent
+  );
+}
+.rs-alert--success .rs-alert__content[data-v-2fd45305] {
+  color: color-mix(in srgb, var(--rs-on-success-container) 78%, transparent);
+}
+.rs-alert--warning[data-v-2fd45305] {
+  background: var(--rs-warning-container);
+  color: var(--rs-on-warning-container);
+  border-color: color-mix(
+    in srgb,
+    var(--rs-warning) var(--rs-alert-border-alpha, 35%),
+    transparent
+  );
+}
+.rs-alert--warning .rs-alert__content[data-v-2fd45305] {
+  color: color-mix(in srgb, var(--rs-on-warning-container) 78%, transparent);
+}
+.rs-alert--danger[data-v-2fd45305] {
+  background: var(--rs-danger-container);
+  color: var(--rs-on-danger-container);
+  border-color: color-mix(
+    in srgb,
+    var(--rs-danger) var(--rs-alert-border-alpha, 35%),
+    transparent
+  );
+}
+.rs-alert--danger .rs-alert__content[data-v-2fd45305] {
+  color: color-mix(in srgb, var(--rs-on-danger-container) 78%, transparent);
+}

package/dist/components/alert/src/RsAlert.d.ts

@@ -0,0 +1,32 @@
+import type { RsFeedbackTone } from '../../_shared/src/overlay-utils';
+type __VLS_Props = {
+    type?: RsFeedbackTone;
+    title?: string;
+    closable?: boolean;
+    bordered?: boolean;
+};
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_10: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    title?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    type: RsFeedbackTone;
+    bordered: boolean;
+    closable: boolean;
+}, {}, {}, {}, 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/alert/src/RsAlert.impl.js

@@ -0,0 +1,83 @@
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import RsIcon_default from "../../icon/src/RsIcon.js";
+import { computed, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, toDisplayString, unref } from "vue";
+//#region src/components/alert/src/RsAlert.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	class: "rs-alert__icon",
+	"aria-hidden": "true"
+};
+var _hoisted_2 = { class: "rs-alert__body" };
+var _hoisted_3 = {
+	key: 0,
+	class: "rs-alert__title"
+};
+var _hoisted_4 = {
+	key: 1,
+	class: "rs-alert__content"
+};
+var _hoisted_5 = ["aria-label"];
+var RsAlert_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "RsAlert",
+	props: {
+		type: { default: "info" },
+		title: {},
+		closable: {
+			type: Boolean,
+			default: false
+		},
+		bordered: {
+			type: Boolean,
+			default: true
+		}
+	},
+	emits: ["close"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { t } = useRsI18n();
+		const iconName = computed(() => {
+			switch (props.type) {
+				case "success": return "circle-check";
+				case "warning": return "triangle-alert";
+				case "danger": return "circle-alert";
+				case "default": return "info";
+				default: return "info";
+			}
+		});
+		const rootClass = computed(() => [
+			"rs-alert",
+			`rs-alert--${props.type}`,
+			{
+				"rs-alert--bordered": props.bordered,
+				"rs-alert--closable": props.closable
+			}
+		]);
+		function onClose(event) {
+			emit("close", event);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: normalizeClass(rootClass.value),
+				role: "alert"
+			}, [
+				createElementVNode("span", _hoisted_1, [renderSlot(_ctx.$slots, "icon", {}, () => [createVNode(RsIcon_default, {
+					name: iconName.value,
+					size: 16
+				}, null, 8, ["name"])], true)]),
+				createElementVNode("div", _hoisted_2, [__props.title || _ctx.$slots.title ? (openBlock(), createElementBlock("div", _hoisted_3, [renderSlot(_ctx.$slots, "title", {}, () => [createTextVNode(toDisplayString(__props.title), 1)], true)])) : createCommentVNode("", true), _ctx.$slots.default ? (openBlock(), createElementBlock("div", _hoisted_4, [renderSlot(_ctx.$slots, "default", {}, void 0, true)])) : createCommentVNode("", true)]),
+				__props.closable ? (openBlock(), createElementBlock("button", {
+					key: 0,
+					type: "button",
+					class: "rs-alert__close",
+					"aria-label": unref(t)("alert.close"),
+					onClick: onClose
+				}, [createVNode(RsIcon_default, {
+					name: "x",
+					size: 14
+				})], 8, _hoisted_5)) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+export { RsAlert_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/alert/src/RsAlert.js

@@ -0,0 +1,8 @@
+import './RsAlert.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+import RsAlert_vue_vue_type_script_setup_true_lang_default from "./RsAlert.impl.js";
+
+//#region src/components/alert/src/RsAlert.vue
+var RsAlert_default = /*#__PURE__*/ _plugin_vue_export_helper_default(RsAlert_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-2fd45305"]]);
+//#endregion
+export { RsAlert_default as default };

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

@@ -0,0 +1,3 @@
+export { default as RsAnchor } from './src/RsAnchor.js';
+export type { RsAnchorFlatItem, RsAnchorItem } from './src/anchor-utils';
+export { flattenAnchorItems, hrefToAnchorId, pickActiveAnchorHref, } from './src/anchor-utils';

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

@@ -0,0 +1,65 @@
+
+.rs-anchor[data-v-c95cbe5f] {
+  position: relative;
+  display: flex;
+  gap: 0.7rem;
+  min-width: 8.5rem;
+}
+.rs-anchor--affix[data-v-c95cbe5f] {
+  position: sticky;
+  top: var(--rs-space-lg);
+}
+.rs-anchor__rail[data-v-c95cbe5f] {
+  position: relative;
+  flex-shrink: 0;
+  width: 2px;
+  border-radius: var(--rs-radius-full);
+  background: color-mix(in srgb, var(--rs-border-subtle) 88%, var(--rs-muted));
+}
+.rs-anchor__ink[data-v-c95cbe5f] {
+  position: absolute;
+  inset-inline-start: 0;
+  top: 0;
+  width: 2px;
+  border-radius: inherit;
+  background: var(--rs-primary);
+  box-shadow: 0 0 0 1px color-mix(in srgb, var(--rs-primary) 18%, transparent);
+  opacity: 0;
+  transition:
+    transform 180ms ease,
+    height 180ms ease,
+    opacity 180ms ease;
+}
+.rs-anchor__list[data-v-c95cbe5f] {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  flex: 1;
+}
+.rs-anchor__link[data-v-c95cbe5f] {
+  display: block;
+  padding-block: 0.28rem;
+  color: var(--rs-muted);
+  font-size: var(--rs-font-size-xs);
+  line-height: 1.55;
+  text-decoration: none;
+  border-radius: var(--rs-radius-xs);
+  transition: color var(--rs-transition-fast);
+}
+.rs-anchor__link[data-v-c95cbe5f]:hover {
+  color: var(--rs-text);
+}
+.rs-anchor__link[data-v-c95cbe5f]:focus-visible {
+  outline: 2px solid var(--rs-primary);
+  outline-offset: 2px;
+}
+.rs-anchor__link--active[data-v-c95cbe5f] {
+  color: var(--rs-primary);
+  font-weight: 600;
+}
+.rs-anchor--lineless .rs-anchor__link[data-v-c95cbe5f] {
+  padding-inline: 0.45rem;
+}
+.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

@@ -0,0 +1,41 @@
+import { type RsAnchorItem } from './anchor-utils';
+type __VLS_Props = {
+    items: RsAnchorItem[];
+    /** 判定「已滚过」的顶部偏移（px） */
+    offset?: number;
+    /** 点击滚动后标题距容器顶的距离 */
+    targetOffset?: number;
+    /** 额外容差，避免刚贴顶就跳下一项 */
+    bounds?: number;
+    /** sticky 吸附 */
+    affix?: boolean;
+    /** 无轨道墨点（仅文字高亮） */
+    lineless?: boolean;
+    /**
+     * 是否改写 location.hash。
+     * Hash 路由（Vue Router createWebHashHistory）必须为 false，否则会丢掉当前路由。
+     */
+    changeHash?: boolean;
+    getContainer?: () => HTMLElement | Window | null | undefined;
+};
+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, {
+    change: (href: string) => any;
+    click: (href: string, event: MouseEvent) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((href: string) => any) | undefined;
+    onClick?: ((href: string, event: MouseEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    offset: number;
+    bounds: number;
+    affix: boolean;
+    lineless: boolean;
+    changeHash: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,188 @@
+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";
+//#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 = [
+	"href",
+	"data-rs-anchor-href",
+	"onClick"
+];
+var RsAnchor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsAnchor",
+	__name: "RsAnchor",
+	props: /*@__PURE__*/ mergeModels({
+		items: {},
+		offset: { default: 12 },
+		targetOffset: {},
+		bounds: { default: 8 },
+		affix: {
+			type: Boolean,
+			default: true
+		},
+		lineless: {
+			type: Boolean,
+			default: false
+		},
+		changeHash: {
+			type: Boolean,
+			default: true
+		},
+		getContainer: {}
+	}, {
+		"modelValue": { default: "" },
+		"modelModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["change", "click"], ["update:modelValue"]),
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const activeHref = useModel(__props, "modelValue");
+		const emit = __emit;
+		const { t } = useRsI18n();
+		const rootRef = ref(null);
+		const inkStyle = ref({});
+		const flatItems = computed(() => flattenAnchorItems(props.items));
+		const resolvedTargetOffset = computed(() => props.targetOffset ?? props.offset);
+		let scrollTarget = null;
+		let ticking = false;
+		function findTarget(href) {
+			const id = hrefToAnchorId(href);
+			if (!id || typeof document === "undefined") return null;
+			return document.getElementById(id);
+		}
+		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 setActive(href) {
+			if (!href || href === activeHref.value) return;
+			activeHref.value = href;
+			emit("change", href);
+		}
+		function syncInk() {
+			const root = rootRef.value;
+			if (!root || props.lineless) return;
+			const current = activeHref.value || flatItems.value[0]?.href;
+			if (!current) {
+				inkStyle.value = { opacity: "0" };
+				return;
+			}
+			const link = findLinkByHref(root, current);
+			if (!link) {
+				inkStyle.value = { opacity: "0" };
+				return;
+			}
+			inkStyle.value = {
+				opacity: "1",
+				transform: `translateY(${link.offsetTop}px)`,
+				height: `${link.offsetHeight}px`
+			};
+		}
+		function syncFromScroll() {
+			if (!scrollTarget) return;
+			const next = pickActiveAnchorHref(collectTops(scrollTarget), props.offset + props.bounds);
+			if (next) setActive(next);
+			nextTick(syncInk);
+		}
+		function onScroll() {
+			if (ticking) return;
+			ticking = true;
+			requestAnimationFrame(() => {
+				ticking = false;
+				syncFromScroll();
+			});
+		}
+		function bindContainer() {
+			unbindContainer();
+			try {
+				scrollTarget = resolveAnchorContainer(props.getContainer);
+			} catch {
+				scrollTarget = null;
+				return;
+			}
+			scrollTarget.addEventListener("scroll", onScroll, { passive: true });
+			syncFromScroll();
+		}
+		function unbindContainer() {
+			scrollTarget?.removeEventListener("scroll", onScroll);
+			scrollTarget = null;
+		}
+		function onSelect(href, event) {
+			event.preventDefault();
+			emit("click", href, event);
+			const target = findTarget(href);
+			const container = scrollTarget ?? resolveAnchorContainer(props.getContainer);
+			if (target) scrollContainerTo(container, computeScrollTopForTarget(target, container, resolvedTargetOffset.value));
+			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}`);
+			}
+			nextTick(syncInk);
+		}
+		onMounted(() => {
+			bindContainer();
+			window.addEventListener("resize", onScroll, { passive: true });
+		});
+		onUnmounted(() => {
+			unbindContainer();
+			window.removeEventListener("resize", onScroll);
+		});
+		watch(() => [
+			props.items,
+			props.getContainer,
+			props.offset,
+			props.bounds
+		], () => {
+			nextTick(bindContainer);
+		}, { deep: true });
+		watch(activeHref, () => {
+			nextTick(syncInk);
+		});
+		return (_ctx, _cache) => {
+			return flatItems.value.length ? (openBlock(), createElementBlock("nav", {
+				key: 0,
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: normalizeClass(["rs-anchor", {
+					"rs-anchor--affix": __props.affix,
+					"rs-anchor--lineless": __props.lineless
+				}]),
+				"aria-label": unref(t)("anchor.label")
+			}, [!__props.lineless ? (openBlock(), createElementBlock("div", _hoisted_2, [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", {
+					key: item.href,
+					class: normalizeClass(["rs-anchor__link", { "rs-anchor__link--active": item.href === activeHref.value }]),
+					style: normalizeStyle({ paddingInlineStart: `${.7 + item.depth * .75}rem` }),
+					href: item.href,
+					"data-rs-anchor-href": item.href,
+					onClick: ($event) => onSelect(item.href, $event)
+				}, toDisplayString(item.title), 15, _hoisted_4);
+			}), 128))])], 10, _hoisted_1)) : createCommentVNode("", true);
+		};
+	}
+});
+//#endregion
+export { RsAnchor_vue_vue_type_script_setup_true_lang_default as default };

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

@@ -0,0 +1,8 @@
+import './RsAnchor.css'
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.js";
+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"]]);
+//#endregion
+export { RsAnchor_default as default };

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

@@ -0,0 +1,26 @@
+export interface RsAnchorItem {
+    href: string;
+    title: string;
+    children?: RsAnchorItem[];
+}
+export interface RsAnchorFlatItem {
+    href: string;
+    title: string;
+    depth: number;
+}
+/** `#overview` / `path#overview` → `overview` */
+export declare function hrefToAnchorId(href: string): string;
+export declare function flattenAnchorItems(items: RsAnchorItem[], depth?: number): RsAnchorFlatItem[];
+/**
+ * 滚动监听：取最后一个 top <= offset 的标题。
+ * entries 须按文档顺序（与 DOM 一致），top 为相对滚动容器顶部的距离。
+ */
+export declare function pickActiveAnchorHref(entries: ReadonlyArray<{
+    href: string;
+    top: number;
+}>, offset: number): string;
+export declare function resolveAnchorContainer(getContainer?: () => HTMLElement | Window | null | undefined): HTMLElement | Window;
+export declare function readContainerScrollTop(container: HTMLElement | Window): number;
+export declare function targetTopInContainer(target: HTMLElement, container: HTMLElement | Window): number;
+export declare function scrollContainerTo(container: HTMLElement | Window, top: number): void;
+export declare function computeScrollTopForTarget(target: HTMLElement, container: HTMLElement | Window, targetOffset: number): number;

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

@@ -0,0 +1,63 @@
+//#region src/components/anchor/src/anchor-utils.ts
+/** `#overview` / `path#overview` → `overview` */
+function hrefToAnchorId(href) {
+	const raw = href.trim();
+	return (raw.includes("#") ? raw.slice(raw.indexOf("#") + 1) : raw).replace(/^#/, "");
+}
+function flattenAnchorItems(items, depth = 0) {
+	const out = [];
+	for (const item of items) {
+		out.push({
+			href: item.href,
+			title: item.title,
+			depth
+		});
+		if (item.children?.length) out.push(...flattenAnchorItems(item.children, depth + 1));
+	}
+	return out;
+}
+/**
+* 滚动监听：取最后一个 top <= offset 的标题。
+* entries 须按文档顺序（与 DOM 一致），top 为相对滚动容器顶部的距离。
+*/
+function pickActiveAnchorHref(entries, offset) {
+	if (entries.length === 0) return "";
+	let active = entries[0]?.href ?? "";
+	for (const entry of entries) if (entry.top <= offset) active = entry.href;
+	return active;
+}
+function resolveAnchorContainer(getContainer) {
+	const resolved = getContainer?.();
+	if (resolved) return resolved;
+	if (typeof window !== "undefined") return window;
+	throw new Error("RsAnchor: no scroll container");
+}
+function readContainerScrollTop(container) {
+	if (container instanceof Window) return container.scrollY;
+	return container.scrollTop;
+}
+function targetTopInContainer(target, container) {
+	const targetRect = target.getBoundingClientRect();
+	if (container instanceof Window) return targetRect.top;
+	return targetRect.top - container.getBoundingClientRect().top;
+}
+function scrollContainerTo(container, top) {
+	if (container instanceof Window) {
+		container.scrollTo({
+			top,
+			behavior: "smooth"
+		});
+		return;
+	}
+	container.scrollTo({
+		top,
+		behavior: "smooth"
+	});
+}
+function computeScrollTopForTarget(target, container, targetOffset) {
+	const current = readContainerScrollTop(container);
+	const relativeTop = targetTopInContainer(target, container);
+	return Math.max(0, current + relativeTop - targetOffset);
+}
+//#endregion
+export { computeScrollTopForTarget, flattenAnchorItems, hrefToAnchorId, pickActiveAnchorHref, readContainerScrollTop, resolveAnchorContainer, scrollContainerTo, targetTopInContainer };

package/dist/components/auto-complete/index.d.ts

@@ -0,0 +1 @@
+export { default as RsAutoComplete } from './src/RsAutoComplete.js';

package/dist/components/auto-complete/src/RsAutoComplete.d.ts

@@ -0,0 +1,39 @@
+import type { RsComponentSize } from '../../../theme/types';
+import { type RsSelectFilterOption, type RsSelectOption } from '../../select/src/select-utils';
+type __VLS_Props = {
+    options?: ReadonlyArray<string | RsSelectOption>;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: RsComponentSize;
+    allowClear?: boolean;
+    filterOption?: RsSelectFilterOption | boolean;
+    debounce?: number;
+    emptyText?: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (query: string) => any;
+    select: (value: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    onSelect?: ((value: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    options: ReadonlyArray<string | RsSelectOption>;
+    emptyText: string;
+    filterOption: RsSelectFilterOption | boolean;
+    debounce: number;
+    allowClear: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;