ensis-ui 0.0.0-stage → 3.0.0

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

@@ -0,0 +1,110 @@
+import type { RsContextMenuItem } from '../../context-menu/src/context-menu-utils';
+/** 选项卡项定义 */
+export interface RsTabItem {
+    value: string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    badge?: string | number;
+    /** 是否可关闭；未设置时继承 RsTabs 的 closable；fixed 为 true 时强制不可关 */
+    closable?: boolean;
+    /** 固定/常驻标签（对齐 GTabs fixed / 浏览器固定标签），不可关闭、不可被批量关闭 */
+    fixed?: boolean;
+    /** 是否可重命名；未设置时继承 RsTabs 的 renamable */
+    renamable?: boolean;
+}
+/** 选项卡尺寸（ssm 由 ConfigProvider 落入时按 sm） */
+export type RsTabsSize = 'sm' | 'md' | 'lg';
+/** line 下划线 · segmented 胶囊 · card 卡片（Ant editable-card） */
+export type RsTabsVariant = 'line' | 'segmented' | 'card';
+/** 标签栏位置（对齐 Ant / Element tabPosition） */
+export type RsTabsPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * 键盘激活方式（WAI-ARIA APG）。
+ * automatic：方向键同时移动焦点并切换；manual：方向键只移焦点，Enter / Space 才切换。
+ */
+export type RsTabsActivation = 'automatic' | 'manual';
+/** `#tab` 插槽参数 */
+export interface RsTabsTabSlot {
+    item: RsTabItem;
+    active: boolean;
+    disabled: boolean;
+}
+export interface RsTabsExpose {
+    /** 把焦点放到指定标签；未传则落到当前激活项 */
+    focus: (value?: string) => void;
+    /** 走 beforeLeave 后切换。被拦截时返回 false */
+    selectTab: (value: string) => Promise<boolean>;
+}
+/** 模板 ref 实例：expose + 根节点 */
+export type RsTabsInstance = RsTabsExpose & {
+    $el: HTMLElement;
+};
+/**
+ * 标签栏对齐：start 左齐 · center 居中 · evenly 均分空隙 · stretch 项等宽铺满。
+ * 用于登录等场景，避免业务侧 :deep 改 list/trigger。
+ */
+export type RsTabsJustify = 'start' | 'center' | 'evenly' | 'stretch';
+/**
+ * 标题栏与内容区间距（主要用于 borderless）。
+ * none=0 · sm=8px · md=12px · lg=16px · xl=24px；也可用 CSS 变量 --rs-tabs-content-gap 覆盖。
+ */
+export type RsTabsContentGap = 'none' | 'sm' | 'md' | 'lg' | 'xl';
+/** 标签过多时的处理方式 */
+export type RsTabsOverflow = 'scroll' | 'dropdown';
+/** 批量关闭动作（顶栏导航右键菜单） */
+export type RsTabsCloseAction = 'close' | 'others' | 'left' | 'right' | 'all';
+/** 判断是否为固定标签 */
+export declare function isTabFixed(item: RsTabItem): boolean;
+/** 判断单项是否展示关闭按钮 */
+export declare function isTabClosable(item: RsTabItem, globalClosable?: boolean): boolean;
+/** 判断单项是否可双击重命名 */
+export declare function isTabRenamable(item: RsTabItem, globalRenamable?: boolean): boolean;
+/** 关闭当前激活项时，解析应切换到的下一项（优先右侧，否则左侧） */
+export declare function getNextTabAfterClose(items: RsTabItem[], closedValue: string, activeValue: string): string | undefined;
+/**
+ * 批量关闭后解析应保留的激活项。
+ * 若当前激活项仍在剩余列表中则保持，否则取锚点（若仍在）或首项。
+ */
+export declare function getNextTabAfterBatchClose(remaining: RsTabItem[], activeValue: string, anchorValue?: string): string | undefined;
+/** 将 dragValue 对应的项移动到 dropValue 之前（fixed 项不可作为拖拽源或落点） */
+export declare function reorderTabItems(items: RsTabItem[], dragValue: string, dropValue: string): RsTabItem[];
+/**
+ * 按动作解析待关闭的 value 列表（跳过 fixed / 不可关闭项）。
+ */
+export declare function resolveTabsToClose(items: RsTabItem[], action: RsTabsCloseAction, anchorValue: string, globalClosable?: boolean): string[];
+export interface BuildTabContextMenuLabels {
+    close: string;
+    closeOthers: string;
+    closeLeft: string;
+    closeRight: string;
+    closeAll: string;
+}
+/**
+ * 构建顶栏导航右键菜单项（关闭 / 关闭其他 / 左 / 右 / 全部）。
+ */
+export declare function buildTabContextMenuItems(items: RsTabItem[], anchor: RsTabItem, globalClosable: boolean, labels: BuildTabContextMenuLabels): RsContextMenuItem[];
+export interface ResolveVisibleTabOptions {
+    /** dropdown 模式下为 false：激活项仅在「更多」展示，不占标签栏 */
+    keepActiveVisible?: boolean;
+}
+/**
+ * 根据各标签宽度与可用宽度，计算应展示的标签 value 集合。
+ */
+export declare function resolveVisibleTabValues(items: RsTabItem[], widths: Map<string, number>, availableWidth: number, activeValue: string, reservedWidth?: number, options?: ResolveVisibleTabOptions): Set<string>;
+export declare function isVerticalTabsPosition(position: RsTabsPosition): boolean;
+export declare function getEnabledTabValues(items: readonly RsTabItem[]): string[];
+/** 在可启用项里按 delta 环移（跳过 disabled） */
+export declare function getAdjacentTabValue(items: readonly RsTabItem[], current: string, delta: number): string | undefined;
+export declare function getEdgeTabValue(items: readonly RsTabItem[], edge: 'start' | 'end'): string | undefined;
+/**
+ * 解析标签栏键盘位移。竖排只用上下；横排左右在 RTL 下对调。
+ * Home / End 返回端点；不处理的键返回 null。
+ */
+export declare function resolveTabKeyboardMove(key: string, position: RsTabsPosition, rtl?: boolean): number | 'start' | 'end' | null;
+export declare function sanitizeTabDomId(value: string): string;
+export declare function tabTriggerId(rootId: string, value: string): string;
+export declare function tabPanelId(rootId: string, value: string): string;
+/** lazy：首次激活才挂；destroyInactive：离开即卸。后者优先。 */
+export declare function shouldRenderTabPanel(value: string, activeValue: string, visited: ReadonlySet<string>, lazy: boolean, destroyInactive: boolean): boolean;
+export declare function resolveTabsSize(size: string | undefined): RsTabsSize;

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

@@ -0,0 +1,201 @@
+//#region src/components/tabs/src/tabs-utils.ts
+/** 判断是否为固定标签 */
+function isTabFixed(item) {
+	return item.fixed === true;
+}
+/** 判断单项是否展示关闭按钮 */
+function isTabClosable(item, globalClosable = false) {
+	if (isTabFixed(item)) return false;
+	if (item.closable !== void 0) return item.closable;
+	return globalClosable;
+}
+/** 判断单项是否可双击重命名 */
+function isTabRenamable(item, globalRenamable = false) {
+	if (item.renamable !== void 0) return item.renamable;
+	return globalRenamable;
+}
+/** 关闭当前激活项时，解析应切换到的下一项（优先右侧，否则左侧） */
+function getNextTabAfterClose(items, closedValue, activeValue) {
+	if (activeValue !== closedValue) return activeValue;
+	const index = items.findIndex((item) => item.value === closedValue);
+	if (index < 0) return void 0;
+	const remaining = items.filter((item) => item.value !== closedValue);
+	if (!remaining.length) return void 0;
+	return remaining[index]?.value ?? remaining[index - 1]?.value ?? remaining[0]?.value;
+}
+/**
+* 批量关闭后解析应保留的激活项。
+* 若当前激活项仍在剩余列表中则保持，否则取锚点（若仍在）或首项。
+*/
+function getNextTabAfterBatchClose(remaining, activeValue, anchorValue) {
+	if (!remaining.length) return void 0;
+	if (remaining.some((item) => item.value === activeValue)) return activeValue;
+	if (anchorValue && remaining.some((item) => item.value === anchorValue)) return anchorValue;
+	return remaining[0]?.value;
+}
+/** 将 dragValue 对应的项移动到 dropValue 之前（fixed 项不可作为拖拽源或落点） */
+function reorderTabItems(items, dragValue, dropValue) {
+	const from = items.findIndex((item) => item.value === dragValue);
+	const to = items.findIndex((item) => item.value === dropValue);
+	if (from < 0 || to < 0 || from === to) return items;
+	const dragItem = items[from];
+	const dropItem = items[to];
+	if (!dragItem || !dropItem || isTabFixed(dragItem) || isTabFixed(dropItem)) return items;
+	const next = [...items];
+	const [moved] = next.splice(from, 1);
+	if (!moved) return items;
+	next.splice(to, 0, moved);
+	return next;
+}
+/**
+* 按动作解析待关闭的 value 列表（跳过 fixed / 不可关闭项）。
+*/
+function resolveTabsToClose(items, action, anchorValue, globalClosable = false) {
+	const index = items.findIndex((item) => item.value === anchorValue);
+	if (index < 0 && action !== "all") return [];
+	const canClose = (item) => isTabClosable(item, globalClosable);
+	switch (action) {
+		case "close": {
+			const item = items[index];
+			return item && canClose(item) ? [item.value] : [];
+		}
+		case "others": return items.filter((item) => item.value !== anchorValue && canClose(item)).map((item) => item.value);
+		case "left": return items.filter((item, i) => i < index && canClose(item)).map((item) => item.value);
+		case "right": return items.filter((item, i) => i > index && canClose(item)).map((item) => item.value);
+		case "all": return items.filter((item) => canClose(item)).map((item) => item.value);
+		default: return [];
+	}
+}
+/**
+* 构建顶栏导航右键菜单项（关闭 / 关闭其他 / 左 / 右 / 全部）。
+*/
+function buildTabContextMenuItems(items, anchor, globalClosable, labels) {
+	if (items.findIndex((item) => item.value === anchor.value) < 0) return [];
+	const canCloseAnchor = isTabClosable(anchor, globalClosable);
+	const others = resolveTabsToClose(items, "others", anchor.value, globalClosable);
+	const left = resolveTabsToClose(items, "left", anchor.value, globalClosable);
+	const right = resolveTabsToClose(items, "right", anchor.value, globalClosable);
+	const all = resolveTabsToClose(items, "all", anchor.value, globalClosable);
+	return [
+		{
+			key: "close",
+			label: labels.close,
+			icon: "x",
+			disabled: !canCloseAnchor
+		},
+		{
+			key: "sep-1",
+			label: "",
+			separator: true
+		},
+		{
+			key: "others",
+			label: labels.closeOthers,
+			icon: "copy-x",
+			disabled: others.length === 0
+		},
+		{
+			key: "left",
+			label: labels.closeLeft,
+			icon: "arrow-left-to-line",
+			disabled: left.length === 0
+		},
+		{
+			key: "right",
+			label: labels.closeRight,
+			icon: "arrow-right-to-line",
+			disabled: right.length === 0
+		},
+		{
+			key: "sep-2",
+			label: "",
+			separator: true
+		},
+		{
+			key: "all",
+			label: labels.closeAll,
+			icon: "trash-2",
+			danger: true,
+			disabled: all.length === 0
+		}
+	];
+}
+/**
+* 根据各标签宽度与可用宽度，计算应展示的标签 value 集合。
+*/
+function resolveVisibleTabValues(items, widths, availableWidth, activeValue, reservedWidth = 0, options = {}) {
+	const keepActiveVisible = options.keepActiveVisible ?? true;
+	if (availableWidth <= 0 || !items.length) return new Set(items.map((item) => item.value));
+	const budget = Math.max(0, availableWidth - reservedWidth);
+	const visible = [];
+	let used = 0;
+	for (const item of items) {
+		const width = widths.get(item.value) ?? 0;
+		if (used + width > budget) break;
+		visible.push(item.value);
+		used += width;
+	}
+	if (keepActiveVisible && !visible.includes(activeValue)) {
+		if (items.findIndex((item) => item.value === activeValue) >= 0) {
+			if (visible.length > 1) visible.pop();
+			if (!visible.includes(activeValue)) visible.push(activeValue);
+		}
+	}
+	return new Set(visible);
+}
+function isVerticalTabsPosition(position) {
+	return position === "left" || position === "right";
+}
+function getEnabledTabValues(items) {
+	return items.filter((item) => !item.disabled).map((item) => item.value);
+}
+/** 在可启用项里按 delta 环移（跳过 disabled） */
+function getAdjacentTabValue(items, current, delta) {
+	const enabled = getEnabledTabValues(items);
+	if (!enabled.length) return void 0;
+	const index = enabled.indexOf(current);
+	return enabled[(Math.max(index, 0) + delta + enabled.length * 8) % enabled.length];
+}
+function getEdgeTabValue(items, edge) {
+	const enabled = getEnabledTabValues(items);
+	if (!enabled.length) return void 0;
+	return edge === "start" ? enabled[0] : enabled.at(-1);
+}
+/**
+* 解析标签栏键盘位移。竖排只用上下；横排左右在 RTL 下对调。
+* Home / End 返回端点；不处理的键返回 null。
+*/
+function resolveTabKeyboardMove(key, position, rtl = false) {
+	if (key === "Home") return "start";
+	if (key === "End") return "end";
+	if (isVerticalTabsPosition(position)) {
+		if (key === "ArrowUp") return -1;
+		if (key === "ArrowDown") return 1;
+		return null;
+	}
+	if (key === "ArrowLeft") return rtl ? 1 : -1;
+	if (key === "ArrowRight") return rtl ? -1 : 1;
+	return null;
+}
+function sanitizeTabDomId(value) {
+	return value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-/, "").replace(/-$/, "") || "tab";
+}
+function tabTriggerId(rootId, value) {
+	return `${rootId}-tab-${sanitizeTabDomId(value)}`;
+}
+function tabPanelId(rootId, value) {
+	return `${rootId}-panel-${sanitizeTabDomId(value)}`;
+}
+/** lazy：首次激活才挂；destroyInactive：离开即卸。后者优先。 */
+function shouldRenderTabPanel(value, activeValue, visited, lazy, destroyInactive) {
+	if (destroyInactive) return value === activeValue;
+	if (!lazy) return true;
+	return value === activeValue || visited.has(value);
+}
+function resolveTabsSize(size) {
+	if (size === "lg") return "lg";
+	if (size === "sm" || size === "ssm") return "sm";
+	return "md";
+}
+//#endregion
+export { buildTabContextMenuItems, getAdjacentTabValue, getEdgeTabValue, getEnabledTabValues, getNextTabAfterBatchClose, getNextTabAfterClose, isTabClosable, isTabFixed, isTabRenamable, isVerticalTabsPosition, reorderTabItems, resolveTabKeyboardMove, resolveTabsSize, resolveTabsToClose, resolveVisibleTabValues, sanitizeTabDomId, shouldRenderTabPanel, tabPanelId, tabTriggerId };

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

@@ -0,0 +1,2 @@
+export { default as RsTag } from './src/RsTag.js';
+export type { RsTagVariant } from './src/tag-utils';

package/dist/components/tag/src/RsTag.css

@@ -0,0 +1,98 @@
+
+.rs-tag[data-v-d8327085] {
+  --rs-tag-pad-y-sm: 0.0625rem;
+  --rs-tag-pad-y-md: 0.125rem;
+  --rs-tag-disabled-opacity: 0.55;
+  --rs-tag-close-opacity: 0.75;
+  display: inline-flex;
+  align-items: center;
+  gap: var(--rs-space-xs);
+  max-width: 100%;
+  border-radius: var(--rs-tag-radius, var(--rs-radius-sm));
+  font-weight: var(--rs-tag-font-weight, 400);
+  line-height: var(--rs-line-height-tight);
+  box-sizing: border-box;
+  vertical-align: middle;
+}
+.rs-tag--ssm[data-v-d8327085] {
+  padding-block: 0;
+  padding-inline: var(--rs-space-xs);
+  font-size: var(--rs-font-size-xs);
+}
+.rs-tag--sm[data-v-d8327085] {
+  padding-block: var(--rs-tag-pad-y-sm);
+  padding-inline: var(--rs-space-xs);
+  font-size: var(--rs-font-size-xs);
+}
+.rs-tag--md[data-v-d8327085] {
+  padding-block: var(--rs-tag-pad-y-md);
+  padding-inline: var(--rs-space-sm);
+  font-size: var(--rs-font-size-xs);
+}
+.rs-tag--lg[data-v-d8327085] {
+  padding-block: var(--rs-space-xs);
+  padding-inline: var(--rs-space-sm);
+  font-size: var(--rs-font-size-sm);
+}
+.rs-tag--round[data-v-d8327085] {
+  border-radius: var(--rs-radius-full);
+}
+.rs-tag--disabled[data-v-d8327085] {
+  opacity: var(--rs-tag-disabled-opacity);
+  cursor: not-allowed;
+}
+.rs-tag__content[data-v-d8327085] {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.rs-tag__close[data-v-d8327085] {
+  min-width: 0;
+  min-height: 0;
+  width: 1em;
+  height: 1em;
+  padding: 0;
+  color: inherit;
+  opacity: var(--rs-tag-close-opacity);
+}
+.rs-tag__close[data-v-d8327085]:hover:not(:disabled) {
+  opacity: 1;
+  color: inherit;
+  background: color-mix(in srgb, currentColor 12%, transparent);
+}
+.rs-tag--default[data-v-d8327085] {
+  background: var(--rs-surface-hover);
+  color: var(--rs-text-primary);
+  border: 1px solid var(--rs-border);
+}
+.rs-tag--primary[data-v-d8327085] {
+  background: var(--rs-primary-container);
+  color: var(--rs-on-primary-container);
+  border: 1px solid color-mix(in srgb, var(--rs-primary) var(--rs-tag-border-alpha, 40%), transparent);
+}
+.rs-tag--success[data-v-d8327085] {
+  background: var(--rs-success-container);
+  color: var(--rs-on-success-container);
+  border: 1px solid color-mix(in srgb, var(--rs-success) var(--rs-tag-border-alpha, 40%), transparent);
+}
+.rs-tag--warning[data-v-d8327085] {
+  background: var(--rs-warning-container);
+  color: var(--rs-on-warning-container);
+  border: 1px solid color-mix(in srgb, var(--rs-warning) var(--rs-tag-border-alpha, 40%), transparent);
+}
+.rs-tag--danger[data-v-d8327085] {
+  background: var(--rs-danger-container);
+  color: var(--rs-on-danger-container);
+  border: 1px solid color-mix(in srgb, var(--rs-danger) var(--rs-tag-border-alpha, 40%), transparent);
+}
+.rs-tag--info[data-v-d8327085] {
+  background: var(--rs-info-container);
+  color: var(--rs-on-info-container);
+  border: 1px solid color-mix(in srgb, var(--rs-info) var(--rs-tag-border-alpha, 40%), transparent);
+}
+@media (forced-colors: active) {
+.rs-tag[data-v-d8327085] {
+    border: 1px solid CanvasText;
+    forced-color-adjust: none;
+}
+}

package/dist/components/tag/src/RsTag.d.ts

@@ -0,0 +1,34 @@
+import { type RsComponentSize, type RsRadius } from '../../../theme/types';
+import type { RsTagVariant } from './tag-utils';
+export type { RsTagVariant };
+type __VLS_Props = {
+    variant?: RsTagVariant;
+    closable?: boolean;
+    disabled?: boolean;
+    /** 胶囊圆角快捷开关；等价于 radius="full" */
+    round?: boolean;
+    size?: RsComponentSize;
+    radius?: RsRadius;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => 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;
+}>, {
+    variant: RsTagVariant;
+    disabled: boolean;
+    closable: boolean;
+    round: 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/tag/src/RsTag.impl.js

@@ -0,0 +1,79 @@
+import { RS_COMPONENT_SIZE_ICON_PX } from "../../../theme/types.js";
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import { useResolvedRsComponentSize } from "../../_shared/src/resolve-size.js";
+import { rsRadiusCss, useResolvedRsRadius } from "../../_shared/src/resolve-radius.js";
+import RsButton_default from "../../button/src/RsButton.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, normalizeClass, normalizeStyle, openBlock, renderSlot, unref } from "vue";
+//#region src/components/tag/src/RsTag.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "rs-tag__content" };
+var RsTag_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsTag",
+	__name: "RsTag",
+	props: {
+		variant: { default: "default" },
+		closable: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		round: {
+			type: Boolean,
+			default: false
+		},
+		size: {},
+		radius: {}
+	},
+	emits: ["close"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { t } = useRsI18n();
+		const resolvedSize = useResolvedRsComponentSize(() => props.size);
+		const resolvedRadius = useResolvedRsRadius(() => props.round ? "full" : props.radius, "sm");
+		const closeIconSize = RS_COMPONENT_SIZE_ICON_PX.ssm;
+		const rootClass = computed(() => [
+			"rs-tag",
+			`rs-tag--${props.variant}`,
+			`rs-tag--${resolvedSize.value}`,
+			{
+				"rs-tag--closable": props.closable,
+				"rs-tag--disabled": props.disabled,
+				"rs-tag--round": props.round || resolvedRadius.value === "full"
+			}
+		]);
+		const rootStyle = computed(() => ({ "--rs-tag-radius": rsRadiusCss(resolvedRadius.value) }));
+		function onClose(event) {
+			if (props.disabled) return;
+			event.stopPropagation();
+			emit("close", event);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				class: normalizeClass(rootClass.value),
+				style: normalizeStyle(rootStyle.value)
+			}, [createElementVNode("span", _hoisted_1, [renderSlot(_ctx.$slots, "default", {}, void 0, true)]), __props.closable ? (openBlock(), createBlock(RsButton_default, {
+				key: 0,
+				class: "rs-tag__close",
+				variant: "text",
+				bordered: false,
+				size: "ssm",
+				radius: "full",
+				icon: "x",
+				"icon-size": unref(closeIconSize),
+				"icon-only": "",
+				disabled: __props.disabled,
+				"aria-label": unref(t)("tag.close"),
+				onClick: onClose
+			}, null, 8, [
+				"icon-size",
+				"disabled",
+				"aria-label"
+			])) : createCommentVNode("", true)], 6);
+		};
+	}
+});
+//#endregion
+export { RsTag_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/tag/src/RsTag.js

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

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

@@ -0,0 +1,8 @@
+/**
+ * RsTag 语义色。只有色相、没有形态轴，不另开 tone。
+ * 可增删的一组标签请用 RsDynamicTags。
+ */
+export declare const RS_TAG_VARIANTS: readonly ["default", "primary", "success", "warning", "danger", "info"];
+export type RsTagVariant = (typeof RS_TAG_VARIANTS)[number];
+export declare function isRsTagVariant(value: unknown): value is RsTagVariant;
+export declare function resolveRsTagVariant(variant?: RsTagVariant | null): RsTagVariant;

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

@@ -0,0 +1,3 @@
+export { default as RsTerminal } from './src/RsTerminal.js';
+export { buildAnsiColorDemo, containsEscapeSequence, getTerminalThemePalette, mergeTerminalTheme, readTerminalThemeFromCss, resolveTerminalTheme, terminalShortcutLabel, } from './src/terminal-utils';
+export type { RsResolvedTerminalTheme, RsTerminalAction, RsTerminalCursorStyle, RsTerminalExpose, RsTerminalGeometry, RsTerminalThemeMode, } from './src/terminal-utils';