STab2.js 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475
  1. const n = `<template>
  2. <div class="s-tab" :class="{ dragging }">
  3. <button
  4. v-if="hasOverflow"
  5. type="link"
  6. class="s-tab-arrow prev"
  7. :disabled="!canPrevTab"
  8. :title="$l('上一个')"
  9. @click="handPrev"
  10. >
  11. <left-outlined />
  12. </button>
  13. <div
  14. ref="scrollRef"
  15. class="s-tab-scroll"
  16. role="tablist"
  17. @scroll="syncArrow"
  18. @wheel.prevent="handWheel"
  19. @pointerdown="handDragStart"
  20. @dragstart.prevent
  21. @click.capture="swallowClick"
  22. >
  23. <div ref="trackRef" class="s-tab-track">
  24. <!-- 用法一:传 tabs 数组,组件自己渲染标签 -->
  25. <template v-if="!hasItems">
  26. <a
  27. v-for="(item, index) in list"
  28. :key="keyOf(item, index)"
  29. class="s-tab-item"
  30. :class="{ active: keyOf(item, index) === innerActive }"
  31. :data-value="keyOf(item, index)"
  32. role="tab"
  33. :aria-selected="keyOf(item, index) === innerActive"
  34. :tabindex="keyOf(item, index) === innerActive ? 0 : -1"
  35. @click="handSelect(keyOf(item, index))"
  36. @keydown.left.prevent="handPrev"
  37. @keydown.right.prevent="handNext"
  38. >
  39. {{ labelOf(item) }}
  40. </a>
  41. </template>
  42. <!-- 用法二:不传 tabs,用 <s-tab-item value="x">标签</s-tab-item> 自己写 -->
  43. <slot v-else />
  44. </div>
  45. </div>
  46. <button
  47. v-if="hasOverflow"
  48. type="link"
  49. class="s-tab-arrow next"
  50. :disabled="!canNextTab"
  51. :title="$l('下一个')"
  52. @click="handNext"
  53. >
  54. <right-outlined />
  55. </button>
  56. </div>
  57. </template>
  58. <script setup>
  59. import { computed, nextTick, onBeforeUnmount, onMounted, provide, ref, useSlots, watch } from 'vue'
  60. defineOptions({ name: 'STab' })
  61. const props = defineProps({
  62. // 用法一的数据源:[{ label, value }];字段名可用 tabKey 改
  63. tabs: {
  64. type: Array,
  65. default: () => []
  66. },
  67. // 当前选中值(v-model:activeKey)
  68. activeKey: {
  69. type: [String, Number],
  70. default: ''
  71. },
  72. // 默认选中值:activeKey 未传(或传空)时用它;它也没传就自动选中第一项
  73. defaultActiveKey: {
  74. type: [String, Number],
  75. default: ''
  76. },
  77. // 标签字段映射,默认 { label: 'label', value: 'value' }
  78. tabKey: {
  79. type: Object,
  80. default: () => ({ label: 'label', value: 'value' })
  81. },
  82. // 已到首个/末个标签但仍可滚动时,一次滚多少屏
  83. stepRatio: {
  84. type: Number,
  85. default: 0.6
  86. }
  87. })
  88. const emit = defineEmits(['update:activeKey', 'change'])
  89. // 标签与容器之间的呼吸空隙,滚动定位时留出来,避免贴边
  90. const GAP = 8
  91. const slots = useSlots()
  92. const scrollRef = ref(null)
  93. const trackRef = ref(null)
  94. const canPrev = ref(false)
  95. const canNext = ref(false)
  96. const hasOverflow = ref(false)
  97. const innerActive = ref(props.activeKey)
  98. // 是否处于「鼠标拖拽滑动」中(只影响光标与文字选择,不影响布局)
  99. const dragging = ref(false)
  100. const list = computed(() => props.tabs || [])
  101. const keyField = computed(() => (props.tabKey && props.tabKey.value) || 'value')
  102. const labelField = computed(() => (props.tabKey && props.tabKey.label) || 'label')
  103. // 是否用了 <s-tab-item> 写法(此时 tabs 数组不参与渲染)
  104. const hasItems = computed(() => !!slots.default)
  105. function keyOf(item, index) {
  106. const v = item && item[keyField.value]
  107. return v === undefined || v === null ? index : v
  108. }
  109. function labelOf(item) {
  110. if (!item) return ''
  111. const v = item[labelField.value]
  112. return v === undefined || v === null ? (item.label ?? item.tab ?? '') : v
  113. }
  114. // 空选中值统一判定:''/undefined/null 都视为「没传」
  115. const isEmptyKey = (v) => v === '' || v === undefined || v === null
  116. // 第一项的 key:数组模式直接取数据(保留 Number/String 原始类型),插槽模式从渲染结果读
  117. function firstKey() {
  118. if (!hasItems.value && list.value.length) return keyOf(list.value[0], 0)
  119. const els = itemEls()
  120. return els.length ? els[0].dataset.value : ''
  121. }
  122. // 解析默认值:传了 defaultActiveKey 就用它,没传取第一项
  123. function defaultKey() {
  124. return isEmptyKey(props.defaultActiveKey) ? firstKey() : props.defaultActiveKey
  125. }
  126. // 当前没有选中值时补上默认值;真的补了才返回 true(供调用方决定要不要同步给父级)
  127. function ensureActive() {
  128. if (!isEmptyKey(innerActive.value)) return false
  129. const key = defaultKey()
  130. if (isEmptyKey(key)) return false
  131. innerActive.value = key
  132. return true
  133. }
  134. // 两种用法统一从 DOM 取标签:数组模式由本组件渲染、插槽模式来自 s-tab-item,
  135. // 都带 .s-tab-item 与 data-value,滚动/切换只认这两个标记,逻辑不用分叉
  136. function itemEls() {
  137. const track = trackRef.value
  138. return track ? Array.from(track.querySelectorAll('.s-tab-item')) : []
  139. }
  140. function indexOfActive() {
  141. return itemEls().findIndex((el) => el.dataset.value === String(innerActive.value))
  142. }
  143. // 箭头显隐:只有内容放不下(出现横向溢出)时才显示,放得下就铺满整行
  144. function syncArrow() {
  145. const box = scrollRef.value
  146. if (!box) return
  147. hasOverflow.value = box.scrollWidth - box.clientWidth > 1
  148. canPrev.value = box.scrollLeft > 1
  149. canNext.value = box.scrollLeft + box.clientWidth < box.scrollWidth - 1
  150. }
  151. // 把某个标签滚进可视区(只动横向,不惊动外层纵向滚动)
  152. function scrollToEl(el) {
  153. const box = scrollRef.value
  154. if (!box || !el) return
  155. const boxRect = box.getBoundingClientRect()
  156. const elRect = el.getBoundingClientRect()
  157. let next = null
  158. if (elRect.left < boxRect.left) {
  159. next = box.scrollLeft + (elRect.left - boxRect.left) - GAP
  160. } else if (elRect.right > boxRect.right) {
  161. next = box.scrollLeft + (elRect.right - boxRect.right) + GAP
  162. }
  163. if (next !== null) {
  164. box.scrollTo({ left: Math.max(0, next), behavior: 'smooth' })
  165. }
  166. }
  167. function scrollToActive() {
  168. const i = indexOfActive()
  169. if (i >= 0) scrollToEl(itemEls()[i])
  170. }
  171. // 已到首个/末个标签但仍可滚动时,箭头退化为「纯滚动一屏」
  172. function scrollByStep(dir) {
  173. const box = scrollRef.value
  174. if (!box) return
  175. box.scrollBy({ left: dir * box.clientWidth * props.stepRatio, behavior: 'smooth' })
  176. }
  177. function handSelect(key) {
  178. if (key === innerActive.value) return
  179. innerActive.value = key
  180. emit('update:activeKey', key)
  181. const idx = list.value.findIndex((item, i) => keyOf(item, i) === key)
  182. emit('change', key, idx >= 0 ? list.value[idx] : undefined)
  183. nextTick(scrollToActive)
  184. }
  185. function handPrev() {
  186. const els = itemEls()
  187. const i = indexOfActive()
  188. if (i > 0) {
  189. handSelect(els[i - 1].dataset.value)
  190. return
  191. }
  192. scrollByStep(-1)
  193. }
  194. function handNext() {
  195. const els = itemEls()
  196. const i = indexOfActive()
  197. if (i >= 0 && i < els.length - 1) {
  198. handSelect(els[i + 1].dataset.value)
  199. return
  200. }
  201. scrollByStep(1)
  202. }
  203. // 鼠标滚轮纵向滚动转横向(触控板/tab 行常见交互),避免整页跟着滚
  204. function handWheel(e) {
  205. const box = scrollRef.value
  206. if (!box || !hasOverflow.value) return
  207. const delta = Math.abs(e.deltaX) > Math.abs(e.deltaY) ? e.deltaX : e.deltaY
  208. box.scrollLeft += delta
  209. }
  210. /**
  211. * 鼠标左键拖动横向滑动
  212. * - 只在内容溢出(出现左右箭头)时启用;触摸屏保持原生惯性滚动,不接管
  213. * - 位移超过阈值才算拖动,否则仍按普通点击处理(避免手抖点不中标签)
  214. * - 用 scrollLeft 增量补偿而非 transform:不脱离文档流、不产生额外合成层,
  215. * 且浏览器会把 scrollLeft 夹在 [0, max] 之间,拖到边界后反向移动不会出现死区
  216. */
  217. const DRAG_THRESHOLD = 5
  218. let drag = null
  219. // 拖动结束时浏览器还会补发一次 click,落点在标签上会误切换,需要吞掉那一次
  220. let suppressClick = false
  221. function handDragStart(e) {
  222. suppressClick = false
  223. const box = scrollRef.value
  224. if (!box || !hasOverflow.value) return
  225. if (e.pointerType === 'touch') return
  226. if (e.button !== 0) return
  227. drag = { id: e.pointerId, startX: e.clientX, lastX: e.clientX, moved: false }
  228. // 按下即切抓手光标(dragging 只管光标与文字选择,是否真的滚动看 drag.moved)
  229. dragging.value = true
  230. // move/up 一律挂到 window:按下后手指/鼠标跑出标签栏(含不足阈值就移出)时依然能收事件,
  231. // 否则「按下 → 快速划出去」会丢掉整个拖动
  232. window.addEventListener('pointermove', handDragMove, true)
  233. window.addEventListener('pointerup', handDragEnd, true)
  234. window.addEventListener('pointercancel', handDragEnd, true)
  235. }
  236. function handDragMove(e) {
  237. if (!drag || e.pointerId !== drag.id) return
  238. const box = scrollRef.value
  239. if (!box) return
  240. if (!drag.moved) {
  241. if (Math.abs(e.clientX - drag.startX) < DRAG_THRESHOLD) return
  242. drag.moved = true
  243. // 捕获指针:拖出标签栏范围后仍持续收到 move/up,不会「拖丢」
  244. box.setPointerCapture?.(e.pointerId)
  245. }
  246. box.scrollLeft -= e.clientX - drag.lastX
  247. drag.lastX = e.clientX
  248. }
  249. function handDragEnd() {
  250. unbindWindowEnd()
  251. if (!drag) return
  252. const box = scrollRef.value
  253. const { moved, id } = drag
  254. drag = null
  255. dragging.value = false
  256. if (box?.hasPointerCapture?.(id)) box.releasePointerCapture(id)
  257. if (moved) suppressClick = true
  258. }
  259. function unbindWindowEnd() {
  260. window.removeEventListener('pointermove', handDragMove, true)
  261. window.removeEventListener('pointerup', handDragEnd, true)
  262. window.removeEventListener('pointercancel', handDragEnd, true)
  263. }
  264. function swallowClick(e) {
  265. if (!suppressClick) return
  266. suppressClick = false
  267. e.preventDefault()
  268. e.stopPropagation()
  269. }
  270. // 箭头是否可点:既有上一个/下一个标签可切,或者还能往回/往前滚(两者取或)
  271. const canPrevTab = computed(() => {
  272. const i = indexOfActive()
  273. return i > 0 || canPrev.value
  274. })
  275. const canNextTab = computed(() => {
  276. const i = indexOfActive()
  277. return (i >= 0 && i < itemEls().length - 1) || canNext.value
  278. })
  279. // 供 s-tab-item 注入:读 activeValue、点击调 select、方向键调 prev/next
  280. provide('sTabContext', {
  281. activeValue: innerActive,
  282. select: handSelect,
  283. prev: handPrev,
  284. next: handNext
  285. })
  286. watch(
  287. () => props.activeKey,
  288. (v) => {
  289. if (v === innerActive.value) return
  290. // 外部清空选中值(没传 / 重置)→ 回落到 defaultActiveKey,再回落到第一项
  291. if (isEmptyKey(v)) {
  292. if (ensureActive()) emit('update:activeKey', innerActive.value)
  293. nextTick(scrollToActive)
  294. return
  295. }
  296. innerActive.value = v
  297. nextTick(scrollToActive)
  298. }
  299. )
  300. // 数组变化 / 插槽内容变化的兜底重算
  301. watch(
  302. () => list.value,
  303. () => {
  304. nextTick(() => {
  305. syncArrow()
  306. if (ensureActive()) emit('update:activeKey', innerActive.value)
  307. scrollToActive()
  308. })
  309. },
  310. { deep: true }
  311. )
  312. let ro = null
  313. onMounted(() => {
  314. nextTick(() => {
  315. syncArrow()
  316. // 首帧才拿得到 DOM(插槽模式尤其如此),默认值在这里补
  317. if (ensureActive()) emit('update:activeKey', innerActive.value)
  318. scrollToActive()
  319. })
  320. if (window.ResizeObserver && scrollRef.value) {
  321. ro = new ResizeObserver(() => syncArrow())
  322. ro.observe(scrollRef.value)
  323. if (scrollRef.value.firstElementChild) ro.observe(scrollRef.value.firstElementChild)
  324. }
  325. })
  326. onBeforeUnmount(() => {
  327. unbindWindowEnd()
  328. if (ro) {
  329. ro.disconnect()
  330. ro = null
  331. }
  332. })
  333. defineExpose({ syncArrow, scrollToActive, scrollRef })
  334. <\/script>
  335. <style lang="less" scoped>
  336. .s-tab {
  337. // 配色不写死,全部从主题变量推导(packages/index.js 按 VITE_APP_THEME 写入 :root 的 --s-*):
  338. // 未选中 = 主题主色 30% 混入中性灰 → 带主题倾向的灰,对比度仍 ≥ 4.5:1
  339. // 悬停/选中 = 主题主色 --s-color
  340. // 箭头到头 = 主题描边色 --s-border-color
  341. // 业务要微调可直接在外层覆盖这几个 --s-tab-* 变量,不用改组件
  342. --s-tab-color: var(--s-color, #1677ff);
  343. --s-tab-active-color: var(--s-color, #1677ff);
  344. --s-tab-disabled-color: var(--s-text-color-disabled);
  345. width: 100%;
  346. min-width: 0;
  347. display: flex;
  348. align-items: center;
  349. gap: 8px;
  350. box-sizing: border-box;
  351. }
  352. // 可横向滚动区:原生滚动条藏起来,靠左右箭头驱动
  353. .s-tab-scroll {
  354. flex: 1 1 auto;
  355. min-width: 0;
  356. overflow-x: auto;
  357. overflow-y: hidden;
  358. scrollbar-width: none;
  359. -ms-overflow-style: none;
  360. &::-webkit-scrollbar {
  361. display: none;
  362. }
  363. }
  364. .s-tab-track {
  365. display: inline-flex;
  366. align-items: center;
  367. gap: 40px;
  368. padding: 0 4px;
  369. white-space: nowrap;
  370. // 用 :deep 是因为两种用法的标签来源不同:
  371. // 数组模式由本组件渲染(带 scopeId),<s-tab-item> 渲染在子组件里(不带本组件的 scopeId)
  372. :deep(.s-tab-item) {
  373. flex: 0 0 auto;
  374. font-size: 14px;
  375. line-height: 40px;
  376. // 老浏览器不认识 color-mix,先给中性灰兜底;支持的浏览器用「主题色调和的灰」
  377. color: var(--s-text-color-regular);
  378. color: ~'color-mix(in srgb, var(--s-tab-color) 30%, var(--s-text-color-regular))';
  379. cursor: pointer;
  380. user-select: none;
  381. transition: color 0.2s;
  382. &:hover {
  383. color: var(--s-tab-active-color);
  384. }
  385. &.active {
  386. color: var(--s-tab-active-color);
  387. font-weight: 500;
  388. }
  389. }
  390. }
  391. .s-tab-arrow {
  392. flex: 0 0 32px;
  393. width: 32px;
  394. height: 32px;
  395. padding: 0;
  396. display: flex;
  397. align-items: center;
  398. justify-content: center;
  399. // 与标签同一套推导:主题色调和出的灰
  400. color: var(--s-text-color-regular);
  401. color: ~'color-mix(in srgb, var(--s-tab-color) 30%, var(--s-text-color-regular))';
  402. font-size: 12px;
  403. cursor: pointer;
  404. transition: all 0.2s;
  405. &:not(:disabled):hover {
  406. color: var(--s-tab-active-color);
  407. }
  408. &:disabled {
  409. color: var(--s-tab-disabled-color);
  410. cursor: not-allowed;
  411. }
  412. }
  413. // 光标:悬停不做任何提示(标签保持 pointer,空白保持默认箭头),**按下**才切抓手
  414. // 放在 .s-tab-track 之后:两者特异性相同,靠顺序覆盖标签的 pointer
  415. .s-tab.dragging {
  416. .s-tab-scroll,
  417. .s-tab-scroll .s-tab-track :deep(.s-tab-item) {
  418. cursor: grabbing;
  419. }
  420. .s-tab-track {
  421. user-select: none;
  422. }
  423. }
  424. </style>
  425. `;
  426. export {
  427. n as default
  428. };