niuma-ui 1.1.12 → 1.2.1

package/src/components/resolve-radius.ts

@@ -1,22 +0,0 @@
-import { computed, type ComputedRef } from 'vue'
-import { RS_RADIUS_CSS, type RsRadius } from '../theme/types'
-import { useRsConfigOptional } from '../composables/useRsConfig'
-
-/**
- * 解析圆角：props → ConfigProvider.controlRadius → 组件默认档。
- * 业务应传 `radius` / `iconRadius` 或依赖全局配置，避免 :deep 改 border-radius。
- */
-export function useResolvedRsRadius(
-  radius: () => RsRadius | undefined,
-  fallback: RsRadius,
-): ComputedRef<RsRadius> {
-  const config = useRsConfigOptional()
-  return computed(
-    () => radius() ?? config?.controlRadius.value ?? fallback,
-  )
-}
-
-/** 将档位转为可写入 style / CSS 变量的值。 */
-export function rsRadiusCss(radius: RsRadius): string {
-  return RS_RADIUS_CSS[radius]
-}

package/src/components/resolve-size.ts

@@ -1,29 +0,0 @@
-import { computed, type ComputedRef } from 'vue'
-import type { RsComponentSize } from '../theme/types'
-import { useRsConfigOptional } from '../composables/useRsConfig'
-import { useRsFormContext, type RsFormContext } from './form-utils'
-
-/**
- * 解析控件尺寸：props → Form → ConfigProvider → md。
- * 业务应传 `size` 或依赖全局/表单上下文，避免 :deep 改高度。
- */
-export function resolveRsComponentSize(
-  size: RsComponentSize | undefined,
-  form?: RsFormContext | null,
-): ComputedRef<RsComponentSize> {
-  const config = useRsConfigOptional()
-  return computed(
-    () => size ?? form?.size.value ?? config?.controlSize.value ?? 'md',
-  )
-}
-
-/** 在 setup 内便捷解析（自动读 Form / Config）。 */
-export function useResolvedRsComponentSize(
-  size: () => RsComponentSize | undefined,
-): ComputedRef<RsComponentSize> {
-  const form = useRsFormContext()
-  const config = useRsConfigOptional()
-  return computed(
-    () => size() ?? form?.size.value ?? config?.controlSize.value ?? 'md',
-  )
-}

package/src/components/scrollbar-utils.ts

@@ -1,10 +0,0 @@
-export type RsScrollbarType = 'auto' | 'always' | 'scroll' | 'hover'
-
-export type RsScrollbarOrientation = 'vertical' | 'horizontal' | 'both'
-
-export function resolveScrollbarSize(size: number | string | undefined): string | undefined {
-  if (size === undefined) {
-    return undefined
-  }
-  return typeof size === 'number' ? `${size}px` : size
-}

package/src/components/select-utils.ts

@@ -1,372 +0,0 @@
-export type RsSelectValue = string | number
-
-/** 过滤 / 回显比对字段名，默认 label；可传 value 或 fieldNames 映射后的键 */
-export type RsSelectOptionFilterProp = string
-
-export type RsSelectPlacement = 'top' | 'bottom' | 'left' | 'right'
-
-export type RsSelectStatus = 'error' | 'warning' | ''
-
-/** 自定义过滤（对齐 Ant Design filterOption）。返回 false 则隐藏该项。 */
-export type RsSelectFilterOption = (query: string, option: RsSelectOption) => boolean
-
-/** 过滤后排序（对齐 Ant Design filterSort） */
-export type RsSelectFilterSort = (a: RsSelectOption, b: RsSelectOption) => number
-
-export interface RsSelectOption {
-  label: string
-  value: RsSelectValue
-  disabled?: boolean
-  /** 原生 title；悬停展示补充说明 */
-  title?: string
-}
-
-export interface RsSelectOptionGroup {
-  label: string
-  options: RsSelectOption[]
-}
-
-export type RsSelectOptions = ReadonlyArray<RsSelectOption | RsSelectOptionGroup>
-
-/** 未正规化的选项（配合 fieldNames 可用 name/id/children 等业务字段） */
-export type RsSelectOptionInput = RsSelectOption | RsSelectOptionGroup | Record<string, unknown>
-
-export type RsSelectOptionsInput = ReadonlyArray<RsSelectOptionInput>
-
-/** 对齐 Ant Design fieldNames */
-export interface RsSelectFieldNames {
-  label?: string
-  value?: string
-  options?: string
-  disabled?: string
-  groupLabel?: string
-}
-
-export type RsSelectGetPopupContainer = (triggerNode?: HTMLElement) => string | HTMLElement | undefined
-
-/** labelInValue 时的 v-model 项（对齐 Ant Design） */
-export interface RsSelectLabeledValue {
-  label: string
-  value: RsSelectValue
-}
-
-export type RsSelectModelValue =
-  | RsSelectValue
-  | RsSelectValue[]
-  | RsSelectLabeledValue
-  | RsSelectLabeledValue[]
-  | ''
-
-/**
- * 按泛型收窄后的 v-model。
- * 默认单选、值为 string：宿主 `@update:model-value="(v: string) => void"` 可直接赋值。
- * `multiple` / `labelInValue` 为字面量 true 时收成数组或 labeled；为 `boolean` 时保留联合。
- */
-export type RsSelectResolvedModel<
-  Value extends RsSelectValue = string,
-  Multiple extends boolean = false,
-  LabelInValue extends boolean = false,
-> = LabelInValue extends true
-  ? Multiple extends true
-    ? RsSelectLabeledValue[]
-    : Multiple extends false
-      ? RsSelectLabeledValue | ''
-      : RsSelectLabeledValue | RsSelectLabeledValue[] | ''
-  : Multiple extends true
-    ? Value[]
-    : Multiple extends false
-      ? Value | ''
-      : Value | Value[] | ''
-
-/**
- * Reka ComboboxItem 禁止 value 为空串（空串表示未选中 / placeholder）。
- * 选项若传入 value: ''，对内映射为此哨兵，避免崩溃；对外读写仍为 ''。
- */
-export const RS_SELECT_EMPTY_VALUE = '__rs_select_empty__'
-
-/** 业务 value → ComboboxItem token（空串走哨兵；数字转为十进制字符串） */
-export function toComboboxValue(value: RsSelectValue): string {
-  return value === '' ? RS_SELECT_EMPTY_VALUE : String(value)
-}
-
-/** ComboboxItem token → 业务字符串（仅还原空串哨兵，不恢复 number） */
-export function fromComboboxValue(value: string): string {
-  return value === RS_SELECT_EMPTY_VALUE ? '' : value
-}
-
-export function isSelectOptionGroup(
-  item: RsSelectOption | RsSelectOptionGroup,
-): item is RsSelectOptionGroup {
-  return 'options' in item && Array.isArray(item.options)
-}
-
-export function flattenSelectOptions(options: RsSelectOptions): RsSelectOption[] {
-  const result: RsSelectOption[] = []
-  for (const item of options) {
-    if (isSelectOptionGroup(item)) {
-      result.push(...item.options)
-    } else {
-      result.push(item)
-    }
-  }
-  return result
-}
-
-export function findSelectOption(
-  options: RsSelectOptions,
-  token: string,
-): RsSelectOption | undefined {
-  const raw = fromComboboxValue(token)
-  return flattenSelectOptions(options).find((opt) => String(opt.value) === String(raw))
-}
-
-/**
- * Combobox token → 业务 value。
- * 优先返回 options 里的原始类型（number 0 保持为 0）；手输/未知项保持字符串。
- */
-export function restoreSelectValue(
-  token: string,
-  options: RsSelectOptions,
-): RsSelectValue {
-  const matched = findSelectOption(options, token)
-  if (matched) return matched.value
-  return fromComboboxValue(token)
-}
-
-export function restoreSelectValues(
-  tokens: string[],
-  options: RsSelectOptions,
-): RsSelectValue[] {
-  return tokens.map((token) => restoreSelectValue(token, options))
-}
-
-export function buildOptionLabelMap(options: RsSelectOptions): Map<string, string> {
-  const map = new Map<string, string>()
-  for (const opt of flattenSelectOptions(options)) {
-    const key = toComboboxValue(opt.value)
-    map.set(key, opt.label)
-    if (opt.value === '') map.set('', opt.label)
-  }
-  return map
-}
-
-export function buildOptionDisabledMap(options: RsSelectOptions): Map<string, boolean> {
-  const map = new Map<string, boolean>()
-  for (const opt of flattenSelectOptions(options)) {
-    const key = toComboboxValue(opt.value)
-    map.set(key, Boolean(opt.disabled))
-  }
-  return map
-}
-
-function optionFieldText(option: RsSelectOption, prop: string): string {
-  if (prop === 'value') return String(option.value)
-  if (prop === 'label' || !prop) return String(option.label)
-  const extra = Reflect.get(option, prop)
-  return extra == null ? String(option.label) : String(extra)
-}
-
-function defaultMatchOption(
-  option: RsSelectOption,
-  query: string,
-  contains: (text: string, search: string) => boolean,
-  optionFilterProp: RsSelectOptionFilterProp,
-): boolean {
-  return contains(optionFieldText(option, optionFilterProp), query)
-}
-
-function coerceSelectValue(raw: unknown): RsSelectValue {
-  if (typeof raw === 'number' || typeof raw === 'string') return raw
-  if (raw == null) return ''
-  return String(raw)
-}
-
-function mapSelectOption(
-  raw: Record<string, unknown>,
-  names: Required<Pick<RsSelectFieldNames, 'label' | 'value' | 'disabled'>>,
-): RsSelectOption {
-  const value = coerceSelectValue(raw[names.value])
-  const label = raw[names.label]
-  return {
-    ...raw,
-    value,
-    label: label == null ? String(value) : String(label),
-    disabled: Boolean(raw[names.disabled]),
-    title: typeof raw.title === 'string' ? raw.title : undefined,
-  }
-}
-
-/**
- * 按 fieldNames 把业务选项正规化为 { label, value, disabled }。
- * 默认键即为 label / value / options，既有调用无需改。
- */
-export function normalizeSelectOptions(
-  options: RsSelectOptionsInput,
-  fieldNames?: RsSelectFieldNames,
-): RsSelectOptions {
-  const labelKey = fieldNames?.label ?? 'label'
-  const valueKey = fieldNames?.value ?? 'value'
-  const optionsKey = fieldNames?.options ?? 'options'
-  const disabledKey = fieldNames?.disabled ?? 'disabled'
-  const groupLabelKey = fieldNames?.groupLabel ?? labelKey
-  const result: Array<RsSelectOption | RsSelectOptionGroup> = []
-
-  for (const item of options) {
-    if (!item || typeof item !== 'object') continue
-    const raw = item as Record<string, unknown>
-    const nested = raw[optionsKey]
-    if (Array.isArray(nested)) {
-      const children: RsSelectOption[] = []
-      for (const child of nested) {
-        if (!child || typeof child !== 'object') continue
-        children.push(mapSelectOption(child as Record<string, unknown>, {
-          label: labelKey,
-          value: valueKey,
-          disabled: disabledKey,
-        }))
-      }
-      result.push({
-        label: String(raw[groupLabelKey] ?? ''),
-        options: children,
-      })
-      continue
-    }
-    result.push(mapSelectOption(raw, { label: labelKey, value: valueKey, disabled: disabledKey }))
-  }
-  return result
-}
-
-/** 触发器 / tag 展示文案，对齐 Ant optionLabelProp */
-export function optionDisplayLabel(option: RsSelectOption, prop = 'label'): string {
-  return optionFieldText(option, prop)
-}
-
-export function comboboxBindingToTokens(value: unknown, multiple: boolean): string[] {
-  if (multiple) return Array.isArray(value) ? value.map(String) : []
-  if (value == null || value === '') return []
-  return [String(value)]
-}
-
-export function selectModelEntries(value: unknown): unknown[] {
-  if (Array.isArray(value)) return value
-  if (value === '' || value == null) return []
-  return [value]
-}
-
-export function filterSelectOptions(
-  options: RsSelectOptions,
-  query: string,
-  contains: (text: string, search: string) => boolean,
-  filterOption?: RsSelectFilterOption | boolean,
-  optionFilterProp: RsSelectOptionFilterProp = 'label',
-): RsSelectOptions {
-  if (filterOption === false) return options
-  const trimmed = query.trim()
-  if (!trimmed) return options
-
-  const match =
-    typeof filterOption === 'function'
-      ? (opt: RsSelectOption) => filterOption(trimmed, opt)
-      : (opt: RsSelectOption) => defaultMatchOption(opt, trimmed, contains, optionFilterProp)
-
-  const result: Array<RsSelectOption | RsSelectOptionGroup> = []
-  for (const item of options) {
-    if (isSelectOptionGroup(item)) {
-      const filtered = item.options.filter(match)
-      if (filtered.length > 0) {
-        result.push({ label: item.label, options: filtered })
-      }
-    } else if (match(item)) {
-      result.push(item)
-    }
-  }
-  return result as RsSelectOptions
-}
-
-export function flattenSelectValues(options: RsSelectOptions): string[] {
-  return flattenSelectOptions(options).map((opt) => toComboboxValue(opt.value))
-}
-
-export function toSelectedTokens(value: unknown, multiple: boolean): string[] {
-  const entries = multiple
-    ? selectModelEntries(value)
-    : Array.isArray(value) || value === '' || value == null
-      ? []
-      : [value]
-  const tokens: string[] = []
-  for (const entry of entries) {
-    const raw = unwrapSelectEntry(entry)
-    if (raw === null) continue
-    tokens.push(toComboboxValue(raw))
-  }
-  return tokens
-}
-
-export function isSelectLabeledValue(value: unknown): value is RsSelectLabeledValue {
-  return typeof value === 'object' && value !== null && !Array.isArray(value) && 'value' in value
-}
-
-export function unwrapSelectEntry(item: unknown): RsSelectValue | null {
-  if (item == null || item === '') return null
-  if (isSelectLabeledValue(item)) return item.value
-  if (typeof item === 'string' || typeof item === 'number') return item
-  return null
-}
-
-export function toLabeledValue(
-  value: RsSelectValue,
-  options: RsSelectOptions,
-): RsSelectLabeledValue {
-  const matched = flattenSelectOptions(options).find(
-    (opt) => String(opt.value) === String(value),
-  )
-  return {
-    value: matched ? matched.value : value,
-    label: matched?.label ?? String(value),
-  }
-}
-
-export function packSelectModel(
-  values: RsSelectValue[],
-  options: RsSelectOptions,
-  multiple: boolean,
-  labelInValue: boolean,
-): RsSelectModelValue {
-  if (multiple) {
-    return labelInValue ? values.map((value) => toLabeledValue(value, options)) : values
-  }
-  const first = values[0]
-  if (first === undefined) return ''
-  return labelInValue ? toLabeledValue(first, options) : first
-}
-
-export function sortSelectOptions(
-  options: RsSelectOptions,
-  sort?: RsSelectFilterSort,
-): RsSelectOptions {
-  if (!sort) return options
-  const next: Array<RsSelectOption | RsSelectOptionGroup> = []
-  const flats: RsSelectOption[] = []
-  const flushFlats = () => {
-    if (!flats.length) return
-    next.push(...[...flats].sort(sort))
-    flats.length = 0
-  }
-  for (const item of options) {
-    if (isSelectOptionGroup(item)) {
-      flushFlats()
-      next.push({ label: item.label, options: [...item.options].sort(sort) })
-    } else {
-      flats.push(item)
-    }
-  }
-  flushFlats()
-  return next as RsSelectOptions
-}
-
-export function splitByTokenSeparators(raw: string, separators: string[]): string[] | null {
-  if (!separators.length) return null
-  const found = separators.find((sep) => sep && raw.includes(sep))
-  if (!found) return null
-  return raw.split(found)
-}

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

@@ -1,254 +0,0 @@
-/** 面板分割方向：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
-}
-
-/**
- * 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[]
-}
-
-/** 模板 ref 实例：expose + 根节点 */
-export type RsSplitPaneInstance = RsSplitPaneExpose & { $el: HTMLElement }
-
-/** 由 RsSplitPaneItem 解析出的规范化约束 */
-export interface RsSplitConstraint {
-  min: number
-  max: number
-  collapsible: boolean
-  collapsedSize: number
-}
-
-const clamp = (value: number, lower: number, upper: number): number =>
-  Math.min(Math.max(value, lower), upper)
-
-/** 保留有限位小数，消除浮点毛刺 */
-export function roundSize(value: number, precision = 4): number {
-  const factor = 10 ** precision
-  return Math.round(value * factor) / factor
-}
-
-/** 是否为内容自适应尺寸 */
-export function isRsSplitPaneAutoSize(size: RsSplitPaneSize | undefined): size is 'auto' {
-  return size === 'auto'
-}
-
-/** 各面板是否声明为 auto（忽略受控 provided 时的瞬时物化） */
-export function resolveSplitAutoFlags(panes: RsSplitPaneItem[]): boolean[] {
-  return panes.map((pane) => isRsSplitPaneAutoSize(pane.size))
-}
-
-/** 将面板定义解析为规范化约束，保证 0 ≤ min ≤ max ≤ 100 且 collapsedSize ≤ min */
-export function resolveSplitConstraints(panes: RsSplitPaneItem[]): RsSplitConstraint[] {
-  return panes.map((pane) => {
-    const rawMin = clamp(pane.min ?? 0, 0, 100)
-    const rawMax = clamp(pane.max ?? 100, 0, 100)
-    const min = Math.min(rawMin, rawMax)
-    const max = Math.max(rawMin, rawMax)
-    const collapsedSize = clamp(pane.collapsedSize ?? 0, 0, min)
-    return {
-      min,
-      max,
-      collapsible: pane.collapsible ?? false,
-      collapsedSize,
-    }
-  })
-}
-
-/** 按比例把一组尺寸缩放到总和为 100 */
-function rescaleTo100(sizes: number[]): number[] {
-  if (!sizes.length) return []
-  const sum = sizes.reduce((acc, value) => acc + Math.max(0, value), 0)
-  if (sum <= 0) {
-    const each = 100 / sizes.length
-    return sizes.map(() => each)
-  }
-  return sizes.map((value) => (Math.max(0, value) / sum) * 100)
-}
-
-/**
- * 计算初始尺寸数组（非 auto 面板总和 100；auto 位为 0 占位，样式层不使用 flex-grow）。
- * 优先使用 provided（受控值），其次面板自身的 number size，未指定的非 auto 项在剩余空间内均分。
- */
-export function normalizeSplitSizes(
-  panes: RsSplitPaneItem[],
-  provided?: number[] | null,
-): number[] {
-  const count = panes.length
-  if (count === 0) return []
-
-  const autoFlags = resolveSplitAutoFlags(panes)
-  // 受控 sizes 一旦提供完整数组，视为已全部物化为百分比（含原 auto）
-  const fullyControlled =
-    Array.isArray(provided) &&
-    provided.length === count &&
-    provided.every((value) => typeof value === 'number' && Number.isFinite(value))
-
-  if (fullyControlled) {
-    return rescaleTo100(provided!.map((value) => Math.max(0, value))).map((value) =>
-      roundSize(value),
-    )
-  }
-
-  const seed: (number | null)[] = panes.map((pane, index) => {
-    if (autoFlags[index]) return 0
-    const candidate = provided?.[index] ?? (typeof pane.size === 'number' ? pane.size : null)
-    return typeof candidate === 'number' && Number.isFinite(candidate)
-      ? Math.max(0, candidate)
-      : null
-  })
-
-  const flexibleIndices = panes
-    .map((_, index) => index)
-    .filter((index) => !autoFlags[index])
-
-  if (flexibleIndices.length === 0) {
-    // 全部 auto：占位全 0，由内容撑开
-    return panes.map(() => 0)
-  }
-
-  const missing = flexibleIndices.filter((index) => seed[index] === null).length
-  const knownSum = flexibleIndices.reduce<number>((acc, index) => acc + (seed[index] ?? 0), 0)
-  const each = missing > 0 ? Math.max(0, 100 - knownSum) / missing : 0
-
-  const filled = seed.map((value, index) => {
-    if (autoFlags[index]) return 0
-    return value ?? each
-  })
-
-  // 只对非 auto 部分缩放到 100
-  const flexibleValues = flexibleIndices.map((index) => filled[index] ?? 0)
-  const scaledFlexible = rescaleTo100(flexibleValues)
-  const next = filled.slice()
-  flexibleIndices.forEach((paneIndex, i) => {
-    next[paneIndex] = roundSize(scaledFlexible[i] ?? 0)
-  })
-  return next
-}
-
-/** 判断某面板当前是否处于折叠态 */
-export function isSplitPaneCollapsed(size: number, constraint: RsSplitConstraint): boolean {
-  if (!constraint.collapsible) return false
-  return size <= constraint.collapsedSize + 0.01
-}
-
-/**
- * 在第 index 个分隔条（介于 pane[index] 与 pane[index+1] 之间）上拖动 deltaPercent。
- * 仅调整相邻两个面板，遵守各自 min/max，并在可折叠时吸附到 collapsedSize。
- * 返回新的尺寸数组（引用不同，总和保持不变）。
- */
-export function applySplitResize(
-  sizes: number[],
-  constraints: RsSplitConstraint[],
-  index: number,
-  deltaPercent: number,
-): number[] {
-  if (index < 0 || index >= sizes.length - 1) return sizes
-  const a = sizes[index]
-  const b = sizes[index + 1]
-  const ca = constraints[index]
-  const cb = constraints[index + 1]
-  if (a === undefined || b === undefined || !ca || !cb) return sizes
-
-  const total = a + b
-  let nextA = a + deltaPercent
-
-  // 收缩 A：越过阈值吸附折叠
-  if (ca.collapsible && deltaPercent < 0 && nextA < ca.min) {
-    nextA = nextA <= (ca.min + ca.collapsedSize) / 2 ? ca.collapsedSize : ca.min
-  }
-
-  // 收缩 B（即放大 A）：越过阈值吸附折叠 B
-  if (cb.collapsible && deltaPercent > 0) {
-    const nextB = total - nextA
-    if (nextB < cb.min) {
-      const snappedB = nextB <= (cb.min + cb.collapsedSize) / 2 ? cb.collapsedSize : cb.min
-      nextA = total - snappedB
-    }
-  }
-
-  // 硬约束：A 的可行区间需同时满足 A 与 B 的 min/max
-  const lowerA = Math.max(ca.collapsible ? ca.collapsedSize : ca.min, total - cb.max)
-  const upperA = Math.min(ca.max, total - (cb.collapsible ? cb.collapsedSize : cb.min))
-  nextA = clamp(nextA, Math.min(lowerA, upperA), Math.max(lowerA, upperA))
-
-  const next = sizes.slice()
-  next[index] = roundSize(nextA)
-  next[index + 1] = roundSize(total - nextA)
-  return next
-}
-
-/** 把 pane[index] 设为 target，差额从相邻面板（优先右侧）补偿 */
-function redistribute(sizes: number[], index: number, target: number): number[] {
-  const current = sizes[index]
-  if (current === undefined) return sizes
-  const neighbor = index + 1 < sizes.length ? index + 1 : index - 1
-  if (neighbor < 0) return sizes
-  const next = sizes.slice()
-  const delta = target - current
-  next[index] = roundSize(target)
-  next[neighbor] = roundSize(Math.max(0, (next[neighbor] ?? 0) - delta))
-  return next
-}
-
-/** 折叠 pane[index]（可折叠→collapsedSize，否则→min） */
-export function collapseSplitPane(
-  sizes: number[],
-  constraints: RsSplitConstraint[],
-  index: number,
-): number[] {
-  const constraint = constraints[index]
-  if (!constraint || sizes[index] === undefined) return sizes
-  const target = constraint.collapsible ? constraint.collapsedSize : constraint.min
-  return redistribute(sizes, index, target)
-}
-
-/** 展开 pane[index]（toSize 缺省时回到 min 或均分值），并夹紧到 [min, max] */
-export function expandSplitPane(
-  sizes: number[],
-  constraints: RsSplitConstraint[],
-  index: number,
-  toSize?: number,
-): number[] {
-  const constraint = constraints[index]
-  if (!constraint || sizes[index] === undefined) return sizes
-  const fallback = constraint.min > 0 ? constraint.min : 100 / Math.max(1, sizes.length)
-  const target = clamp(toSize ?? fallback, constraint.min, constraint.max)
-  return redistribute(sizes, index, target)
-}
-
-/** 两组尺寸是否近似相等（用于受控回写时避免抖动） */
-export function splitSizesEqual(a: number[], b: number[], epsilon = 0.01): boolean {
-  if (a.length !== b.length) return false
-  return a.every((value, index) => Math.abs(value - (b[index] ?? 0)) <= epsilon)
-}