ensis-ui 0.0.0-stage → 3.0.0

package/dist/components/split-pane/src/RsSplitPane.impl.js

@@ -0,0 +1,527 @@
+import { useRsConfigOptional } from "../../../composables/useRsConfig.js";
+import { resolveDirMode } from "../../../locale/apply.js";
+import { useRsI18n } from "../../../composables/useRsI18n.js";
+import RsIcon_default from "../../icon/src/RsIcon.js";
+import { applySplitResize, collapseSplitPane, expandSplitPane, invertSplitAxisDelta, isSplitPaneCollapsed, isSplitResizerInteractive, normalizeSplitSizes, resolveSplitAutoFlags, resolveSplitConstraints, roundSize, splitPaneDomId, splitSizesEqual } from "./split-pane-utils.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeModels, normalizeClass, normalizeStyle, onUnmounted, openBlock, ref, renderList, renderSlot, useId, useModel, watch } from "vue";
+//#region src/components/split-pane/src/RsSplitPane.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["id", "aria-label"];
+var _hoisted_2 = ["id", "data-pane-key"];
+var _hoisted_3 = [
+	"data-resizer-index",
+	"onPointerdown",
+	"onPointermove",
+	"onPointerup",
+	"onPointercancel",
+	"onLostpointercapture"
+];
+var _hoisted_4 = [
+	"tabindex",
+	"aria-orientation",
+	"aria-valuenow",
+	"aria-valuemin",
+	"aria-valuemax",
+	"aria-valuetext",
+	"aria-controls",
+	"aria-label",
+	"aria-disabled",
+	"onKeydown",
+	"onDblclick"
+];
+var _hoisted_5 = {
+	key: 0,
+	class: "rs-split__grip",
+	"aria-hidden": "true"
+};
+var RsSplitPane_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RsSplitPane",
+	__name: "RsSplitPane",
+	props: /*@__PURE__*/ mergeModels({
+		panes: {},
+		orientation: { default: "horizontal" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		keyboardStep: { default: 4 },
+		withHandle: {
+			type: Boolean,
+			default: false
+		},
+		fill: {
+			type: Boolean,
+			default: false
+		},
+		id: {},
+		ariaLabel: {}
+	}, {
+		"sizes": { default: () => [] },
+		"sizesModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels([
+		"resize",
+		"resize-end",
+		"resize-start",
+		"collapse",
+		"expand"
+	], ["update:sizes"]),
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		/** 各面板尺寸（百分比，总和 100） */
+		const model = useModel(__props, "sizes");
+		const emit = __emit;
+		const { t, locale } = useRsI18n();
+		const config = useRsConfigOptional();
+		const fallbackId = useId();
+		const rootRef = ref(null);
+		const sizes = ref([]);
+		const rootId = computed(() => props.id || fallbackId);
+		const groupLabel = computed(() => props.ariaLabel || t("split.label"));
+		const writingDir = computed(() => resolveDirMode(config?.dir.value ?? "auto", config?.locale.value ?? locale.value));
+		const constraints = computed(() => resolveSplitConstraints(props.panes));
+		const resizerCount = computed(() => Math.max(0, props.panes.length - 1));
+		/** 内容自适应面板标记；首次拖拽/键盘调整时会物化为百分比并清空 */
+		const autoFlags = ref(resolveSplitAutoFlags(props.panes));
+		/** pane key → 折叠前尺寸；expand 未显式传 toSize 时还原 */
+		const sizeBeforeCollapse = /* @__PURE__ */ new Map();
+		/** 归一化初始值，作为双击复位的基准 */
+		let initialSizes = normalizeSplitSizes(props.panes, modelSeed());
+		sizes.value = initialSizes.slice();
+		function modelSeed() {
+			return model.value && model.value.length === props.panes.length ? model.value : void 0;
+		}
+		function paneKeySignature() {
+			return props.panes.map((pane) => pane.key).join("|");
+		}
+		function pruneCollapseMemory() {
+			const keys = new Set(props.panes.map((pane) => pane.key));
+			for (const key of sizeBeforeCollapse.keys()) if (!keys.has(key)) sizeBeforeCollapse.delete(key);
+		}
+		watch(() => paneKeySignature(), () => {
+			const provided = sizes.value.length === props.panes.length ? sizes.value : void 0;
+			autoFlags.value = resolveSplitAutoFlags(props.panes);
+			initialSizes = normalizeSplitSizes(props.panes, provided);
+			sizes.value = initialSizes.slice();
+			pruneCollapseMemory();
+			syncModel(sizes.value);
+		});
+		watch(() => props.panes.map((pane) => pane.size).join("|"), () => {
+			autoFlags.value = resolveSplitAutoFlags(props.panes);
+			initialSizes = normalizeSplitSizes(props.panes, modelSeed());
+			if (!autoFlags.value.some(Boolean)) {
+				sizes.value = initialSizes.slice();
+				syncModel(sizes.value);
+			}
+		});
+		watch(model, (value) => {
+			if (!value || value.length !== props.panes.length) return;
+			if (splitSizesEqual(value, sizes.value)) return;
+			autoFlags.value = props.panes.map(() => false);
+			sizes.value = normalizeSplitSizes(props.panes, value);
+		});
+		function syncModel(next) {
+			if (!splitSizesEqual(model.value ?? [], next)) model.value = next.slice();
+		}
+		function commit(next) {
+			sizes.value = next;
+			syncModel(next);
+			emit("resize", next.slice());
+		}
+		function emitBoundaryTransitions(before, after) {
+			props.panes.forEach((pane, index) => {
+				const constraint = constraints.value[index];
+				const wasCollapsed = isSplitPaneCollapsed(before[index] ?? 0, constraint);
+				const nowCollapsed = isSplitPaneCollapsed(after[index] ?? 0, constraint);
+				if (!wasCollapsed && nowCollapsed) {
+					const prev = before[index];
+					if (prev !== void 0) sizeBeforeCollapse.set(pane.key, prev);
+					emit("collapse", pane.key);
+				} else if (wasCollapsed && !nowCollapsed) emit("expand", pane.key);
+			});
+		}
+		/** 展开目标：显式 toSize > 折叠前记忆 > 初始 size */
+		function resolveExpandSize(key, index, toSize) {
+			if (toSize !== void 0) return toSize;
+			return sizeBeforeCollapse.get(key) ?? initialSizes[index];
+		}
+		function paneDomId(key) {
+			return splitPaneDomId(rootId.value, key);
+		}
+		function resizerInteractive(index) {
+			return isSplitResizerInteractive(props.panes[index], props.disabled);
+		}
+		function resizerAriaLabel(index) {
+			return props.panes[index]?.resizerAriaLabel || t("split.resize");
+		}
+		function resizerValueText(index) {
+			return t("split.value", { value: Math.round(sizes.value[index] ?? 0) });
+		}
+		function resizerControls(index) {
+			return [props.panes[index], props.panes[index + 1]].filter((pane) => Boolean(pane)).map((pane) => paneDomId(pane.key)).join(" ");
+		}
+		/** 跟计算样式，避免只读 Config 而父级已写 dir=rtl */
+		function rootIsRtl() {
+			const root = rootRef.value;
+			if (root && typeof getComputedStyle === "function") return getComputedStyle(root).direction === "rtl";
+			return writingDir.value === "rtl";
+		}
+		function axisDelta(raw) {
+			return invertSplitAxisDelta(props.orientation, rootIsRtl(), raw);
+		}
+		let dragIndex = null;
+		let dragOrigin = 0;
+		let dragStartSizes = [];
+		let flexPx = 0;
+		let pendingDragSizes = null;
+		let dragFrame = 0;
+		let dragTarget = null;
+		let dragPointerId = null;
+		let dragPaneEls = [];
+		function directPaneElements(root) {
+			return [...root.children].filter((el) => el instanceof HTMLElement && el.classList.contains("rs-split__pane"));
+		}
+		function paneElements() {
+			const root = rootRef.value;
+			if (!root) return [];
+			return directPaneElements(root);
+		}
+		/** 拖拽过程中直接写 flex-grow，避免每帧触发 Vue 重渲染 */
+		function applyDragToDom(next) {
+			const panes = dragPaneEls.length ? dragPaneEls : paneElements();
+			next.forEach((size, i) => {
+				panes[i]?.style.setProperty("flex-grow", String(size));
+			});
+		}
+		function setDraggingUi(active, host) {
+			rootRef.value?.classList.toggle("rs-split--dragging", active);
+			if (!host) return;
+			if (active) host.dataset.active = "";
+			else delete host.dataset.active;
+		}
+		function scheduleDragApply(next) {
+			pendingDragSizes = next;
+			if (dragFrame) return;
+			dragFrame = requestAnimationFrame(() => {
+				dragFrame = 0;
+				if (!pendingDragSizes) return;
+				applyDragToDom(pendingDragSizes);
+				emit("resize", pendingDragSizes.slice());
+			});
+		}
+		function clearDragInlineStyles() {
+			(dragPaneEls.length ? dragPaneEls : paneElements()).forEach((el) => {
+				el.style.removeProperty("flex-grow");
+			});
+		}
+		function releaseDragPointer() {
+			if (dragTarget && dragPointerId != null) try {
+				dragTarget.releasePointerCapture(dragPointerId);
+			} catch {}
+			dragTarget = null;
+			dragPointerId = null;
+		}
+		function abortDrag() {
+			if (dragFrame) {
+				cancelAnimationFrame(dragFrame);
+				dragFrame = 0;
+			}
+			const host = dragTarget;
+			const index = dragIndex;
+			releaseDragPointer();
+			if (index !== null) {
+				setDraggingUi(false, host);
+				clearDragInlineStyles();
+			}
+			dragIndex = null;
+			pendingDragSizes = null;
+			dragPaneEls = [];
+		}
+		function finishDrag(index) {
+			if (dragIndex !== index) return;
+			if (dragFrame) {
+				cancelAnimationFrame(dragFrame);
+				dragFrame = 0;
+			}
+			const host = dragTarget;
+			const final = pendingDragSizes ?? sizes.value;
+			pendingDragSizes = null;
+			dragIndex = null;
+			releaseDragPointer();
+			setDraggingUi(false, host);
+			clearDragInlineStyles();
+			dragPaneEls = [];
+			commit(final);
+			emitBoundaryTransitions(dragStartSizes, final);
+			emit("resize-end", final.slice());
+		}
+		function axisSize(el) {
+			return props.orientation === "horizontal" ? el.offsetWidth : el.offsetHeight;
+		}
+		/** 可伸缩空间的像素总量（不含分隔条），用于像素→百分比换算 */
+		function measureFlexPx() {
+			const root = rootRef.value;
+			if (!root) return 0;
+			let sum = 0;
+			directPaneElements(root).forEach((el) => {
+				sum += axisSize(el);
+			});
+			return sum;
+		}
+		function onResizerPointerDown(index, event) {
+			if (!resizerInteractive(index)) return;
+			if (event.pointerType === "mouse" && event.button !== 0) return;
+			materializeAutoPanes();
+			const target = event.currentTarget;
+			target.setPointerCapture?.(event.pointerId);
+			dragIndex = index;
+			dragOrigin = props.orientation === "horizontal" ? event.clientX : event.clientY;
+			dragStartSizes = sizes.value.slice();
+			pendingDragSizes = dragStartSizes;
+			flexPx = measureFlexPx();
+			dragTarget = target;
+			dragPointerId = event.pointerId;
+			dragPaneEls = paneElements();
+			setDraggingUi(true, target);
+			emit("resize-start", dragStartSizes.slice());
+			event.preventDefault();
+		}
+		function onResizerPointerMove(index, event) {
+			if (dragIndex !== index || flexPx <= 0) return;
+			const deltaPercent = axisDelta(((props.orientation === "horizontal" ? event.clientX : event.clientY) - dragOrigin) / flexPx * 100);
+			scheduleDragApply(applySplitResize(dragStartSizes, constraints.value, index, deltaPercent));
+		}
+		function endDrag(index, event) {
+			if (dragIndex !== index) return;
+			if (dragTarget && event.pointerId === dragPointerId) try {
+				dragTarget.releasePointerCapture(event.pointerId);
+			} catch {}
+			finishDrag(index);
+		}
+		function onLostPointerCapture(index) {
+			if (dragIndex !== index) return;
+			finishDrag(index);
+		}
+		function onResizerKeydown(index, event) {
+			if (!resizerInteractive(index)) return;
+			materializeAutoPanes();
+			const horizontal = props.orientation === "horizontal";
+			const step = props.keyboardStep;
+			let delta = 0;
+			switch (event.key) {
+				case "ArrowLeft":
+					if (horizontal) delta = axisDelta(-step);
+					break;
+				case "ArrowRight":
+					if (horizontal) delta = axisDelta(step);
+					break;
+				case "ArrowUp":
+					if (!horizontal) delta = -step;
+					break;
+				case "ArrowDown":
+					if (!horizontal) delta = step;
+					break;
+				case "Home":
+					delta = -100;
+					break;
+				case "End":
+					delta = 100;
+					break;
+				case "Enter":
+				case " ":
+					event.preventDefault();
+					toggleCollapseAt(index);
+					return;
+				default: return;
+			}
+			if (delta === 0) return;
+			event.preventDefault();
+			emit("resize-start", sizes.value.slice());
+			const before = sizes.value.slice();
+			commit(applySplitResize(sizes.value, constraints.value, index, delta));
+			emitBoundaryTransitions(before, sizes.value);
+			emit("resize-end", sizes.value.slice());
+		}
+		function onResizerDblClick(index) {
+			if (!resizerInteractive(index)) return;
+			materializeAutoPanes();
+			const a = sizes.value[index];
+			const b = sizes.value[index + 1];
+			const initA = initialSizes[index];
+			const initB = initialSizes[index + 1];
+			if (a === void 0 || b === void 0 || initA === void 0 || initB === void 0) return;
+			const total = a + b;
+			const initTotal = initA + initB;
+			const targetA = initTotal > 0 ? initA / initTotal * total : total / 2;
+			const next = sizes.value.slice();
+			next[index] = roundSize(targetA);
+			next[index + 1] = roundSize(total - targetA);
+			const before = sizes.value.slice();
+			commit(next);
+			emitBoundaryTransitions(before, sizes.value);
+			emit("resize-end", sizes.value.slice());
+		}
+		/** 分隔条 index 两侧择一可折叠面板进行折叠/展开切换 */
+		function collapsibleCandidate(index) {
+			if (constraints.value[index]?.collapsible) return index;
+			if (constraints.value[index + 1]?.collapsible) return index + 1;
+			return -1;
+		}
+		function toggleCollapseAt(index) {
+			const candidate = collapsibleCandidate(index);
+			if (candidate < 0) return;
+			const before = sizes.value.slice();
+			const collapsed = isSplitPaneCollapsed(sizes.value[candidate] ?? 0, constraints.value[candidate]);
+			const key = props.panes[candidate]?.key;
+			commit(collapsed ? expandSplitPane(sizes.value, constraints.value, candidate, key ? resolveExpandSize(key, candidate) : void 0) : collapseSplitPane(sizes.value, constraints.value, candidate));
+			emitBoundaryTransitions(before, sizes.value);
+			emit("resize-end", sizes.value.slice());
+		}
+		/** 将 auto 面板按当前像素占比物化为百分比，之后走统一拖拽逻辑 */
+		function materializeAutoPanes() {
+			if (!autoFlags.value.some(Boolean)) return;
+			const total = measureFlexPx();
+			if (total <= 0) return;
+			const measured = paneElements().map((el) => axisSize(el) / total * 100);
+			const next = normalizeSplitSizes(props.panes.map((pane) => ({
+				...pane,
+				size: typeof pane.size === "number" ? pane.size : void 0
+			})), measured);
+			autoFlags.value = props.panes.map(() => false);
+			sizes.value = next;
+			syncModel(next);
+		}
+		function paneStyle(index) {
+			if (autoFlags.value[index]) {
+				const pane = props.panes[index];
+				const vertical = props.orientation === "vertical";
+				const style = {
+					flexGrow: "0",
+					flexShrink: "0",
+					flexBasis: "auto",
+					[vertical ? "minHeight" : "minWidth"]: "min-content"
+				};
+				if (typeof pane?.min === "number" && pane.min > 0) style[vertical ? "minHeight" : "minWidth"] = `${pane.min}%`;
+				if (typeof pane?.max === "number" && pane.max < 100) style[vertical ? "maxHeight" : "maxWidth"] = `${pane.max}%`;
+				return style;
+			}
+			const size = sizes.value[index] ?? 0;
+			return {
+				flexGrow: String(size),
+				flexShrink: "1",
+				flexBasis: "0%"
+			};
+		}
+		function paneCollapsed(index) {
+			if (autoFlags.value[index]) return false;
+			return isSplitPaneCollapsed(sizes.value[index] ?? 0, constraints.value[index]);
+		}
+		/** 分隔条 index（位于 panes[index] 与 panes[index+1] 之间）是否显示抓手 */
+		function resizerShowsHandle(index) {
+			const pane = props.panes[index];
+			if (pane?.resizerHandle !== void 0) return pane.resizerHandle;
+			return props.withHandle;
+		}
+		function indexOfKey(key) {
+			return props.panes.findIndex((pane) => pane.key === key);
+		}
+		function collapse(key) {
+			const index = indexOfKey(key);
+			if (index < 0) return;
+			const before = sizes.value.slice();
+			const next = collapseSplitPane(sizes.value, constraints.value, index);
+			if (splitSizesEqual(before, next)) return;
+			commit(next);
+			emitBoundaryTransitions(before, sizes.value);
+			emit("resize-end", sizes.value.slice());
+		}
+		function expand(key, toSize) {
+			const index = indexOfKey(key);
+			if (index < 0) return;
+			const before = sizes.value.slice();
+			const next = expandSplitPane(sizes.value, constraints.value, index, resolveExpandSize(key, index, toSize));
+			if (splitSizesEqual(before, next)) return;
+			commit(next);
+			emitBoundaryTransitions(before, sizes.value);
+			emit("resize-end", sizes.value.slice());
+		}
+		function reset() {
+			autoFlags.value = resolveSplitAutoFlags(props.panes);
+			initialSizes = normalizeSplitSizes(props.panes);
+			commit(initialSizes.slice());
+			emit("resize-end", sizes.value.slice());
+		}
+		function focus(index) {
+			const root = rootRef.value;
+			if (!root) return;
+			const hosts = [...root.querySelectorAll("[data-resizer-index]")];
+			((index !== void 0 ? hosts.find((el) => Number(el.dataset.resizerIndex) === index) : hosts.find((el) => resizerInteractive(Number(el.dataset.resizerIndex)))) ?? hosts[0])?.querySelector(".rs-split__resizer")?.focus();
+		}
+		onUnmounted(() => {
+			abortDrag();
+			sizeBeforeCollapse.clear();
+		});
+		__expose({
+			collapse,
+			expand,
+			reset,
+			getSizes: () => sizes.value.slice(),
+			focus
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				id: __props.id,
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: normalizeClass(["rs-split", [`rs-split--${__props.orientation}`, {
+					"rs-split--disabled": __props.disabled,
+					"rs-split--fill": __props.fill
+				}]]),
+				role: "group",
+				"aria-label": groupLabel.value
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.panes, (pane, index) => {
+				return openBlock(), createElementBlock(Fragment, { key: pane.key }, [createElementVNode("div", {
+					id: paneDomId(pane.key),
+					class: normalizeClass(["rs-split__pane", {
+						"rs-split__pane--collapsed": paneCollapsed(index),
+						"rs-split__pane--auto": autoFlags.value[index]
+					}]),
+					style: normalizeStyle(paneStyle(index)),
+					"data-pane-key": pane.key
+				}, [renderSlot(_ctx.$slots, pane.key, {
+					size: sizes.value[index],
+					collapsed: paneCollapsed(index)
+				})], 14, _hoisted_2), index < resizerCount.value ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(["rs-split__resizer-host", {
+						"rs-split__resizer-host--handle": resizerShowsHandle(index),
+						"rs-split__resizer-host--disabled": !resizerInteractive(index)
+					}]),
+					"data-resizer-index": index,
+					onPointerdown: ($event) => onResizerPointerDown(index, $event),
+					onPointermove: ($event) => onResizerPointerMove(index, $event),
+					onPointerup: ($event) => endDrag(index, $event),
+					onPointercancel: ($event) => endDrag(index, $event),
+					onLostpointercapture: ($event) => onLostPointerCapture(index)
+				}, [createElementVNode("hr", {
+					class: normalizeClass(["rs-split__resizer", { "rs-split__resizer--handle": resizerShowsHandle(index) }]),
+					tabindex: resizerInteractive(index) ? 0 : -1,
+					"aria-orientation": __props.orientation === "horizontal" ? "vertical" : "horizontal",
+					"aria-valuenow": Math.round(sizes.value[index] ?? 0),
+					"aria-valuemin": Math.round(constraints.value[index]?.min ?? 0),
+					"aria-valuemax": Math.round(constraints.value[index]?.max ?? 100),
+					"aria-valuetext": resizerValueText(index),
+					"aria-controls": resizerControls(index),
+					"aria-label": resizerAriaLabel(index),
+					"aria-disabled": resizerInteractive(index) ? void 0 : true,
+					onKeydown: ($event) => onResizerKeydown(index, $event),
+					onDblclick: ($event) => onResizerDblClick(index)
+				}, null, 42, _hoisted_4), resizerShowsHandle(index) ? (openBlock(), createElementBlock("span", _hoisted_5, [createVNode(RsIcon_default, {
+					name: __props.orientation === "horizontal" ? "grip-vertical" : "grip-horizontal",
+					size: 12
+				}, null, 8, ["name"])])) : createCommentVNode("", true)], 42, _hoisted_3)) : createCommentVNode("", true)], 64);
+			}), 128))], 10, _hoisted_1);
+		};
+	}
+});
+//#endregion
+export { RsSplitPane_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/split-pane/src/RsSplitPane.js

@@ -0,0 +1,7 @@
+import './RsSplitPane.css'
+import RsSplitPane_vue_vue_type_script_setup_true_lang_default from "./RsSplitPane.impl.js";
+
+//#region src/components/split-pane/src/RsSplitPane.vue
+var RsSplitPane_default = RsSplitPane_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RsSplitPane_default as default };

package/dist/components/split-pane/src/split-pane-utils.d.ts

@@ -0,0 +1,97 @@
+/** 面板分割方向：horizontal 左右排布（拖动横向）· vertical 上下排布（拖动纵向） */
+export type RsSplitOrientation = 'horizontal' | 'vertical';
+/** 面板尺寸：数字为占比百分比；'auto' 按内容自适应（不占百分比配额） */
+export type RsSplitPaneSize = number | 'auto';
+/** 单个面板定义；百分比尺寸单位为 0~100 */
+export interface RsSplitPaneItem {
+    /** 唯一标识，用于插槽名与 v-model:sizes 的顺序映射 */
+    key: string;
+    /**
+     * 初始尺寸
+     * - number：占比百分比
+     * - 'auto'：按内容自适应（flex-basis: auto）
+     * - 缺省：在「非 auto」面板的剩余百分比内均分
+     */
+    size?: RsSplitPaneSize;
+    /** 最小尺寸（百分比），默认 0；auto 面板可作为 min-height/min-width % */
+    min?: number;
+    /** 最大尺寸（百分比），默认 100；auto 面板可作为 max-height/max-width % */
+    max?: number;
+    /** 是否可折叠：拖动越过阈值时吸附到 collapsedSize */
+    collapsible?: boolean;
+    /** 折叠后的尺寸（百分比），默认 0；会被限制在 [0, min] */
+    collapsedSize?: number;
+    /** 本面板右侧分隔条是否显示抓手；缺省时继承 RsSplitPane.withHandle */
+    resizerHandle?: boolean;
+    /**
+     * 本面板右侧 / 下方分隔条是否可拖、可键盘调整。
+     * 默认 true；false 时缝仍渲染，但不能改尺寸。
+     */
+    resizable?: boolean;
+    /** 覆盖本缝的 aria-label；缺省走 split.resize */
+    resizerAriaLabel?: string;
+}
+/** 具名插槽参数：当前占比与是否折叠 */
+export interface RsSplitPaneSlot {
+    size: number;
+    collapsed: boolean;
+}
+/**
+ * RsSplitPane 模板 ref 请用此类型。
+ * 不要写 `InstanceType<typeof RsSplitPane>`：组件实例类型过深，vue-tsc 会报 Excessive stack depth。
+ */
+export interface RsSplitPaneExpose {
+    collapse: (key: string) => void;
+    expand: (key: string, toSize?: number) => void;
+    reset: () => void;
+    getSizes: () => number[];
+    /** 聚焦第 index 条分隔条（默认第一条可交互缝） */
+    focus: (index?: number) => void;
+}
+/** 模板 ref 实例：expose + 根节点 */
+export type RsSplitPaneInstance = RsSplitPaneExpose & {
+    $el: HTMLElement;
+};
+/** 由 RsSplitPaneItem 解析出的规范化约束 */
+export interface RsSplitConstraint {
+    min: number;
+    max: number;
+    collapsible: boolean;
+    collapsedSize: number;
+}
+/** 保留有限位小数，消除浮点毛刺 */
+export declare function roundSize(value: number, precision?: number): number;
+/** 是否为内容自适应尺寸 */
+export declare function isRsSplitPaneAutoSize(size: RsSplitPaneSize | undefined): size is 'auto';
+/** 各面板是否声明为 auto（忽略受控 provided 时的瞬时物化） */
+export declare function resolveSplitAutoFlags(panes: RsSplitPaneItem[]): boolean[];
+/** 将面板定义解析为规范化约束，保证 0 ≤ min ≤ max ≤ 100 且 collapsedSize ≤ min */
+export declare function resolveSplitConstraints(panes: RsSplitPaneItem[]): RsSplitConstraint[];
+/**
+ * 计算初始尺寸数组（非 auto 面板总和 100；auto 位为 0 占位，样式层不使用 flex-grow）。
+ * 优先使用 provided（受控值），其次面板自身的 number size，未指定的非 auto 项在剩余空间内均分。
+ */
+export declare function normalizeSplitSizes(panes: RsSplitPaneItem[], provided?: number[] | null): number[];
+/** 判断某面板当前是否处于折叠态 */
+export declare function isSplitPaneCollapsed(size: number, constraint: RsSplitConstraint): boolean;
+/**
+ * 在第 index 个分隔条（介于 pane[index] 与 pane[index+1] 之间）上拖动 deltaPercent。
+ * 仅调整相邻两个面板，遵守各自 min/max，并在可折叠时吸附到 collapsedSize。
+ * 返回新的尺寸数组（引用不同，总和保持不变）。
+ */
+export declare function applySplitResize(sizes: number[], constraints: RsSplitConstraint[], index: number, deltaPercent: number): number[];
+/** 折叠 pane[index]（可折叠→collapsedSize，否则→min） */
+export declare function collapseSplitPane(sizes: number[], constraints: RsSplitConstraint[], index: number): number[];
+/** 展开 pane[index]（toSize 缺省时回到 min 或均分值），并夹紧到 [min, max] */
+export declare function expandSplitPane(sizes: number[], constraints: RsSplitConstraint[], index: number, toSize?: number): number[];
+/** 两组尺寸是否近似相等（用于受控回写时避免抖动） */
+export declare function splitSizesEqual(a: number[], b: number[], epsilon?: number): boolean;
+/**
+ * RTL 下行方向主轴与视觉左右对调：指针 / 左右键的增量要取反，
+ * 分隔条才跟手、且符合 APG「方向键按物理方向移动分隔条」。
+ */
+export declare function invertSplitAxisDelta(orientation: RsSplitOrientation, rtl: boolean, delta: number): number;
+/** 面板 DOM id：给 separator 的 aria-controls 用 */
+export declare function splitPaneDomId(rootId: string, key: string): string;
+/** 第 index 条缝（pane[index] 右侧 / 下方）是否允许拖拽与键盘调整 */
+export declare function isSplitResizerInteractive(pane: RsSplitPaneItem | undefined, disabled: boolean): boolean;