dsh-knit 0.24.0 → 0.25.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -784,7 +784,7 @@ test('媒体:媒体视图渲染方形网格,图片出 img、视频出首帧
784
784
  'v0.21.x:媒体档也只剩阿拉伯数字(不再「个媒体」)')
785
785
  })
786
786
 
787
- test('媒体:点图片卡片就地预览大图,且不请求 /api/doc', async () => {
787
+ test('媒体:**单击图片只移光标**(就地预览 2026-10-22 已撤掉),双击才进全屏查看器', async () => {
788
788
  const { calls } = installFetch(kindResponder({ media: mediaPayload() }))
789
789
  const { KnitBody } = loadClientModule().exports.__test
790
790
  harness.reset()
@@ -798,14 +798,20 @@ test('媒体:点图片卡片就地预览大图,且不请求 /api/doc', async
798
798
  await harness.flush()
799
799
  nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
800
800
 
801
- const pm = byClass(nodes, 'knit-preview-media')
802
- assert.equal(pm.length, 1)
803
- assert.equal(pm[0].type, 'img')
804
- assert.ok(String(pm[0].props.src).includes('/knit/api/raw'))
801
+ // 2026-10-22 用户裁决:媒体档不再有「单击就地预览」—— 下方不许弹面板
802
+ assert.equal(byExactClass(nodes, 'knit-preview').length, 0, '单击图片不该弹就地预览')
803
+ assert.equal(byExactClass(nodes, 'knit-preview-media').length, 0, '更不该出现媒体预览体')
805
804
  assert.ok(!calls.some((u) => u.includes('/api/doc')), '图片不应触发正文请求')
805
+ // 单击只移光标(键盘导航与双击的落点靠它)
806
+ assert.ok(String(byClass(nodes, 'knit-media-card')[0].props.className).includes('cursor'), '单击只移光标')
807
+
808
+ // 双击 = 全屏查看器(这才是现在「看大图」的唯一入口)
809
+ byClass(nodes, 'knit-media-card')[0].props.onDoubleClick()
810
+ const after = harness.render(h(KnitBody, { sessionId: 's1' }))
811
+ assert.equal(byExactClass(after, 'knit-lightbox').length, 1, '双击应进查看器')
806
812
  })
807
813
 
808
- test('媒体:点视频卡片就地预览,播放器 controls 且静音自动播放', async () => {
814
+ test('媒体:**单击视频不弹预览**,双击才就地预览(播放器 controls 且静音自动播放)', async () => {
809
815
  const { calls } = installFetch(kindResponder({ media: mediaPayload() }))
810
816
  const { KnitBody } = loadClientModule().exports.__test
811
817
  harness.reset()
@@ -814,7 +820,12 @@ test('媒体:点视频卡片就地预览,播放器 controls 且静音自动
814
820
  await harness.flush()
815
821
  nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
816
822
 
817
- byClass(nodes, 'knit-media-card')[1].props.onClick() // 第二张是视频
823
+ const videoOf = (n) => byClass(n, 'knit-media-card').find((c) => String(c.props['data-knit-rel']).endsWith('.mp4'))
824
+ videoOf(nodes).props.onClick() // 单击:2026-10-22 起不再弹预览
825
+ assert.equal(byExactClass(harness.render(h(KnitBody, { sessionId: 's1' })), 'knit-preview').length, 0,
826
+ '单击视频不该弹就地预览')
827
+
828
+ videoOf(harness.render(h(KnitBody, { sessionId: 's1' }))).props.onDoubleClick() // 双击才弹
818
829
  nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
819
830
  await harness.flush()
820
831
  nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
@@ -5798,3 +5809,1060 @@ test('v0.25:客户端源码里**不许**再把变更关联挂到列表接口
5798
5809
  assert.ok(!source.includes('&changes=1'), '列表请求上不许再拼这个参数(整体删除,不是注释掉)')
5799
5810
  assert.ok(!source.includes('pack.changes'), '包上不再有这个字段(读它就是读了不存在的形状)')
5800
5811
  })
5812
+
5813
+ /* ── v0.25:预览里的查找(Cmd+F)────────────────────────────────────────
5814
+ 分工与 `docAnchorNeedles`(纯)/ `docAnchorHit`(DOM)那条既有分界线一致:
5815
+ **纯函数那半**(匹配 / 下标映射 / 环形步进)在这里被真断言钉住;
5816
+ **DOM 那半**(画标记、滚动)需要真 document,替身给不了,只在真机验证。
5817
+ ⚠️ 替身没有 document ⇒ 命中数恒 0 ⇒ 界面会显示「无结果」。那不是 bug,是替身的边界,
5818
+ 所以下面凡涉及「命中数」的断言都按 0 命中写 —— 不许拿假 DOM 造一个假绿。 */
5819
+
5820
+ test('查找(纯):匹配是**字面量**、不重叠、大小写不敏感', () => {
5821
+ const { findRanges } = loadClientModule().exports.__test
5822
+ const spans = (text, query) => findRanges(text, query).map((r) => [r.start, r.end])
5823
+
5824
+ assert.deepEqual(spans('Hello hello', 'HELLO'), [[0, 5], [6, 11]], '大小写不敏感')
5825
+ assert.deepEqual(spans('aaaa', 'aa'), [[0, 2], [2, 4]], '不重叠:aa 在 aaaa 里是 2 处不是 3(与 Chrome 同口径)')
5826
+ assert.deepEqual(spans('响应式文档列表', '文档'), [[3, 5]], '中文按 UTF-16 码元下标(与 slice 同一套)')
5827
+
5828
+ // **字面量**:正则元字符必须原样找 —— 用户搜的是关键词,不是模式;也不许抛
5829
+ assert.deepEqual(spans('a(b)c', '('), [[1, 2]], '( 不许当分组符号')
5830
+ assert.deepEqual(spans('axb', '.'), [], '. 不许当「任意字符」')
5831
+ assert.deepEqual(spans('a**b**c', '**'), [[1, 3], [4, 6]], '* 不许当量词(字面量:找的是两个星号本身)')
5832
+ assert.deepEqual(spans('价格 [必读]', '['), [[3, 4]], '[ 不许当字符类')
5833
+ assert.deepEqual(spans('a?b', '?'), [[1, 2]], '? 不许当可选标记')
5834
+
5835
+ assert.equal(findRanges('abc', '').length, 0, '空关键词 = 不找(不是「全部命中」)')
5836
+ assert.equal(findRanges('', 'a').length, 0)
5837
+ assert.equal(findRanges(null, 'a').length, 0, '畸形输入不许抛')
5838
+ assert.equal(findRanges('abc', null).length, 0)
5839
+
5840
+ // 性质:每一段切出来就是关键词本身 —— 把「下标错位」这一类 bug 一次盖住
5841
+ for (const [text, query] of [['abcABC', 'abc'], ['文档里找文档', '文档'], ['x(1) x(1)', 'x(1)'], ['🔥🔥', '🔥']]) {
5842
+ const ranges = findRanges(text, query)
5843
+ assert.ok(ranges.length > 0, `${text} / ${query} 应该有命中`)
5844
+ for (const r of ranges) {
5845
+ assert.equal(text.slice(r.start, r.end).toLowerCase(), query.toLowerCase(), `${text} / ${query} 切出来的必须是关键词`)
5846
+ }
5847
+ }
5848
+ })
5849
+
5850
+ test('查找(纯):折叠后**变长**的字符退回大小写敏感 —— 宁可少匹配,也不许标错位置', () => {
5851
+ const { findRanges } = loadClientModule().exports.__test
5852
+ assert.equal('İ'.toLowerCase().length, 2, '前提:这个字符折叠后确实变长(否则这条守的是空气)')
5853
+ // 折叠串比原文长 ⇒ 用它算出来的下标会整体错位、画出来的命中就偏了。
5854
+ assert.deepEqual(findRanges('İstanbul', 'istanbul'), [], '退回大小写敏感:找不到就是找不到')
5855
+ assert.deepEqual(findRanges('İstanbul', 'İstanbul').map((r) => [r.start, r.end]), [[0, 8]], '大小写一致时仍然精确')
5856
+ assert.deepEqual(findRanges('aaİbb', 'aa').map((r) => r.start), [0], '同一串里其他命中不受影响')
5857
+ })
5858
+
5859
+ test('查找(纯):归一化下标 → 原文下标这座桥是准的(渲染会把换行折成空格)', () => {
5860
+ const { normalizedIndexMap } = loadClientModule().exports.__test
5861
+ assert.deepEqual(normalizedIndexMap('abc'), [0, 1, 2], '没有空白时是恒等映射')
5862
+ assert.deepEqual(normalizedIndexMap('a\n\nb'), [0, 1, 3], '一串空白折成一个空格,映射取那串的第一个字符')
5863
+ // 前导空白折成一个空格 ⇒ 映射到那串的第一个字符(下标 0);'a' 在原文下标 2;尾随空格在 3
5864
+ assert.deepEqual(normalizedIndexMap(' a '), [0, 2, 3])
5865
+
5866
+ // 性质:第 i 项指向的字符,就是归一化后第 i 个位置上的字符
5867
+ const normalize = (text) => text.replace(/\s+/g, ' ')
5868
+ for (const text of ['a b', 'a\n\nb', ' 前后 ', '行1\n\n行2\n 行3', '一\n二', 'no-space']) {
5869
+ const flat = normalize(text)
5870
+ const map = normalizedIndexMap(text)
5871
+ assert.equal(map.length, flat.length, `${JSON.stringify(text)} 的映射长度应等于归一化长度`)
5872
+ for (let i = 0; i < flat.length; i += 1) {
5873
+ // 映射指向的是「这一位来自原文哪里」。空白位来自**那串空白的第一个字符**
5874
+ // (原文里是 \n,归一化后是空格)—— 所以空白位只要求「原文那里也是空白」;
5875
+ // 非空白位必须逐字相同。切片正是靠这条才切得准。
5876
+ if (/\s/.test(flat[i])) assert.ok(/\s/.test(text[map[i]]), `${JSON.stringify(text)} 第 ${i} 位应是空白`)
5877
+ else assert.equal(text[map[i]], flat[i], `${JSON.stringify(text)} 第 ${i} 位对不上`)
5878
+ if (i > 0) assert.ok(map[i] > map[i - 1], `${JSON.stringify(text)} 的映射必须严格递增(切片的前提)`)
5879
+ }
5880
+ }
5881
+ })
5882
+
5883
+ test('查找(纯):上一个 / 下一个**环绕**,越界先夹紧,总数 0 时恒 0', () => {
5884
+ const { stepFindIndex } = loadClientModule().exports.__test
5885
+ assert.equal(stepFindIndex(0, 3, 1), 1)
5886
+ assert.equal(stepFindIndex(2, 3, 1), 0, '最后一个再按「下一个」回到第一个(与 Chrome 一致)')
5887
+ assert.equal(stepFindIndex(0, 3, -1), 2, '第一个再按「上一个」回到最后一个')
5888
+ assert.equal(stepFindIndex(0, 1, 1), 0, '只有一个时原地不动')
5889
+ assert.equal(stepFindIndex(0, 0, 1), 0, '没有命中时恒 0(不许出 NaN / -0)')
5890
+ assert.equal(stepFindIndex(9, 3, 1), 0, '下标越界(命中数变少时真会发生)先夹到末条,再环绕回 0')
5891
+ })
5892
+
5893
+ /** 造一个键盘事件替身,同时记下 preventDefault / stopPropagation 被调了几次。 */
5894
+ function keyEvent(props) {
5895
+ const calls = { prevented: 0, stopped: 0 }
5896
+ const event = {
5897
+ key: '', metaKey: false, ctrlKey: false, altKey: false, shiftKey: false,
5898
+ ...props,
5899
+ preventDefault: () => { calls.prevented += 1 },
5900
+ stopPropagation: () => { calls.stopped += 1 },
5901
+ }
5902
+ return { event, calls }
5903
+ }
5904
+
5905
+ /**
5906
+ * 打开第一行的预览 —— 查找的宿主必须是「已经打开一篇正文」。
5907
+ * @returns {Promise<{nodes: object[], render: Function}>} 节点与重渲染函数
5908
+ */
5909
+ async function openPreviewForFind(seed = ['', 'time']) {
5910
+ const { KnitBody } = loadClientModule().exports.__test
5911
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
5912
+ harness.reset()
5913
+ harness.seed(seed)
5914
+ let nodes = render()
5915
+ await harness.flush()
5916
+ nodes = render()
5917
+ byClass(nodes, 'knit-doc')[0].props.onClick()
5918
+ return { nodes: render(), render }
5919
+ }
5920
+
5921
+ test('查找:Cmd+F 在**面板根**的捕获阶段打开查找条,且必须 preventDefault', async () => {
5922
+ installFetch(kindResponder({ doc: listPayload() }))
5923
+ const { nodes, render } = await openPreviewForFind()
5924
+ assert.equal(byExactClass(nodes, 'knit-findbar').length, 0, '默认不出现(不许白占一行)')
5925
+
5926
+ const root = byClass(nodes, 'knit-root')[0]
5927
+ assert.equal(typeof root.props.onKeyDownCapture, 'function',
5928
+ '快捷键必须挂**捕获阶段**:焦点通常在左边列表上(↑↓ 开着预览,挂 .knit-preview 收不到事件),'
5929
+ + '而且查找开着时 Esc 要抢在列表那个「关预览」之前')
5930
+ assert.equal(root.props.onKeyDown, undefined, '不许同时挂冒泡 —— 那会让 Esc 的优先级反过来')
5931
+
5932
+ const { event, calls } = keyEvent({ key: 'f', metaKey: true })
5933
+ root.props.onKeyDownCapture(event)
5934
+ const after = render()
5935
+ assert.equal(byExactClass(after, 'knit-findbar').length, 1, 'Cmd+F 应打开查找条')
5936
+ assert.equal(calls.prevented, 1, '必须 preventDefault —— 否则宿主 / 浏览器的原生查找也会一起打开')
5937
+ assert.equal(calls.stopped, 1, '必须 stopPropagation')
5938
+
5939
+ const input = byClass(after, 'knit-findinput')[0]
5940
+ assert.ok(input, '应有查找输入框')
5941
+ assert.equal(input.props.value, '', '打开时是空的(不许带上一次的关键词)')
5942
+
5943
+ // 替身没有 document ⇒ 画不出命中 ⇒ 命中数如实为 0,界面要说「无结果」而不是假装 0/0
5944
+ input.props.onChange({ target: { value: '文档' } })
5945
+ const typed = render()
5946
+ assert.equal(byClass(typed, 'knit-findinput')[0].props.value, '文档', '输入受控')
5947
+ assert.deepEqual(byExactClass(typed, 'knit-findcount').map(textOf), ['无结果'],
5948
+ '命中数为 0 时必须说「无结果」;这里恒 0 是替身没有 DOM 所致,不是被测行为')
5949
+ })
5950
+
5951
+ test('查找:Esc 先关查找条,**不许**把预览一起关掉(列表那个 Esc 要让位)', async () => {
5952
+ installFetch(kindResponder({ doc: listPayload() }))
5953
+ const { nodes, render } = await openPreviewForFind()
5954
+ byClass(nodes, 'knit-root')[0].props.onKeyDownCapture(keyEvent({ key: 'f', metaKey: true }).event)
5955
+ const opened = render()
5956
+ assert.equal(byExactClass(opened, 'knit-findbar').length, 1, '前提:查找开着')
5957
+ assert.equal(byExactClass(opened, 'knit-preview').length, 1, '前提:预览开着')
5958
+
5959
+ const { event, calls } = keyEvent({ key: 'Escape' })
5960
+ byClass(opened, 'knit-root')[0].props.onKeyDownCapture(event)
5961
+ const closed = render()
5962
+ assert.equal(byExactClass(closed, 'knit-findbar').length, 0, 'Esc 应关掉查找条')
5963
+ assert.equal(byExactClass(closed, 'knit-preview').length, 1, '预览必须还在 —— Esc 一次只吃一层')
5964
+ assert.equal(calls.stopped, 1, '必须 stopPropagation,否则列表自己的 Esc 会把预览也关掉')
5965
+ })
5966
+
5967
+ test('查找:媒体档不打开查找条(没有可搜的正文),也不拦快捷键', async () => {
5968
+ installFetch(kindResponder({ media: mediaPayload() }))
5969
+ const { KnitBody } = loadClientModule().exports.__test
5970
+ harness.reset()
5971
+ harness.seed(['', 'time', 'media'])
5972
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
5973
+ await harness.flush()
5974
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
5975
+ // 前提:媒体预览**开着** —— 图片档现在单击不弹预览了,所以用视频双击把它打开
5976
+ byClass(nodes, 'knit-media-card')
5977
+ .find((c) => String(c.props['data-knit-rel']).endsWith('.mp4')).props.onDoubleClick()
5978
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
5979
+ assert.equal(byExactClass(nodes, 'knit-preview').length, 1, '前提:媒体预览开着')
5980
+
5981
+ const { event, calls } = keyEvent({ key: 'f', metaKey: true })
5982
+ byClass(nodes, 'knit-root')[0].props.onKeyDownCapture(event)
5983
+ const after = harness.render(h(KnitBody, { sessionId: 's1' }))
5984
+ assert.equal(byExactClass(after, 'knit-findbar').length, 0, '媒体档不该出现查找条')
5985
+ assert.equal(calls.prevented, 0, '不拦 —— 媒体没有可搜的正文,快捷键交回宿主 / 浏览器')
5986
+ const labels = byClass(after, 'knit-btn').map(textOf)
5987
+ assert.ok(!labels.includes('查找'), `媒体档预览头不该出现「查找」按钮(不留死按钮):${labels.join(' / ')}`)
5988
+ })
5989
+
5990
+ test('查找:预览头有「查找」按钮 —— 外层应用抢走 Cmd+F 时的兜底入口', async () => {
5991
+ // 为什么必须有这个按钮(2026-10-15 用户实测):在飞书客户端的内置浏览器里按 Cmd+F,
5992
+ // 出来的是**飞书自己的**查找框 —— 原生快捷键在按键进入网页之前就被处理了,网页侧抢不回来。
5993
+ // 所以能力必须有一个不依赖快捷键的入口。
5994
+ installFetch(kindResponder({ doc: listPayload() }))
5995
+ const { nodes, render } = await openPreviewForFind()
5996
+ const btn = byClass(nodes, 'knit-btn').find((n) => textOf(n) === '查找')
5997
+ assert.ok(btn, `预览头应有「查找」按钮,实际按钮:${byClass(nodes, 'knit-btn').map(textOf).join(' / ')}`)
5998
+ assert.equal(byExactClass(nodes, 'knit-findbar').length, 0, '前提:查找条还没开')
5999
+
6000
+ btn.props.onClick()
6001
+ const after = render()
6002
+ assert.equal(byExactClass(after, 'knit-findbar').length, 1, '点按钮应打开查找条')
6003
+ assert.ok(byClass(after, 'knit-findinput')[0], '并且输入框要在(按钮是给鼠标用户用的)')
6004
+ })
6005
+
6006
+ test('查找:滚动**只**由显式导航触发 —— 5 秒轮询重画命中时不许把用户的视图拽回去', async () => {
6007
+ const { readFileSync } = await import('node:fs')
6008
+ const { fileURLToPath } = await import('node:url')
6009
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6010
+
6011
+ // 命中数组**走 ref 读**、不进依赖:进了依赖就会把「重画」当成「用户动了光标」,
6012
+ // 每 5 秒把读到一半的位置拽回第一条(AGENTS.md §6.13 ② 那条坑,同一个道理)。
6013
+ const at = source.indexOf('const marks = findMarksRef.current')
6014
+ assert.ok(at > 0, '应能找到「滚动到当前命中」那条 effect')
6015
+ const tail = source.slice(at, at + 700)
6016
+ const deps = tail.match(/\}, \[([^\]]*)\]\)/)
6017
+ assert.ok(deps, '那条 effect 应当有依赖数组')
6018
+ assert.equal(deps[1], 'findSeq',
6019
+ '依赖只许是 findSeq(显式导航才 +1);加进 findCount / state.docs 之类的轮询值,'
6020
+ + '就会每 5 秒把视图拽回去一次')
6021
+ })
6022
+
6023
+ test('查找:命中只上底色 —— 不许有 padding / border(会改行高与折行,代码预览的横带就错位了)', async () => {
6024
+ const { readFileSync } = await import('node:fs')
6025
+ const { fileURLToPath } = await import('node:url')
6026
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6027
+ const start = source.indexOf('const CSS = `') + 'const CSS = `'.length
6028
+ const css = source.slice(start, source.indexOf('`', start)).replace(/\/\*[\s\S]*?\*\//g, '')
6029
+
6030
+ const base = css.match(/mark\.knit-find\{([^}]*)\}/)
6031
+ assert.ok(base, '应有 mark.knit-find 的样式')
6032
+ // `padding:0` 是显式清零,允许;不许的是给它一个非零内边距(会改行高与折行)
6033
+ for (const decl of (base[1].match(/\bpadding\s*:[^;}]*/g) || [])) {
6034
+ assert.equal(decl, 'padding:0', `命中只许把 padding 显式写成 0,不许给内边距:${decl}`)
6035
+ }
6036
+ // `border:0` 是**显式关掉**浏览器给 mark 的默认边框,允许;不许的是给它一个可见宽度
6037
+ for (const decl of (base[1].match(/\bborder\s*:[^;}]*/g) || [])) {
6038
+ assert.equal(decl, 'border:0', `命中只许把 border 显式写成 0,不许给宽度:${decl}`)
6039
+ }
6040
+ assert.match(base[1], /color:inherit/, '必须继承字色 —— 否则浏览器默认的 mark(黄底黑字)会漏出来')
6041
+ assert.match(base[1], /background:var\(--knit-/, '底色只吃已定义的灰阶变量,不许自造颜色')
6042
+
6043
+ const current = css.match(/mark\.knit-find-current\{([^}]*)\}/)
6044
+ assert.ok(current, '应有「当前命中」的样式')
6045
+ assert.match(current[1], /background:var\(--knit-chip-bg\)/,
6046
+ '当前命中用命中段那一档灰(比普通命中深)—— 用灰阶而不是第二种颜色建立层级')
6047
+ })
6048
+
6049
+ /* ── v0.25:媒体收藏 ────────────────────────────────────────────────────
6050
+ 顺序规则只有一条:**稳定分区**(收藏的按原有顺序前移,其余按原有顺序跟在后面)。
6051
+ 不做第二套排序 —— 所以这里钉的是「分区」,不是「新排序」。 */
6052
+
6053
+ test('收藏(纯):落盘的畸形值一律回空表,不许抛', () => {
6054
+ const { parseFavorites } = loadClientModule().exports.__test
6055
+ assert.deepEqual(parseFavorites(null), {})
6056
+ assert.deepEqual(parseFavorites(''), {})
6057
+ assert.deepEqual(parseFavorites('not json'), {}, '手改坏的 / 上个版本留下的:回空,不抛')
6058
+ assert.deepEqual(parseFavorites('[1,2]'), {}, '数组不是表')
6059
+ assert.deepEqual(parseFavorites('"x"'), {}, '字符串不是表')
6060
+ // 正常表:非字符串 / 空串 / 重复项都要被摘掉
6061
+ assert.deepEqual(parseFavorites('{"/p":["a.png","a.png","",3,"b.mp4"]}'), { '/p': ['a.png', 'b.mp4'] })
6062
+ assert.deepEqual(parseFavorites('{"/p":[]}'), {}, '空数组不占一个键')
6063
+ assert.deepEqual(parseFavorites('{"/p":"a.png"}'), {}, '值不是数组 ⇒ 丢掉整个键')
6064
+ })
6065
+
6066
+ test('收藏(纯):加 / 取消返回新数组,不改入参;新加的在最前', () => {
6067
+ const { toggleFavoriteList } = loadClientModule().exports.__test
6068
+ const before = ['a.png']
6069
+ const added = toggleFavoriteList(before, 'b.mp4')
6070
+ assert.deepEqual(added, ['b.mp4', 'a.png'], '新加的排最前(同一次会话里立刻可见)')
6071
+ assert.deepEqual(before, ['a.png'], '不许改入参(React 状态要新引用才会重渲染)')
6072
+ assert.deepEqual(toggleFavoriteList(added, 'a.png'), ['b.mp4'], '再点一次=取消')
6073
+ assert.deepEqual(toggleFavoriteList(['a.png'], 'a.png'), [])
6074
+ assert.deepEqual(toggleFavoriteList(undefined, 'a.png'), ['a.png'], '没有历史时也能加')
6075
+ assert.deepEqual(toggleFavoriteList(['a.png'], ''), ['a.png'], '空 rel 不动(不许写进一个空条目)')
6076
+ })
6077
+
6078
+ test('收藏(纯):收藏的排最前,且两组内部**都保持原有顺序**(不是重新排序)', () => {
6079
+ const { orderFavorites } = loadClientModule().exports.__test
6080
+ const docs = [
6081
+ { rel: 'a.png' }, { rel: 'b.png' }, { rel: 'c.png' }, { rel: 'd.mp4' }, { rel: 'e.png' },
6082
+ ]
6083
+ const ordered = orderFavorites(docs, ['d.mp4', 'b.png'])
6084
+ assert.deepEqual(ordered.map((d) => d.rel), ['b.png', 'd.mp4', 'a.png', 'c.png', 'e.png'],
6085
+ '收藏的两个前移(按**原顺序** b 在 d 前,而不是按收藏顺序),其余原样跟随')
6086
+ assert.equal(orderFavorites(docs, ['b.png'])[0].rel, 'b.png')
6087
+ assert.equal(orderFavorites(docs, []), docs, '没有收藏时**原样返回同一个数组**(省一次重渲染)')
6088
+ assert.deepEqual(orderFavorites([], ['a']), [], '空列表不炸')
6089
+ assert.deepEqual(orderFavorites(null, ['a']), [], '畸形输入不炸')
6090
+ // 新引用的 Set 与数组两种入参都要认
6091
+ assert.equal(orderFavorites(docs, new Set(['e.png']))[0].rel, 'e.png')
6092
+ })
6093
+
6094
+ /** 打开媒体档并把预览打开到第一张(收藏按钮的宿主)。 */
6095
+
6096
+ test('收藏:媒体网格里收藏的排最前,并在名字前带 ★', async () => {
6097
+ installFetch(kindResponder({ media: mediaPayload() }))
6098
+ const { KnitBody, FAV_KEY } = loadClientModule().exports.__test
6099
+ // 载荷里 a.png 在前、demo.mp4 在后 ⇒ 把**后面那个**收藏,它就该跑到第一格
6100
+ globalThis.window.localStorage.setItem(FAV_KEY, JSON.stringify({ '/p': ['demo.mp4'] }))
6101
+ harness.reset()
6102
+ harness.seed(['', 'time', 'media'])
6103
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6104
+ await harness.flush()
6105
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6106
+ // ⚠️ 再 flush 一次:收藏那条 effect 依赖 `state.root`,而根是**异步**到手的 ——
6107
+ // 第一次 render 时它还是空串。替身只在 flush 里跑 effect,少这一下就等于没加载。
6108
+ await harness.flush()
6109
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6110
+
6111
+ const order = byClass(nodes, 'knit-media-card').map((n) => n.props['data-knit-rel'])
6112
+ assert.deepEqual(order, ['demo.mp4', 'a.png'], '收藏的排最前;没有收藏的按原顺序跟在后面')
6113
+ const stars = byExactClass(nodes, 'knit-fav')
6114
+ assert.equal(stars.length, 1, '只有收藏的那一张带 ★')
6115
+ assert.equal(textOf(stars[0]), '★')
6116
+ })
6117
+
6118
+ test('收藏:**全屏查看器**里有「收藏」按钮(预览头那条路已随单击预览一起撤掉),点一下就变成「已收藏」并落盘', async () => {
6119
+ const { FAV_KEY } = loadClientModule().exports.__test
6120
+ // 用查看器自己的挂载助手:双击第 1 张图 ⇒ 查看器里必须能找到「收藏」
6121
+ const { nodes, render } = await mountLightbox(manyMediaPayload(), 0)
6122
+ const labels = byClass(nodes, 'knit-btn').map(textOf)
6123
+ assert.ok(labels.includes('收藏'), `查看器工具条应有「收藏」:${labels.join(' / ')}`)
6124
+
6125
+ const btn = byClass(nodes, 'knit-btn').find((n) => textOf(n) === '收藏')
6126
+ btn.props.onClick()
6127
+ const after = render()
6128
+ const nowLabels = byClass(after, 'knit-btn').map(textOf)
6129
+ assert.ok(nowLabels.includes('已收藏'), `点过之后应显示「已收藏」:${nowLabels.join(' / ')}`)
6130
+ assert.ok(!nowLabels.includes('收藏'), '两个状态不许同时出现')
6131
+ // 落盘:同一个工作区下记了这张
6132
+ const saved = JSON.parse(globalThis.window.localStorage.getItem(FAV_KEY) || '{}')
6133
+ assert.deepEqual(saved['/p'], ['m0.png'], '按工作区根存,记的就是查看器里这张')
6134
+
6135
+ // 再点一次=取消(收藏能撤回,不是单向操作)
6136
+ byClass(after, 'knit-btn').find((n) => textOf(n) === '已收藏').props.onClick()
6137
+ const third = render()
6138
+ assert.ok(byClass(third, 'knit-btn').map(textOf).includes('收藏'), '取消后回到「收藏」')
6139
+ assert.deepEqual(JSON.parse(globalThis.window.localStorage.getItem(FAV_KEY) || '{}'), {}, '取消后不留下空数组')
6140
+ })
6141
+
6142
+ test('收藏:**文档档**没有这个按钮(「收藏」是媒体专属,别和 Context Pack 的「固定」混)', async () => {
6143
+ installFetch(kindResponder({ doc: listPayload() }))
6144
+ const { nodes } = await openPreviewForFind()
6145
+ const labels = byClass(nodes, 'knit-btn').map(textOf)
6146
+ assert.ok(!labels.includes('收藏') && !labels.includes('已收藏'),
6147
+ `文档预览头不该有收藏:${labels.join(' / ')}`)
6148
+ })
6149
+
6150
+ /* ── v0.25:对话里「工具产出」的图(媒体档)────────────────────────────────
6151
+ 数据来自独立接口 `/api/attachments`;字节按 **sha256** 取。去重在工作区那一侧做
6152
+ (宿主按内容哈希判断「已经在本地了」),所以这里只钉 UI 与接线。 */
6153
+
6154
+ /** 一条附件载荷(宿主 `/api/attachments` 的 `items[]` 形状)。 */
6155
+ function attachmentFixture(overrides = {}) {
6156
+ return {
6157
+ id: 'sha256:' + 'a'.repeat(64),
6158
+ name: 'D1_测试生成.png',
6159
+ mediaType: 'image/png',
6160
+ kind: 'image',
6161
+ width: 64,
6162
+ height: 64,
6163
+ bytes: 1024,
6164
+ at: Date.now() - 60000,
6165
+ ...overrides,
6166
+ }
6167
+ }
6168
+
6169
+ test('对话图:媒体档把它和文件混排,带「对话」标记,src 指向附件路由(不是 raw)', async () => {
6170
+ const items = [attachmentFixture()]
6171
+ const { calls } = installFetch((url) => (url.includes('/api/attachments')
6172
+ ? { ok: true, items }
6173
+ : url.includes('/api/doc')
6174
+ ? { ok: true, rel: 'a.png', title: 'a', text: '', truncated: false }
6175
+ : mediaPayload()))
6176
+ const { KnitBody } = loadClientModule().exports.__test
6177
+ harness.reset()
6178
+ harness.seed(['', 'time', 'media'])
6179
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6180
+ await harness.flush()
6181
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6182
+ await harness.flush()
6183
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6184
+
6185
+ assert.ok(calls.some((u) => u.includes('/api/attachments')), '媒体档要取一次附件列表')
6186
+ const rels = byClass(nodes, 'knit-media-card').map((n) => n.props['data-knit-rel'])
6187
+ // v0.25(2026-10-22):媒体档**只按时间倒序**(不再看相关性)。载荷里 a.png 是 60 秒前、
6188
+ // demo.mp4 是 9 亿毫秒前 ⇒ 文件之间就是 [a.png, demo.mp4];对话图的时间由夹具给(更早),
6189
+ // 所以它排在 a.png 后面 —— 这条钉的是「同一条时间轴上合并」,不是「对话图永远第一」。
6190
+ assert.deepEqual(rels, ['a.png', items[0].id, 'demo.mp4'],
6191
+ `顺序:按时间倒序,对话图与文件在同一条时间轴上;实际 ${rels.join(' / ')}`)
6192
+
6193
+ const marks = byExactClass(nodes, 'knit-conv').map(textOf)
6194
+ assert.deepEqual(marks, ['对话'], '对话里生成的图带一个「对话」标记(文字,承担信息)')
6195
+
6196
+ const imgs = byClass(nodes, 'knit-thumb').flatMap((n) => (n.children || []).filter((c) => c && c.type === 'img'))
6197
+ const srcs = imgs.map((n) => String(n.props.src))
6198
+ assert.ok(srcs.some((u) => u.includes('/api/attachment?') && u.includes(encodeURIComponent(items[0].id))),
6199
+ `对话图的 src 必须走附件路由(只带 sha256):${srcs.join(' | ')}`)
6200
+ assert.ok(srcs.some((u) => u.includes('/api/raw?')), '文件图仍然走 /api/raw(没有改动既有路径)')
6201
+ })
6202
+
6203
+ test('对话图:文档档**不取**附件列表,也不出现「对话」标记(这条只在媒体档)', async () => {
6204
+ const { calls } = installFetch((url) => (url.includes('/api/attachments')
6205
+ ? { ok: true, items: [attachmentFixture()] }
6206
+ : url.includes('/api/doc')
6207
+ ? { ok: true, rel: 'x.md', title: 'x', text: '正文', truncated: false }
6208
+ : listPayload()))
6209
+ const { KnitBody } = loadClientModule().exports.__test
6210
+ harness.reset()
6211
+ harness.seed(['', 'relevance'])
6212
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6213
+ await harness.flush()
6214
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6215
+ await harness.flush()
6216
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6217
+
6218
+ assert.ok(!calls.some((u) => u.includes('/api/attachments')), '文档档不该打这个请求')
6219
+ assert.equal(byExactClass(nodes, 'knit-conv').length, 0, '文档档不该有「对话」标记')
6220
+ })
6221
+
6222
+ test('对话图:接口失败/老宿主没有这条路由 ⇒ 静默(文件列表照常,不弹错)', async () => {
6223
+ installFetch((url) => (url.includes('/api/attachments')
6224
+ ? { ok: false, code: 'knit/not-found-route' }
6225
+ : url.includes('/api/doc')
6226
+ ? { ok: true, rel: 'a.png', title: 'a', text: '', truncated: false }
6227
+ : mediaPayload()))
6228
+ const { KnitBody } = loadClientModule().exports.__test
6229
+ harness.reset()
6230
+ harness.seed(['', 'time', 'media'])
6231
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6232
+ await harness.flush()
6233
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6234
+ await harness.flush()
6235
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6236
+
6237
+ const rels = byClass(nodes, 'knit-media-card').map((n) => n.props['data-knit-rel'])
6238
+ assert.deepEqual(rels, ['a.png', 'demo.mp4'], '附件取不到 ⇒ 只显示文件,不空屏、不报错')
6239
+ assert.equal(byExactClass(nodes, 'knit-conv').length, 0)
6240
+ })
6241
+
6242
+ /* ── v0.25:媒体档「悬停看大图」──────────────────────────────────────────
6243
+ 用户要「鼠标停在图片上弹个大图,默认 800×800」。
6244
+ **800 是上限不是尺寸** —— 面板只有几百像素宽,所以盒子按可用空间收缩,
6245
+ 这一段把几何(纯函数)与交互(延迟 / 离开 / 只对图片 / 滚动收起)都钉住。 */
6246
+
6247
+ test('悬停大图(纯):边长按 `HOVER_SHOT_MAX` 封顶,按可用空间收缩,且优先摆在卡片左侧', () => {
6248
+ const { hoverShotBox, HOVER_SHOT_MAX } = loadClientModule().exports.__test
6249
+ const view = { width: 1440, height: 900 }
6250
+ // 卡片在右侧面板里(left=1000),左边有一大片空间 ⇒ 摆在左侧、且不超过 800
6251
+ const box = hoverShotBox({ left: 1000, top: 300, width: 200, height: 140 }, view)
6252
+ assert.equal(box.side, 'left', '面板在右边 ⇒ 浮窗往左让,不压住网格')
6253
+ assert.ok(box.width <= HOVER_SHOT_MAX && box.height <= HOVER_SHOT_MAX, `不许超过上限 ${HOVER_SHOT_MAX}:${box.width}×${box.height}`)
6254
+ assert.ok(box.left + box.width <= 1000, '不许压到卡片')
6255
+ assert.ok(box.left >= 12, '不许出视口左边')
6256
+ // 垂直:**放得下就居中,放不下就夹进视口**(800 高的盒子没法整块塞进一条低卡片的中线里)
6257
+ assert.ok(box.top >= 12 && box.top + box.height <= view.height - 12, '垂直方向必须夹在视口内')
6258
+ const tall = hoverShotBox({ left: 1000, top: 400, width: 200, height: 140 }, view)
6259
+ assert.equal(tall.top + tall.height / 2, 400 + 70, '放得下时中线对齐卡片')
6260
+
6261
+ // 左边没地方 ⇒ 翻到右边
6262
+ const flipped = hoverShotBox({ left: 20, top: 40, width: 200, height: 100 }, view)
6263
+ assert.equal(flipped.side, 'right')
6264
+ assert.ok(flipped.left >= 20 + 200, '翻到右边时不许压住卡片')
6265
+ assert.ok(flipped.left + flipped.width <= view.width - 12, '不许出视口右边')
6266
+
6267
+ // 窄视口 ⇒ 盒子跟着变小(不是硬撑 800)
6268
+ const tiny = hoverShotBox({ left: 300, top: 100, width: 120, height: 90 }, { width: 360, height: 640 })
6269
+ assert.ok(tiny.width <= 360 - 24, `窄视口要收缩:${tiny.width}`)
6270
+ assert.ok(tiny.left >= 12 && tiny.left + tiny.width <= 360 - 12)
6271
+
6272
+ // 拿不到卡片矩形(替身 / 事件不带 currentTarget)⇒ 视口居中,仍然守 800
6273
+ const noRect = hoverShotBox(null, view)
6274
+ assert.ok(noRect.width <= HOVER_SHOT_MAX && noRect.height <= HOVER_SHOT_MAX)
6275
+ assert.ok(Math.abs(noRect.left + noRect.width / 2 - view.width / 2) <= 1, '没有矩形就居中')
6276
+ })
6277
+
6278
+ test('悬停大图:停一下才出现(不许鼠标扫过就闪),离开即收', async () => {
6279
+ installFetch(kindResponder({ media: mediaPayload() }))
6280
+ const { KnitBody } = loadClientModule().exports.__test
6281
+ harness.reset()
6282
+ harness.seed(['', 'time', 'media'])
6283
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6284
+ let nodes = render()
6285
+ await harness.flush()
6286
+ nodes = render()
6287
+
6288
+ const card = byClass(nodes, 'knit-media-card')[0]
6289
+ assert.equal(typeof card.props.onMouseEnter, 'function', '媒体卡片要能感知悬停')
6290
+ card.props.onMouseEnter({ currentTarget: null })
6291
+ nodes = render()
6292
+ assert.equal(byExactClass(nodes, 'knit-shot').length, 0, '刚移上去不该立刻弹(会闪)')
6293
+
6294
+ harness.tick() // 替身没有时间概念:把挂起的定时器跑掉 = 延迟到了
6295
+ nodes = render()
6296
+ const shot = byExactClass(nodes, 'knit-shot')
6297
+ assert.equal(shot.length, 1, '延迟到了才出现')
6298
+ const img = (shot[0].children || []).find((c) => c && c.type === 'img')
6299
+ assert.ok(img, '浮窗里是一张图')
6300
+ assert.match(String(img.props.src), /\/api\/raw\?.*a\.png/, `src 应指向这张图:${img.props.src}`)
6301
+ assert.equal(img.props.alt, '', '纯装饰,alt 留空(文件名在卡片上已经有了)')
6302
+
6303
+ // 移开:立刻收回
6304
+ byClass(nodes, 'knit-media-card')[0].props.onMouseLeave()
6305
+ nodes = render()
6306
+ assert.equal(byExactClass(nodes, 'knit-shot').length, 0, '移开就收')
6307
+ })
6308
+
6309
+ test('悬停大图:没停够就移开 ⇒ 一次都不出现(不许闪一下)', async () => {
6310
+ installFetch(kindResponder({ media: mediaPayload() }))
6311
+ const { KnitBody } = loadClientModule().exports.__test
6312
+ harness.reset()
6313
+ harness.seed(['', 'time', 'media'])
6314
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6315
+ let nodes = render()
6316
+ await harness.flush()
6317
+ nodes = render()
6318
+
6319
+ const card = byClass(nodes, 'knit-media-card')[0]
6320
+ card.props.onMouseEnter({ currentTarget: null })
6321
+ card.props.onMouseLeave() // 还没到点就移开
6322
+ harness.tick() // 就算定时器还在,也不该弹
6323
+ nodes = render()
6324
+ assert.equal(byExactClass(nodes, 'knit-shot').length, 0)
6325
+ })
6326
+
6327
+ test('悬停大图:只对图片 —— 视频卡片不弹(视频交给点击预览)', async () => {
6328
+ installFetch(kindResponder({ media: mediaPayload() }))
6329
+ const { KnitBody } = loadClientModule().exports.__test
6330
+ harness.reset()
6331
+ harness.seed(['', 'time', 'media'])
6332
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6333
+ let nodes = render()
6334
+ await harness.flush()
6335
+ nodes = render()
6336
+
6337
+ const video = byClass(nodes, 'knit-media-card').find((n) => String(n.props['data-knit-rel']).endsWith('.mp4'))
6338
+ assert.ok(video, '载荷里应有视频卡片')
6339
+ video.props.onMouseEnter({ currentTarget: null })
6340
+ harness.tick()
6341
+ nodes = render()
6342
+ assert.equal(byExactClass(nodes, 'knit-shot').length, 0, '视频不弹悬停大图')
6343
+ })
6344
+
6345
+ test('悬停大图:滚动列表就收起(fixed 定位不会跟着卡片走,留着就是错位)', async () => {
6346
+ installFetch(kindResponder({ media: mediaPayload() }))
6347
+ const { KnitBody } = loadClientModule().exports.__test
6348
+ harness.reset()
6349
+ harness.seed(['', 'time', 'media'])
6350
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6351
+ let nodes = render()
6352
+ await harness.flush()
6353
+ nodes = render()
6354
+ byClass(nodes, 'knit-media-card')[0].props.onMouseEnter({ currentTarget: null })
6355
+ harness.tick()
6356
+ nodes = render()
6357
+ assert.equal(byExactClass(nodes, 'knit-shot').length, 1, '前提:它已经弹出来了')
6358
+
6359
+ const list = byExactClass(nodes, 'knit-list')[0]
6360
+ assert.equal(typeof list.props.onScroll, 'function', '列表要能感知滚动')
6361
+ list.props.onScroll()
6362
+ nodes = render()
6363
+ assert.equal(byExactClass(nodes, 'knit-shot').length, 0, '一滚就收')
6364
+ })
6365
+
6366
+ test('悬停大图:对话里生成的图走**附件地址**(不是 /api/raw)', async () => {
6367
+ const items = [attachmentFixture()]
6368
+ installFetch((url) => (url.includes('/api/attachments')
6369
+ ? { ok: true, items }
6370
+ : url.includes('/api/doc')
6371
+ ? { ok: true, rel: 'x', title: 'x', text: '', truncated: false }
6372
+ : mediaPayload()))
6373
+ const { KnitBody } = loadClientModule().exports.__test
6374
+ harness.reset()
6375
+ harness.seed(['', 'time', 'media'])
6376
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6377
+ let nodes = render()
6378
+ await harness.flush()
6379
+ nodes = render()
6380
+ await harness.flush()
6381
+ nodes = render()
6382
+
6383
+ const conv = byClass(nodes, 'knit-media-card').find((n) => n.props['data-knit-rel'] === items[0].id)
6384
+ assert.ok(conv, '前提:对话图在网格里')
6385
+ conv.props.onMouseEnter({ currentTarget: null })
6386
+ harness.tick()
6387
+ nodes = render()
6388
+ const shot = byExactClass(nodes, 'knit-shot')[0]
6389
+ assert.ok(shot, '对话图也要能悬停看大图')
6390
+ const img = (shot.children || []).find((c) => c && c.type === 'img')
6391
+ assert.match(String(img.props.src), /\/api\/attachment\?/, `应走附件路由:${img.props.src}`)
6392
+ assert.ok(String(img.props.src).includes(encodeURIComponent(items[0].id)), '只带 sha256')
6393
+ })
6394
+
6395
+ test('悬停大图:CSS 必须 pointer-events:none(只许看一眼,不许挡点击),且与入口浮窗同一层级', async () => {
6396
+ const { readFileSync } = await import('node:fs')
6397
+ const { fileURLToPath } = await import('node:url')
6398
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6399
+ const start = source.indexOf('const CSS = `') + 'const CSS = `'.length
6400
+ const css = source.slice(start, source.indexOf('`', start)).replace(/\/\*[\s\S]*?\*\//g, '')
6401
+ const box = css.match(/\.knit-shot\{([^}]*)\}/)
6402
+ assert.ok(box, '应有 .knit-shot 的样式')
6403
+ assert.match(box[1], /position:fixed/, 'fixed:不参与面板布局')
6404
+ assert.match(box[1], /pointer-events:none/, '不许挡住卡片的点击与双击')
6405
+ assert.match(box[1], /z-index:60/, '与入口浮窗(.knit-peek)同一层级,别自己拍一个')
6406
+ const img = css.match(/\.knit-shot img\{([^}]*)\}/)
6407
+ assert.ok(img, '应有图的样式')
6408
+ assert.match(img[1], /object-fit:contain/, '等比铺满盒子,不许裁切变形')
6409
+ })
6410
+
6411
+ /* ── v0.25(2026-10-22 用户裁决):媒体档**只看时间**,文档/代码才看相关性 ─────────
6412
+ 原话:「媒体这里不用跟随 Agent 读了它进行排序,目前就是以上传时间排序就可以,
6413
+ 最新的放在前面就够了……文档可以是调用,但是图片不需要有这种逻辑」。 */
6414
+
6415
+ test('媒体档排序:请求**一律 time**(不看「相关」偏好);切回文档档照旧听偏好', async () => {
6416
+ const { calls } = installFetch(kindResponder({ media: mediaPayload(), doc: listPayload() }))
6417
+ const { KnitBody } = loadClientModule().exports.__test
6418
+ const mount = async (seed) => {
6419
+ harness.reset()
6420
+ harness.seed(seed)
6421
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6422
+ await harness.flush()
6423
+ return harness.render(h(KnitBody, { sessionId: 's1' }))
6424
+ }
6425
+ // 偏好 = 相关 + 媒体档
6426
+ await mount(['', 'relevance', 'media'])
6427
+ const mediaUrls = calls.filter((u) => u.includes('kind=media'))
6428
+ assert.ok(mediaUrls.length > 0, '媒体档应该发过列表请求')
6429
+ assert.ok(mediaUrls.every((u) => u.includes('sort=time')),
6430
+ `媒体档必须请求时间序(宿主就不做无用的相关度计算):${mediaUrls.join(' | ')}`)
6431
+
6432
+ // 偏好 = 相关 + 文档档 ⇒ 仍然按相关(这条保证「只改媒体档」)
6433
+ await mount(['', 'relevance', 'doc'])
6434
+ const docUrls = calls.filter((u) => u.includes('kind=doc'))
6435
+ assert.ok(docUrls.some((u) => u.includes('sort=relevance')),
6436
+ `文档档不该被这条改动影响:${docUrls.join(' | ')}`)
6437
+ })
6438
+
6439
+ test('媒体档排序:网格**按时间倒序**,宿主给的顺序乱了也要自己排(对话图在同一条时间轴上)', async () => {
6440
+ // 故意把载荷顺序打乱:老的放前面
6441
+ const payload = mediaPayload()
6442
+ const reversed = mediaPayload({ docs: [payload.docs[1], payload.docs[0]] })
6443
+ installFetch(kindResponder({ media: reversed }))
6444
+ const { KnitBody } = loadClientModule().exports.__test
6445
+ harness.reset()
6446
+ harness.seed(['', 'relevance', 'media']) // 偏好是「相关」,也不许影响媒体档
6447
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6448
+ await harness.flush()
6449
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6450
+
6451
+ const rels = byClass(nodes, 'knit-media-card').map((n) => n.props['data-knit-rel'])
6452
+ assert.deepEqual(rels, ['a.png', 'demo.mp4'],
6453
+ `最新在前(a.png 是 60 秒前、demo.mp4 是 9 亿毫秒前);实际 ${rels.join(' / ')}`)
6454
+ })
6455
+
6456
+ test('媒体档排序:那一组按钮**禁用**并如实显示「最新」在生效(偏好本身不丢)', async () => {
6457
+ installFetch(kindResponder({ media: mediaPayload(), doc: listPayload() }))
6458
+ const { KnitBody } = loadClientModule().exports.__test
6459
+ const mount = async (seed) => {
6460
+ harness.reset()
6461
+ harness.seed(seed)
6462
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6463
+ await harness.flush()
6464
+ return harness.render(h(KnitBody, { sessionId: 's1' }))
6465
+ }
6466
+ // 媒体档:按钮禁用,且「最新」显示为生效(不是存着的「相关」)
6467
+ const media = await mount(['', 'relevance', 'media'])
6468
+ const segs = byClass(media, 'knit-seg-btn')
6469
+ assert.equal(segs.length, 2, '排序组仍是两个按钮(不删控件、布局不跳)')
6470
+ assert.ok(segs.every((b) => b.props.disabled === true), '媒体档里这组必须禁用')
6471
+ const active = segs.filter((b) => String(b.props.className).includes('active')).map(textOf)
6472
+ assert.deepEqual(active, ['最新'], `生效的是「最新」,不该显示「相关」:${active.join(' / ')}`)
6473
+ assert.match(String(segs[0].props.title), /图片一律按时间排序/, '悬停要解释为什么不能点')
6474
+
6475
+ // 文档档:恢复可用,且按偏好显示「相关」
6476
+ const doc = await mount(['', 'relevance', 'doc'])
6477
+ const docSegs = byClass(doc, 'knit-seg-btn')
6478
+ assert.ok(docSegs.every((b) => b.props.disabled !== true), '文档档不禁用')
6479
+ assert.deepEqual(docSegs.filter((b) => String(b.props.className).includes('active')).map(textOf), ['相关'])
6480
+ })
6481
+
6482
+ /* ── v0.25:媒体档「双击全屏」查看器(2026-10-22,参照用户给的 Codex 截图)────
6483
+ 用户要的三件事:双击进全屏 / 点图片以外关闭 / 左侧一列「近 10 张」缩略图;
6484
+ 另加:图片以外是毛玻璃且随主题变、←→ 翻页。 */
6485
+
6486
+ test('全屏查看器(纯):左侧带子取「当前这张附近」的 10 张,两头夹紧', () => {
6487
+ const { lightboxRail, LIGHTBOX_RAIL } = loadClientModule().exports.__test
6488
+ const docs = Array.from({ length: 30 }, (_, i) => ({ rel: `p${i}.png` }))
6489
+ const ids = (r) => r.items.map((d) => d.rel)
6490
+
6491
+ const mid = lightboxRail(docs, 15)
6492
+ assert.equal(mid.items.length, LIGHTBOX_RAIL, `最多 ${LIGHTBOX_RAIL} 张`)
6493
+ assert.ok(ids(mid).includes('p15.png'), '当前这张必须在带子里(不然导航断在画面外)')
6494
+ assert.equal(mid.start, 11, '前面留 4 张(偏「刚看过的」)')
6495
+
6496
+ // 头尾夹紧:第 0 张前面没有 4 张可留;第 29 张后面没有了
6497
+ assert.equal(lightboxRail(docs, 0).start, 0)
6498
+ assert.deepEqual(ids(lightboxRail(docs, 0)).slice(0, 2), ['p0.png', 'p1.png'])
6499
+ const tail = lightboxRail(docs, 29)
6500
+ assert.equal(tail.start, 30 - LIGHTBOX_RAIL, '到尾部时带子往前顶,正好铺满 10 张')
6501
+ assert.ok(ids(tail).includes('p29.png'))
6502
+
6503
+ // 少于 10 张:全给
6504
+ assert.deepEqual(ids(lightboxRail(docs.slice(0, 3), 1)), ['p0.png', 'p1.png', 'p2.png'])
6505
+ // 空 / 畸形
6506
+ assert.deepEqual(lightboxRail([], 0).items, [])
6507
+ assert.deepEqual(lightboxRail(null, 3).items, [])
6508
+ // 可注入上限(测试与将来的「显示几张」共用一条)
6509
+ assert.equal(lightboxRail(docs, 15, { size: 4 }).items.length, 4)
6510
+ })
6511
+
6512
+ /** 造一份 14 张图 + 1 个视频的媒体载荷(为了验「带子最多 10 张」)。 */
6513
+ function manyMediaPayload() {
6514
+ const now = Date.now()
6515
+ const docs = Array.from({ length: 14 }, (_, i) => ({
6516
+ path: `/p/m${i}.png`, rel: `m${i}.png`, name: `m${i}.png`, title: `m${i}`,
6517
+ kind: 'image', summary: '', size: 1000 + i, mtimeMs: now - i * 60000, score: null,
6518
+ }))
6519
+ docs.push({
6520
+ path: '/p/v.mp4', rel: 'v.mp4', name: 'v.mp4', title: 'v',
6521
+ kind: 'video', summary: '', size: 9000, mtimeMs: now - 9e7, score: null,
6522
+ })
6523
+ return { ok: true, root: '/p', total: docs.length, mode: 'time', topic: '', kind: 'media', docs }
6524
+ }
6525
+
6526
+ /** 挂到媒体档并双击第 n 张图,返回渲染节点与重渲染函数。 */
6527
+ async function mountLightbox(payload, openIndex = 0) {
6528
+ installFetch((url) => (url.includes('/api/attachments')
6529
+ ? { ok: true, items: [] }
6530
+ : url.includes('/api/doc')
6531
+ ? { ok: true, rel: 'x', title: 'x', text: '', truncated: false }
6532
+ : payload))
6533
+ const { KnitBody } = loadClientModule().exports.__test
6534
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6535
+ harness.reset()
6536
+ harness.seed(['', 'time', 'media'])
6537
+ let nodes = render()
6538
+ await harness.flush()
6539
+ nodes = render()
6540
+ const card = byClass(nodes, 'knit-media-card').filter((n) => String(n.props['data-knit-rel']).endsWith('.png'))[openIndex]
6541
+ assert.ok(card, '前提:有图片卡片')
6542
+ card.props.onDoubleClick()
6543
+ return { nodes: render(), render }
6544
+ }
6545
+
6546
+ test('全屏查看器:双击图片就打开;图与带子都在,带子里最多 10 张且含当前这张', async () => {
6547
+ const payload = manyMediaPayload()
6548
+ const { nodes } = await mountLightbox(payload, 2)
6549
+ const box = byExactClass(nodes, 'knit-lightbox')
6550
+ assert.equal(box.length, 1, '双击应打开查看器')
6551
+ assert.equal(box[0].props.role, 'dialog')
6552
+ assert.equal(box[0].props['aria-modal'], 'true')
6553
+
6554
+ const img = byExactClass(nodes, 'knit-lightbox-img')[0]
6555
+ assert.ok(img, '应有一张放大的图')
6556
+ assert.match(String(img.props.src), /\/api\/raw\?.*m2\.png/, `打开的是双击的那张:${img.props.src}`)
6557
+
6558
+ // ⚠️ 用 byClass(子串)而不是 byExactClass:当前那张的 class 是「knit-lightbox-thumb active」,
6559
+ // 完全相等匹配会把它排除在外 —— 于是「一张 active 都没有」看起来像代码 bug,其实是断言写错。
6560
+ const thumbs = byClass(nodes, 'knit-lightbox-thumb')
6561
+ assert.ok(thumbs.length > 0 && thumbs.length <= 10, `带子最多 10 张:${thumbs.length}`)
6562
+ const active = thumbs.filter((t) => String(t.props.className).includes('active'))
6563
+ assert.equal(active.length, 1, '带子里正好一张是「当前」')
6564
+ assert.match(String(active[0].props.title), /m2\.png/, '当前那张的缩略图被标出来')
6565
+ })
6566
+
6567
+ test('全屏查看器:点**图片以外**关闭;点图片本身不关(否则想看清细节就点没了)', async () => {
6568
+ const { nodes, render } = await mountLightbox(manyMediaPayload(), 0)
6569
+ assert.equal(byExactClass(nodes, 'knit-lightbox').length, 1, '前提:开着')
6570
+
6571
+ // 点图片本身:它的 handler 只做 stopPropagation,不许关
6572
+ const img = byExactClass(nodes, 'knit-lightbox-img')[0]
6573
+ let stopped = 0
6574
+ img.props.onClick({ stopPropagation: () => { stopped += 1 } })
6575
+ assert.equal(stopped, 1, '点图片必须 stopPropagation(冒泡到遮罩就关了)')
6576
+ assert.equal(byExactClass(render(), 'knit-lightbox').length, 1, '还开着')
6577
+
6578
+ // 点遮罩(图片以外):关
6579
+ byExactClass(nodes, 'knit-lightbox')[0].props.onClick()
6580
+ assert.equal(byExactClass(render(), 'knit-lightbox').length, 0, '点图片以外应关闭')
6581
+ })
6582
+
6583
+ test('全屏查看器:点左侧缩略图换图(且不冒泡去关)', async () => {
6584
+ const { nodes, render } = await mountLightbox(manyMediaPayload(), 0)
6585
+ const thumbs = byClass(nodes, 'knit-lightbox-thumb')
6586
+ assert.ok(thumbs.length >= 2, '前提:带子里至少两张')
6587
+
6588
+ let stopped = 0
6589
+ const rail = byExactClass(nodes, 'knit-lightbox-rail')[0]
6590
+ rail.props.onClick({ stopPropagation: () => { stopped += 1 } })
6591
+ assert.equal(stopped, 1, '点带子不许冒泡去关')
6592
+
6593
+ thumbs[1].props.onClick()
6594
+ const after = render()
6595
+ assert.equal(byExactClass(after, 'knit-lightbox').length, 1, '换图不该关掉')
6596
+ const img = byExactClass(after, 'knit-lightbox-img')[0]
6597
+ const expect = String(thumbs[1].props.title)
6598
+ assert.ok(String(img.props.src).includes(encodeURIComponent(expect.replace('/p/', ''))) || String(img.props.src).includes(expect),
6599
+ `换成了第二张:${img.props.src}`)
6600
+ })
6601
+
6602
+ test('全屏查看器:Esc 关、← → 翻页(键盘归它,不许漏到列表导航)', async () => {
6603
+ const { nodes, render } = await mountLightbox(manyMediaPayload(), 3)
6604
+ // 每次都取**当前这次渲染**的根节点:真实界面里事件处理器每次渲染都是新的
6605
+ const rootOf = (n) => byClass(n, 'knit-root')[0]
6606
+ const key = (name) => {
6607
+ const calls = { prevented: 0, stopped: 0 }
6608
+ return [{
6609
+ key: name, preventDefault: () => { calls.prevented += 1 }, stopPropagation: () => { calls.stopped += 1 },
6610
+ }, calls]
6611
+ }
6612
+ // → 翻到下一张
6613
+ const [right, rCalls] = key('ArrowRight')
6614
+ rootOf(nodes).props.onKeyDownCapture(right)
6615
+ assert.equal(rCalls.prevented, 1, '必须拦下(否则列表的键盘导航也跟着动)')
6616
+ let after = render()
6617
+ const img = byExactClass(after, 'knit-lightbox-img')[0]
6618
+ assert.match(String(img.props.src), /m4\.png/, `→ 应换成下一张(列表是 m0,m1,m2,m3,m4…;当前 m3):${img.props.src}`)
6619
+
6620
+ // ← 回到上一张
6621
+ const [left] = key('ArrowLeft')
6622
+ rootOf(after).props.onKeyDownCapture(left)
6623
+ after = render()
6624
+ assert.match(String(byExactClass(after, 'knit-lightbox-img')[0].props.src), /m3\.png/, '← 应回去')
6625
+
6626
+ // Esc 关
6627
+ const [esc, eCalls] = key('Escape')
6628
+ rootOf(after).props.onKeyDownCapture(esc)
6629
+ assert.equal(eCalls.stopped, 1, 'Esc 必须 stopPropagation(否则列表也会跟着关预览)')
6630
+ assert.equal(byExactClass(render(), 'knit-lightbox').length, 0, 'Esc 应关闭')
6631
+ })
6632
+
6633
+ test('全屏查看器:**视频**双击不走这里(仍开新标签页)—— 视频没有「全屏看一张图」这个语义', async () => {
6634
+ const payload = manyMediaPayload()
6635
+ installFetch((url) => (url.includes('/api/attachments')
6636
+ ? { ok: true, items: [] }
6637
+ : url.includes('/api/doc')
6638
+ ? { ok: true, rel: 'x', title: 'x', text: '', truncated: false }
6639
+ : payload))
6640
+ const { KnitBody } = loadClientModule().exports.__test
6641
+ harness.reset()
6642
+ harness.seed(['', 'time', 'media'])
6643
+ let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6644
+ await harness.flush()
6645
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6646
+ const video = byClass(nodes, 'knit-media-card').find((n) => String(n.props['data-knit-rel']).endsWith('.mp4'))
6647
+ assert.ok(video, '前提:有视频卡片')
6648
+ video.props.onDoubleClick()
6649
+ nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
6650
+ assert.equal(byExactClass(nodes, 'knit-lightbox').length, 0, '视频不该打开查看器')
6651
+ })
6652
+
6653
+ test('全屏查看器:毛玻璃**随主题**(两套遮罩都定义),且图片以外的区域才可点关闭', async () => {
6654
+ const { readFileSync } = await import('node:fs')
6655
+ const { fileURLToPath } = await import('node:url')
6656
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6657
+ const start = source.indexOf('const CSS = `') + 'const CSS = `'.length
6658
+ const css = source.slice(start, source.indexOf('`', start))
6659
+
6660
+ const scrims = [...css.matchAll(/--knit-scrim:([^;]+);/g)].map((m) => m[1].trim())
6661
+ assert.equal(scrims.length, 2, `浅色 / 深色各一套遮罩,实际 ${scrims.length} 套`)
6662
+ assert.match(scrims[0], /^rgba\(255,255,255,/, '浅色:半透明白')
6663
+ assert.match(scrims[1], /^rgba\(/, '深色:半透明(近黑)')
6664
+ assert.notEqual(scrims[0], scrims[1], '两套必须不同 —— 否则「随深色模式变化」是假的')
6665
+
6666
+ const box = css.match(/\.knit-lightbox\{([^}]*)\}/)
6667
+ assert.ok(box, '应有 .knit-lightbox 的样式')
6668
+ assert.match(box[1], /position:fixed/, '整窗遮罩')
6669
+ assert.match(box[1], /background:var\(--knit-scrim\)/, '底色吃遮罩变量(这样才随主题)')
6670
+ assert.match(box[1], /backdrop-filter:blur\(/, '毛玻璃:必须真的模糊背后的内容')
6671
+ assert.match(box[1], /z-index:\d{6,}/, '必须是**模态级**层级:70 那一档压不住宿主自己的侧栏与对话(用户实测只盖住了面板那一块)')
6672
+ const img = css.match(/\.knit-lightbox-img\{([^}]*)\}/)
6673
+ assert.ok(img, '应有放大图的样式')
6674
+ assert.match(img[1], /object-fit:contain/, '等比铺满,不裁切')
6675
+ assert.match(img[1], /cursor:default/, '图片本身不是「点一下关闭」的抓手')
6676
+ })
6677
+
6678
+ test('全屏查看器(纯):能 portal 就 portal 到 document.body —— 否则 fixed 被侧栏的 transform 困住', () => {
6679
+ const { mountLightbox } = loadClientModule().exports.__test
6680
+ const node = { type: 'div', props: { className: 'knit-lightbox' } }
6681
+ const seen = []
6682
+ const renderer = { createPortal: (n, target) => { seen.push({ n, target }); return { $$portal: n, target } } }
6683
+ const body = { tag: 'body' }
6684
+
6685
+ const out = mountLightbox(node, { dom: { body }, renderer })
6686
+ assert.equal(seen.length, 1, '有 document.body + createPortal ⇒ 必须走 portal')
6687
+ assert.equal(seen[0].target, body, '挂载点是 document.body')
6688
+ assert.ok(out.$$portal, '返回的是 portal 结果')
6689
+
6690
+ // 降级:没有 document(测试替身 / 老宿主)、没有 createPortal、portal 抛错 —— 一律原地渲染,不许白屏
6691
+ assert.equal(mountLightbox(node, { dom: null, renderer }), node)
6692
+ assert.equal(mountLightbox(node, { dom: { body }, renderer: null }), node)
6693
+ assert.equal(mountLightbox(node, { dom: { body }, renderer: { createPortal: () => { throw new Error('boom') } } }), node,
6694
+ 'portal 抛错要降级成就地渲染')
6695
+ })
6696
+
6697
+ test('全屏查看器:渲染**必须**走 mountLightbox(这条是「整屏」的机制,测试替身验不到只能用形状守)', async () => {
6698
+ const { readFileSync } = await import('node:fs')
6699
+ const { fileURLToPath } = await import('node:url')
6700
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6701
+ assert.ok(source.includes("mountLightbox(h('div', {"),
6702
+ '查看器必须经 mountLightbox 挂载 —— 直接在 .knit-root 里渲染会退回「只盖住面板」')
6703
+ assert.match(source, /createPortal\(node, dom\.body\)/, 'portal 的挂载点是 document.body')
6704
+ // 遮罩变量必须挂在查看器自己身上:portal 之后它不在 .knit-root 里,读不到那层的变量
6705
+ assert.ok(source.includes('--knit-scrim:rgba(255,255,255,.62);'),
6706
+ '遮罩变量要定义在 .knit-lightbox 上(不是 .knit-root)')
6707
+ const start = source.indexOf('const CSS = `') + 'const CSS = `'.length
6708
+ const css = source.slice(start, source.indexOf('`', start))
6709
+ assert.ok(css.includes('body[data-ds-dark-theme] .knit-lightbox'), '深色模式要在**全局选择器**上覆盖(portal 之后没有 .knit-root 可依赖)')
6710
+ // `.knit-root` 那一层不许再声明遮罩(否则两处真源,哪天漂了没人知道)
6711
+ const rootRule = css.match(/\.knit-root\{([^}]*)\}/)
6712
+ assert.ok(rootRule && !rootRule[1].includes('--knit-scrim'), '--knit-scrim 只许有一处真源(.knit-lightbox)')
6713
+ })
6714
+
6715
+ test('全屏查看器:右上角有 ✕(照 DSH 自带查看器 —— 全屏之后必须有看得见的出口)', async () => {
6716
+ installFetch((url) => (url.includes('/api/attachments')
6717
+ ? { ok: true, items: [] }
6718
+ : url.includes('/api/doc')
6719
+ ? { ok: true, rel: 'x', title: 'x', text: '', truncated: false }
6720
+ : manyMediaPayload()))
6721
+ const { KnitBody } = loadClientModule().exports.__test
6722
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6723
+ harness.reset()
6724
+ harness.seed(['', 'time', 'media'])
6725
+ let nodes = render()
6726
+ await harness.flush()
6727
+ nodes = render()
6728
+ byClass(nodes, 'knit-media-card')[0].props.onDoubleClick()
6729
+ nodes = render()
6730
+
6731
+ const close = byExactClass(nodes, 'knit-lightbox-close')
6732
+ assert.equal(close.length, 1, '应有一个关闭按钮')
6733
+ // ⚠️ 必须是 <button>:换成 span 看着一样,但键盘 Tab 不到、读屏也不当按钮 ——
6734
+ // 这条是证伪时发现「只查类名不查元素类型」会漏掉的真回归。
6735
+ assert.equal(close[0].type, 'button', '必须是真的 <button>(可聚焦、可读屏)')
6736
+ assert.equal(textOf(close[0]).trim(), '✕', '按钮上就是 ✕(和宿主那个一致)')
6737
+ assert.match(String(close[0].props.title), /Esc/, '悬停提示要告诉人还有 Esc 这条路')
6738
+ assert.ok(close[0].props['aria-label'], '要有 aria-label(读屏用户靠它)')
6739
+
6740
+ close[0].props.onClick()
6741
+ assert.equal(byExactClass(render(), 'knit-lightbox').length, 0, '点 ✕ 应关闭')
6742
+
6743
+ // CSS:右上角、可点、悬停有反馈
6744
+ const { readFileSync } = await import('node:fs')
6745
+ const { fileURLToPath } = await import('node:url')
6746
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6747
+ const start = source.indexOf('const CSS = `') + 'const CSS = `'.length
6748
+ const css = source.slice(start, source.indexOf('`', start))
6749
+ const rule = css.match(/\.knit-lightbox-close\{([^}]*)\}/)
6750
+ assert.ok(rule, '应有 .knit-lightbox-close 的样式')
6751
+ assert.match(rule[1], /position:absolute/, '定位在遮罩里')
6752
+ assert.match(rule[1], /top:/, '靠上')
6753
+ assert.match(rule[1], /right:/, '靠右')
6754
+ assert.match(rule[1], /cursor:pointer/, '要让人知道能点')
6755
+ assert.ok(/\.knit-lightbox-close:hover\{/.test(css), '悬停要有反馈')
6756
+ })
6757
+
6758
+ test('键盘:媒体档 ↑↓ 只移光标不弹预览;Enter 在图片上进查看器、在视频上就地预览', async () => {
6759
+ installFetch(kindResponder({ media: mediaPayload() }))
6760
+ const { KnitBody } = loadClientModule().exports.__test
6761
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6762
+ const listOf = (n) => byExactClass(n, 'knit-list')[0]
6763
+ harness.reset()
6764
+ harness.seed(['', 'time', 'media'])
6765
+ let nodes = render()
6766
+ await harness.flush()
6767
+ nodes = render()
6768
+
6769
+ // ↓:光标往下走,但**不弹预览**(2026-10-22 用户裁决)
6770
+ listOf(nodes).props.onKeyDown({ key: 'ArrowDown', preventDefault() {} })
6771
+ nodes = render()
6772
+ assert.equal(byExactClass(nodes, 'knit-preview').length, 0, '方向键不许弹就地预览')
6773
+ assert.ok(String(byClass(nodes, 'knit-media-card')[1].props.className).includes('cursor'), '光标应移到第二张')
6774
+
6775
+ // ↑ 回到第一张(图片),Enter ⇒ 全屏查看器
6776
+ listOf(nodes).props.onKeyDown({ key: 'ArrowUp', preventDefault() {} })
6777
+ nodes = render()
6778
+ listOf(nodes).props.onKeyDown({ key: 'Enter', preventDefault() {} })
6779
+ nodes = render()
6780
+ assert.equal(byExactClass(nodes, 'knit-lightbox').length, 1, '图片上 Enter 应进查看器')
6781
+ assert.equal(byExactClass(nodes, 'knit-preview').length, 0, '而不是弹就地预览')
6782
+
6783
+ // 关掉查看器,移到视频上按 Enter ⇒ 就地预览(视频只能这么看)
6784
+ byExactClass(nodes, 'knit-lightbox-close')[0].props.onClick()
6785
+ nodes = render()
6786
+ listOf(nodes).props.onKeyDown({ key: 'ArrowDown', preventDefault() {} })
6787
+ nodes = render()
6788
+ listOf(nodes).props.onKeyDown({ key: 'Enter', preventDefault() {} })
6789
+ nodes = render()
6790
+ assert.equal(byExactClass(nodes, 'knit-preview').length, 1, '视频上 Enter 应就地预览')
6791
+ assert.equal(byClass(nodes, 'knit-preview-media').length, 1, '而且是播放器那个预览体')
6792
+ assert.equal(byExactClass(nodes, 'knit-lightbox').length, 0, '视频不该进查看器')
6793
+ })
6794
+
6795
+ test('查看器:对话里生成的图**没有**「收藏 / 本地打开」(它还没有工作区路径,别给死按钮)', async () => {
6796
+ const items = [attachmentFixture()]
6797
+ installFetch((url) => (url.includes('/api/attachments')
6798
+ ? { ok: true, items }
6799
+ : url.includes('/api/doc')
6800
+ ? { ok: true, rel: 'x', title: 'x', text: '', truncated: false }
6801
+ : mediaPayload()))
6802
+ const { KnitBody } = loadClientModule().exports.__test
6803
+ const render = () => harness.render(h(KnitBody, { sessionId: 's1' }))
6804
+ harness.reset()
6805
+ harness.seed(['', 'time', 'media'])
6806
+ let nodes = render()
6807
+ await harness.flush()
6808
+ nodes = render()
6809
+ await harness.flush()
6810
+ nodes = render()
6811
+
6812
+ const conv = byClass(nodes, 'knit-media-card').find((n) => n.props['data-knit-rel'] === items[0].id)
6813
+ assert.ok(conv, '前提:对话图在网格里')
6814
+ conv.props.onDoubleClick()
6815
+ nodes = render()
6816
+ assert.equal(byExactClass(nodes, 'knit-lightbox').length, 1, '对话图也能全屏看')
6817
+ const labels = byClass(nodes, 'knit-btn').map(textOf)
6818
+ assert.ok(!labels.includes('收藏'), `对话图不该有「收藏」:${labels.join(' / ')}`)
6819
+ assert.ok(!labels.includes('本地打开'), `对话图不该有「本地打开」:${labels.join(' / ')}`)
6820
+ assert.equal(byExactClass(nodes, 'knit-lightbox-close').length, 1, '但关闭按钮必须在')
6821
+ })
6822
+
6823
+ test('查看器:**↑↓ 也能翻页**(左列是竖的),滚轮在图片区翻页、但不抢左列的滚动', async () => {
6824
+ const { nodes, render } = await mountLightbox(manyMediaPayload(), 3)
6825
+ const rootOf = (n) => byClass(n, 'knit-root')[0]
6826
+ const key = (name) => ({ key: name, preventDefault() {}, stopPropagation() {} })
6827
+
6828
+ // ↓ = 下一张(与 → 等价)
6829
+ rootOf(nodes).props.onKeyDownCapture(key('ArrowDown'))
6830
+ let after = render()
6831
+ assert.match(String(byExactClass(after, 'knit-lightbox-img')[0].props.src), /m4\.png/, '↓ 应到下一张')
6832
+
6833
+ // ↑ = 上一张(与 ← 等价)
6834
+ rootOf(after).props.onKeyDownCapture(key('ArrowUp'))
6835
+ after = render()
6836
+ assert.match(String(byExactClass(after, 'knit-lightbox-img')[0].props.src), /m3\.png/, '↑ 应回上一张')
6837
+
6838
+ // 滚轮:在图片区(stage)上滚 = 翻页
6839
+ const stage = byExactClass(after, 'knit-lightbox-stage')[0]
6840
+ assert.ok(stage, '应有图片区(stage)')
6841
+ assert.equal(typeof stage.props.onWheel, 'function', '滚轮要能翻页')
6842
+ stage.props.onWheel({ deltaY: 120 })
6843
+ after = render()
6844
+ assert.match(String(byExactClass(after, 'knit-lightbox-img')[0].props.src), /m4\.png/, '往下滚 = 下一张')
6845
+ stage.props.onWheel({ deltaY: -120 })
6846
+ after = render()
6847
+ assert.match(String(byExactClass(after, 'knit-lightbox-img')[0].props.src), /m3\.png/, '往上滚 = 上一张')
6848
+ // delta 为 0 不许乱翻
6849
+ const before = String(byExactClass(after, 'knit-lightbox-img')[0].props.src)
6850
+ byExactClass(after, 'knit-lightbox-stage')[0].props.onWheel({ deltaY: 0 })
6851
+ assert.equal(String(byExactClass(render(), 'knit-lightbox-img')[0].props.src), before, '零位移不许翻')
6852
+
6853
+ // 左列自己会滚 ⇒ 它上面**不许**挂翻页(否则「滚列表」变成「换图」)
6854
+ const rail = byExactClass(after, 'knit-lightbox-rail')[0]
6855
+ assert.equal(rail.props.onWheel, undefined, '滚轮在左列上应该滚列表,不许被翻页抢走')
6856
+ })
6857
+
6858
+ test('查看器:换图时把当前缩略图滚进可视区(替身没有 DOM,这条只能守形状)', async () => {
6859
+ const { readFileSync } = await import('node:fs')
6860
+ const { fileURLToPath } = await import('node:url')
6861
+ const source = readFileSync(fileURLToPath(new URL('../src/client/client.js', import.meta.url)), 'utf8')
6862
+ /* ⚠️ 别只断言 `scrollIntoView({ block: 'nearest' })` —— 那个串在**预览查找**里早就有一处,
6863
+ 断言会被它「借」过去(第一版就是这么空转的,把 bug 放回去照样绿)。必须绑到 `active` 这一行。 */
6864
+ assert.ok(source.includes("active.scrollIntoView({ block: 'nearest' })"),
6865
+ '换图要把「当前那张」滚进视野(block:nearest —— 已在视野里就一格不动)')
6866
+ assert.ok(source.includes("rail.querySelector('.knit-lightbox-thumb.active')"), '找的是「当前那张」')
6867
+ assert.ok(source.includes("typeof rail.querySelector !== 'function'"), '没有 DOM(替身 / 老宿主)要能跳过')
6868
+ })