dsh-knit 0.23.1 → 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.
- package/CHANGELOG.md +136 -0
- package/README.en.md +36 -7
- package/README.md +35 -9
- package/SECURITY.md +10 -2
- package/package.json +3 -3
- package/src/client/client.js +1441 -29
- package/src/host/attachments.js +245 -0
- package/src/host/changes.js +208 -0
- package/src/host/git.js +377 -0
- package/src/host/index.js +358 -5
- package/test/attachments.test.mjs +285 -0
- package/test/client.test.mjs +1345 -11
- package/test/git-changes.test.mjs +1238 -0
- package/test/harness.mjs +12 -0
- package/test/host-http.test.mjs +4 -58
- package/test/http-harness.mjs +79 -0
- package/test/index-incremental.test.mjs +13 -2
package/src/client/client.js
CHANGED
|
@@ -15,6 +15,12 @@ window.__ModuleLoader__.load({
|
|
|
15
15
|
factory: (require) => {
|
|
16
16
|
const module = { exports: {} }
|
|
17
17
|
const React = require('react')
|
|
18
|
+
/* v0.25(2026-10-22):全屏查看器要**盖住整个屏幕**,所以必须挂到 `document.body` 上。
|
|
19
|
+
为什么不能就地渲染:`position:fixed` 会被**祖先的 transform / filter / contain 困住**
|
|
20
|
+
—— 宿主的右侧栏是滑入的(有 transform),那一层就成了 containing block,
|
|
21
|
+
`fixed` 于是变成「相对侧边栏」而不是视口,于是只能盖住面板那一块(用户实测如此)。
|
|
22
|
+
这是 CSS 逃不出来的坑,只有 portal 能解。取不到 react-dom(老宿主 / 测试替身)就退回就地渲染。 */
|
|
23
|
+
const ReactDOM = (() => { try { return require('react-dom') } catch { return null } })()
|
|
18
24
|
const h = React.createElement
|
|
19
25
|
|
|
20
26
|
/* ── 国际化(DSH 官方 ctx.locale)─────────────────── */
|
|
@@ -42,6 +48,7 @@ window.__ModuleLoader__.load({
|
|
|
42
48
|
|
|
43
49
|
'sort.relevance': '相关',
|
|
44
50
|
'sort.time': '最新',
|
|
51
|
+
'sort.mediaTimeTitle': '图片一律按时间排序(最新在前)',
|
|
45
52
|
'sort.relevanceTitle': '按与当前对话的相关性排序(纯本地关键词匹配,不调模型)',
|
|
46
53
|
'sort.timeTitle': '按文件修改时间倒序',
|
|
47
54
|
|
|
@@ -140,12 +147,18 @@ window.__ModuleLoader__.load({
|
|
|
140
147
|
// 所以它们一色到底(都是 caption 灰),靠**字**区分,不靠颜色。
|
|
141
148
|
'context.pinned': '固定上下文',
|
|
142
149
|
'context.pinnedHint': '你自己标记的',
|
|
150
|
+
// v0.25:Git 变更关联。**与三层平行的一区**,不参与 01…0N 的编号。
|
|
151
|
+
'context.changes': '变更关联',
|
|
152
|
+
'context.changesHint': '由未提交的改动牵出来的',
|
|
153
|
+
'context.changesEmpty': '{files} 个变更文件,没有找到关联证据',
|
|
154
|
+
'context.changesUnreadable': '读不到 Git 变更状态:{reason}',
|
|
143
155
|
'prov.retrieval': '检索',
|
|
144
156
|
'prov.relation': '关系',
|
|
145
157
|
'prov.manual': '用户固定',
|
|
146
158
|
// v0.23:第四档来源。它**只**由「标题 + 摘要」的向量与任务相似而来 ——
|
|
147
159
|
// 不是关键词命中、也不是关系证据,而且只可能落在「相关」那一层。
|
|
148
160
|
'prov.semantic': '语义相关',
|
|
161
|
+
'prov.change': '变更关联',
|
|
149
162
|
'control.pin': '固定',
|
|
150
163
|
'control.unpin': '取消固定',
|
|
151
164
|
'control.exclude': '排除',
|
|
@@ -173,6 +186,20 @@ window.__ModuleLoader__.load({
|
|
|
173
186
|
// ⚠️ 「关系 N 条」说的是**这一份包里带了几条关系证据**(三层各条 relations 之和),
|
|
174
187
|
// 不是工作区里的关系总数、也不是候选数(那两类数字宿主另有字段,这里不展示)。
|
|
175
188
|
'pipe.relations': '关系 {n} 条',
|
|
189
|
+
// v0.25:状态行里那一格(**默认关**)。关着也出现 —— 藏起来用户就永远打不开这个功能。
|
|
190
|
+
'pipe.changesOff': '变更',
|
|
191
|
+
'pipe.changesOn': '变更 {n}',
|
|
192
|
+
'pipe.changesUnavailable': '变更 —',
|
|
193
|
+
'changes.titleOff': '按 Git 变更查找需要一起检查的文件(只读:只跑一条 git status,不执行任何写操作)',
|
|
194
|
+
'changes.titleOn': '{files} 个变更文件 · {related} 条关联证据 · 点一下关闭',
|
|
195
|
+
'changes.titleUnavailable': '读不到 Git 变更状态:{reason}',
|
|
196
|
+
'changes.reason.notARepo': '不是 Git 工作区',
|
|
197
|
+
'changes.reason.gitMissing': '找不到 git 命令',
|
|
198
|
+
'changes.reason.timeout': 'git 读取超时',
|
|
199
|
+
'changes.reason.tooLarge': 'git 输出过大(已截断)',
|
|
200
|
+
'changes.reason.failed': 'git 读取失败',
|
|
201
|
+
'changes.reason.request': '变更关联接口请求失败',
|
|
202
|
+
'changes.reason.unknown': '原因未知',
|
|
176
203
|
// ⚠️ 「固定 N」= 有几篇被你固定、因此**从三层移出**进了固定区(pack.pinned 的长度)。
|
|
177
204
|
// 不写「固定覆盖」这种内部说法;也不带量词 —— 固定对象可能是文档、代码或媒体。
|
|
178
205
|
'pipe.pin': '固定 {n}',
|
|
@@ -288,6 +315,25 @@ window.__ModuleLoader__.load({
|
|
|
288
315
|
|
|
289
316
|
'preview.loading': '正在读取…',
|
|
290
317
|
'preview.truncated': '(文件较大,仅预览前 512 KB)',
|
|
318
|
+
// v0.25 预览里的查找(Cmd+F)。数字用 {current}/{total},两种语言同形。
|
|
319
|
+
'lightbox.aria': '查看大图:{name}',
|
|
320
|
+
'lightbox.close': '关闭(Esc)',
|
|
321
|
+
'attach.badge': '对话',
|
|
322
|
+
'attach.title': '对话里生成的图,还没保存到本地',
|
|
323
|
+
'fav.off': '收藏',
|
|
324
|
+
'fav.on': '已收藏',
|
|
325
|
+
'fav.addTitle': '收藏(排在媒体列表最前面)',
|
|
326
|
+
'fav.removeTitle': '取消收藏',
|
|
327
|
+
'fav.mark': '已收藏',
|
|
328
|
+
'find.openBtn': '查找',
|
|
329
|
+
'find.openTitle': '在本文里查找(Cmd+F)',
|
|
330
|
+
'find.placeholder': '在本文里查找',
|
|
331
|
+
'find.aria': '在预览的文档里查找',
|
|
332
|
+
'find.count': '{current}/{total}',
|
|
333
|
+
'find.none': '无结果',
|
|
334
|
+
'find.prev': '上一个',
|
|
335
|
+
'find.next': '下一个',
|
|
336
|
+
'find.close': '关闭查找',
|
|
291
337
|
'preview.fullscreen': '全屏',
|
|
292
338
|
'preview.exitFullscreen': '退出全屏',
|
|
293
339
|
'preview.fullscreenTitle': '全屏阅读',
|
|
@@ -375,6 +421,7 @@ window.__ModuleLoader__.load({
|
|
|
375
421
|
|
|
376
422
|
'sort.relevance': 'Relevant',
|
|
377
423
|
'sort.time': 'Recent',
|
|
424
|
+
'sort.mediaTimeTitle': 'Images are always sorted by newest first',
|
|
378
425
|
'sort.relevanceTitle': 'Sort by relevance to the current conversation (local keyword matching, no model call)',
|
|
379
426
|
'sort.timeTitle': 'Sort by file modified time, newest first',
|
|
380
427
|
|
|
@@ -460,11 +507,16 @@ window.__ModuleLoader__.load({
|
|
|
460
507
|
// in, not how strong it is — so they share one colour and differ by word.
|
|
461
508
|
'context.pinned': 'Pinned',
|
|
462
509
|
'context.pinnedHint': 'you marked these',
|
|
510
|
+
'context.changes': 'Tied to changes',
|
|
511
|
+
'context.changesHint': 'pulled in by your uncommitted edits',
|
|
512
|
+
'context.changesEmpty': '{files} changed file(s), no related evidence found',
|
|
513
|
+
'context.changesUnreadable': 'Git change status unavailable: {reason}',
|
|
463
514
|
'prov.retrieval': 'retrieved',
|
|
464
515
|
'prov.relation': 'relation',
|
|
465
516
|
'prov.manual': 'pinned',
|
|
466
517
|
// v0.23: the fourth provenance (semantic) — same neutral, lowercase word group.
|
|
467
518
|
'prov.semantic': 'semantic',
|
|
519
|
+
'prov.change': 'change',
|
|
468
520
|
'control.pin': 'Pin',
|
|
469
521
|
'control.unpin': 'Unpin',
|
|
470
522
|
'control.exclude': 'Exclude',
|
|
@@ -484,6 +536,19 @@ window.__ModuleLoader__.load({
|
|
|
484
536
|
'pipe.candidates': '{n} candidates',
|
|
485
537
|
'pipe.rank': 'BM25 retrieval',
|
|
486
538
|
'pipe.relations': '{n} relations',
|
|
539
|
+
'pipe.changesOff': 'Changes',
|
|
540
|
+
'pipe.changesOn': 'Changes {n}',
|
|
541
|
+
'pipe.changesUnavailable': 'Changes —',
|
|
542
|
+
'changes.titleOff': 'Find the files to check alongside your Git changes (read-only: one git status, no write commands)',
|
|
543
|
+
'changes.titleOn': '{files} changed file(s) · {related} related by evidence · click to turn off',
|
|
544
|
+
'changes.titleUnavailable': 'Git change status unavailable: {reason}',
|
|
545
|
+
'changes.reason.notARepo': 'not a Git working tree',
|
|
546
|
+
'changes.reason.gitMissing': 'git command not found',
|
|
547
|
+
'changes.reason.timeout': 'git timed out',
|
|
548
|
+
'changes.reason.tooLarge': 'git output too large (truncated)',
|
|
549
|
+
'changes.reason.failed': 'git read failed',
|
|
550
|
+
'changes.reason.request': 'the change-links request failed',
|
|
551
|
+
'changes.reason.unknown': 'unknown reason',
|
|
487
552
|
'pipe.pin': '{n} pinned',
|
|
488
553
|
'pipe.pack': '{n} in pack',
|
|
489
554
|
// v0.23 (Phase A): hybrid retrieval. This cell states the mode **in effect**, not the click.
|
|
@@ -573,6 +638,24 @@ window.__ModuleLoader__.load({
|
|
|
573
638
|
|
|
574
639
|
'preview.loading': 'Loading…',
|
|
575
640
|
'preview.truncated': '(large file — showing the first 512 KB)',
|
|
641
|
+
'lightbox.aria': 'Image viewer: {name}',
|
|
642
|
+
'lightbox.close': 'Close (Esc)',
|
|
643
|
+
'attach.badge': 'Chat',
|
|
644
|
+
'attach.title': 'Generated in this chat — not saved locally yet',
|
|
645
|
+
'fav.off': 'Favorite',
|
|
646
|
+
'fav.on': 'Favorited',
|
|
647
|
+
'fav.addTitle': 'Favorite this (it moves to the front of the media list)',
|
|
648
|
+
'fav.removeTitle': 'Remove favorite',
|
|
649
|
+
'fav.mark': 'Favorited',
|
|
650
|
+
'find.openBtn': 'Find',
|
|
651
|
+
'find.openTitle': 'Find in this document (Cmd+F)',
|
|
652
|
+
'find.placeholder': 'Find in this document',
|
|
653
|
+
'find.aria': 'Find in the previewed document',
|
|
654
|
+
'find.count': '{current}/{total}',
|
|
655
|
+
'find.none': 'No results',
|
|
656
|
+
'find.prev': 'Previous',
|
|
657
|
+
'find.next': 'Next',
|
|
658
|
+
'find.close': 'Close find',
|
|
576
659
|
'preview.fullscreen': 'Fullscreen',
|
|
577
660
|
'preview.exitFullscreen': 'Exit fullscreen',
|
|
578
661
|
'preview.fullscreenTitle': 'Read fullscreen',
|
|
@@ -750,6 +833,13 @@ window.__ModuleLoader__.load({
|
|
|
750
833
|
const BS_TAB_ID = 'knit:recent'
|
|
751
834
|
|
|
752
835
|
const LIST_API = '/knit/api/recent'
|
|
836
|
+
/* v0.25:Git 变更关联的**独立接口**。它与列表接口分开,所以「列表的响应形状」
|
|
837
|
+
不会被这个功能碰到;关掉功能时客户端连这个请求都不发。 */
|
|
838
|
+
const CHANGES_API = '/knit/api/changes'
|
|
839
|
+
/* v0.25:媒体档额外显示「对话里工具产出的图」——**独立接口**,`/api/recent` 一个字节没动。
|
|
840
|
+
列表零 I/O(元数据全在会话事件里);字节按 **sha256** 取(见 `attachmentUrl`)。 */
|
|
841
|
+
const ATTACH_LIST_API = '/knit/api/attachments'
|
|
842
|
+
const ATTACH_RAW_API = '/knit/api/attachment'
|
|
753
843
|
const DOC_API = '/knit/api/doc'
|
|
754
844
|
const RAW_API = '/knit/api/raw'
|
|
755
845
|
// v0.12:某篇的「谁引用了它 / 它引用了谁」。与上面三条一样是**同源相对地址**,
|
|
@@ -790,6 +880,8 @@ window.__ModuleLoader__.load({
|
|
|
790
880
|
它要用户显式选、并且配了 provider 才会真的跑 —— 「零模型调用 / 零网络出口」
|
|
791
881
|
这条对外承诺只在默认模式成立(细则见 v0.23 方案 §2 的文案纪律)。 */
|
|
792
882
|
const RETRIEVAL_KEY = 'dsh-knit:retrieval'
|
|
883
|
+
/** v0.25:Git 变更关联的开关。**默认关** —— 不写这一项就是关。 */
|
|
884
|
+
const CHANGES_KEY = 'dsh-knit:changes'
|
|
793
885
|
/** 语义 provider 的**唯一写路由**;读走 `/api/recent` 的 `semantic.provider`。 */
|
|
794
886
|
const SEMANTIC_API = '/knit/api/semantic'
|
|
795
887
|
|
|
@@ -926,6 +1018,227 @@ window.__ModuleLoader__.load({
|
|
|
926
1018
|
* 格子基准宽(= CSS 的 minmax 下限)、当前宽度下能排几列、单格实际宽度、
|
|
927
1019
|
* 是否让卡片文字让位
|
|
928
1020
|
*/
|
|
1021
|
+
/* ── v0.25:媒体档「悬停看大图」────────────────────────────────────────
|
|
1022
|
+
用户要的是「鼠标停在图片上,弹一个大图」。
|
|
1023
|
+
|
|
1024
|
+
三条取舍:
|
|
1025
|
+
① **800×800 是上限,不是尺寸** —— 面板本身只有几百像素宽,硬占 800 会把对话区盖住。
|
|
1026
|
+
所以盒子按「卡片左边还剩多少」与视口算,最后再夹到 800。
|
|
1027
|
+
② **只做图片**(视频要解码 + 起播放器,噪声与代价都不是一个量级)。
|
|
1028
|
+
③ **延迟出现**(`HOVER_SHOT_DELAY_MS`):鼠标扫过网格时不许一路闪;
|
|
1029
|
+
离开即收。`pointer-events:none` —— 它只是「看一眼」,不许挡点击。
|
|
1030
|
+
*/
|
|
1031
|
+
|
|
1032
|
+
/**
|
|
1033
|
+
* 悬停浮窗的边长上限。
|
|
1034
|
+
*
|
|
1035
|
+
* ⚠️ 2026-10-21 从 800 改成 420:用户在真机上看了之后说「现在浮窗太大了」,
|
|
1036
|
+
* 并在截图上用红框标出他想要的大小 —— 约等于原来的**一半**。
|
|
1037
|
+
* 这是**一个人眼定的大小**,不是算出来的;要再调就只改这一个数。
|
|
1038
|
+
*/
|
|
1039
|
+
const HOVER_SHOT_MAX = 420
|
|
1040
|
+
/* ── v0.25:媒体档「双击全屏」(2026-10-22,参照用户给的 Codex 截图)────────
|
|
1041
|
+
用户要的三件事:① 双击图片进全屏;② 点图片以外关闭;③ 左侧一列「近 10 张」缩略图。
|
|
1042
|
+
另加两件(不然光看图就断手):图片以外是**毛玻璃**且随主题变(他第 4 点要的),
|
|
1043
|
+
以及 `←` `→` 在带子里前后翻。
|
|
1044
|
+
刻意**没做**(他没要,也不该顺手塞):缩放百分比、下载、用其他应用打开。
|
|
1045
|
+
*/
|
|
1046
|
+
|
|
1047
|
+
/**
|
|
1048
|
+
* 把查看器挂到哪:**能 portal 就一定 portal**(否则 `fixed` 会被侧边栏的 transform 困住)。
|
|
1049
|
+
*
|
|
1050
|
+
* 单独抽成一个函数是为了「这件事有没有做」能被源码守卫直接看见 ——
|
|
1051
|
+
* 测试替身没有 `document`,这条路径只能在真机上走,所以形状守卫是它唯一的护栏。
|
|
1052
|
+
*
|
|
1053
|
+
* @param {object} node - 要挂的 React 元素
|
|
1054
|
+
* @param {{doc?:object, dom?:object}} [env] - 可注入的 document / ReactDOM(默认取模块里的)
|
|
1055
|
+
* @returns {object} portal 结果,或原节点(降级)
|
|
1056
|
+
*/
|
|
1057
|
+
function mountLightbox(node, env = {}) {
|
|
1058
|
+
const dom = env.dom === undefined ? (typeof document === 'undefined' ? null : document) : env.dom
|
|
1059
|
+
const renderer = env.renderer === undefined ? ReactDOM : env.renderer
|
|
1060
|
+
try {
|
|
1061
|
+
if (node && dom && dom.body && renderer && typeof renderer.createPortal === 'function') {
|
|
1062
|
+
return renderer.createPortal(node, dom.body)
|
|
1063
|
+
}
|
|
1064
|
+
} catch { /* portal 失败就就地渲染,不许白屏 */ }
|
|
1065
|
+
return node
|
|
1066
|
+
}
|
|
1067
|
+
|
|
1068
|
+
/** 全屏查看器左侧缩略图带显示几张。 */
|
|
1069
|
+
const LIGHTBOX_RAIL = 10
|
|
1070
|
+
/** 当前这张在带子里前面留几张(偏「刚看过的」,不是偏「后面的」)。 */
|
|
1071
|
+
const LIGHTBOX_RAIL_LEAD = 4
|
|
1072
|
+
|
|
1073
|
+
/**
|
|
1074
|
+
* 全屏查看器的左侧缩略图带:取**当前这张附近**的 N 张。
|
|
1075
|
+
*
|
|
1076
|
+
* 为什么不是「最新的 N 张」:双击第 30 张时,「最新 10 张」里根本没有它 ——
|
|
1077
|
+
* 带子里看不到当前这张,前后翻也断在画面外。所以取一个以当前为中心的窗口,两头夹紧。
|
|
1078
|
+
* **纯函数**:只吃数组与下标,能真断言。
|
|
1079
|
+
*
|
|
1080
|
+
* @param {object[]} docs - 当前媒体列表(已排好序)
|
|
1081
|
+
* @param {number} index - 当前这张的下标
|
|
1082
|
+
* @param {{size?:number, lead?:number}} [opts] - 带子长度与前置张数
|
|
1083
|
+
* @returns {{start:number, items:object[]}} 起点与带子内容
|
|
1084
|
+
*/
|
|
1085
|
+
function lightboxRail(docs, index, opts = {}) {
|
|
1086
|
+
const list = Array.isArray(docs) ? docs : []
|
|
1087
|
+
const size = Number.isFinite(opts.size) ? Math.max(1, Math.round(opts.size)) : LIGHTBOX_RAIL
|
|
1088
|
+
const lead = Number.isFinite(opts.lead) ? Math.max(0, Math.round(opts.lead)) : LIGHTBOX_RAIL_LEAD
|
|
1089
|
+
if (!list.length) return { start: 0, items: [] }
|
|
1090
|
+
const at = Number.isFinite(index) ? Math.min(Math.max(0, Math.round(index)), list.length - 1) : 0
|
|
1091
|
+
const start = Math.min(Math.max(0, at - lead), Math.max(0, list.length - size))
|
|
1092
|
+
return { start, items: list.slice(start, start + size) }
|
|
1093
|
+
}
|
|
1094
|
+
|
|
1095
|
+
/** 浮窗与卡片之间的间距。 */
|
|
1096
|
+
const HOVER_SHOT_GAP = 12
|
|
1097
|
+
/** 浮窗与视口边缘的最小留白。 */
|
|
1098
|
+
const HOVER_SHOT_MARGIN = 12
|
|
1099
|
+
/** 停多久才出现 —— 短了会在鼠标扫过时一路闪,长了会显得没反应。 */
|
|
1100
|
+
const HOVER_SHOT_DELAY_MS = 350
|
|
1101
|
+
|
|
1102
|
+
/**
|
|
1103
|
+
* 算悬停浮窗的盒子。**纯函数**:只吃两个矩形,不做任何 DOM 读。
|
|
1104
|
+
*
|
|
1105
|
+
* 规则:默认摆在卡片**左侧**(面板在右边,浮窗往对话区那边让,不压住网格);
|
|
1106
|
+
* 左边放不下就翻到右侧;垂直以卡片中线居中并夹进视口;盒子边长**最后**夹到 800。
|
|
1107
|
+
*
|
|
1108
|
+
* @param {{left:number,top:number,width:number,height:number}|null} card - 卡片矩形
|
|
1109
|
+
* @param {{width:number,height:number}} view - 视口尺寸
|
|
1110
|
+
* @param {{max?:number,gap?:number,margin?:number}} [opts] - 可注入的常数(测试用)
|
|
1111
|
+
* @returns {{left:number,top:number,width:number,height:number,side:'left'|'right'}} 盒子
|
|
1112
|
+
*/
|
|
1113
|
+
function hoverShotBox(card, view, opts = {}) {
|
|
1114
|
+
const max = Number.isFinite(opts.max) ? opts.max : HOVER_SHOT_MAX
|
|
1115
|
+
const gap = Number.isFinite(opts.gap) ? opts.gap : HOVER_SHOT_GAP
|
|
1116
|
+
const margin = Number.isFinite(opts.margin) ? opts.margin : HOVER_SHOT_MARGIN
|
|
1117
|
+
const viewW = view && Number.isFinite(view.width) ? view.width : 1024
|
|
1118
|
+
const viewH = view && Number.isFinite(view.height) ? view.height : 768
|
|
1119
|
+
// 拿不到卡片矩形(测试替身没有 DOM / 事件不带 currentTarget)⇒ 视口里居中,仍然守 800 上限
|
|
1120
|
+
if (!card || !Number.isFinite(card.left) || !Number.isFinite(card.top)) {
|
|
1121
|
+
const size = Math.min(max, viewW - margin * 2, viewH - margin * 2)
|
|
1122
|
+
return {
|
|
1123
|
+
left: Math.max(margin, Math.round((viewW - size) / 2)),
|
|
1124
|
+
top: Math.max(margin, Math.round((viewH - size) / 2)),
|
|
1125
|
+
width: size,
|
|
1126
|
+
height: size,
|
|
1127
|
+
side: 'right',
|
|
1128
|
+
}
|
|
1129
|
+
}
|
|
1130
|
+
const roomLeft = card.left - gap - margin
|
|
1131
|
+
const roomRight = viewW - (card.left + card.width) - gap - margin
|
|
1132
|
+
const side = roomLeft >= roomRight ? 'left' : 'right'
|
|
1133
|
+
const room = Math.max(0, side === 'left' ? roomLeft : roomRight)
|
|
1134
|
+
const width = Math.max(1, Math.min(max, room, viewW - margin * 2))
|
|
1135
|
+
const height = Math.max(1, Math.min(max, viewH - margin * 2, width * 1.6))
|
|
1136
|
+
const rawLeft = side === 'left' ? card.left - gap - width : card.left + card.width + gap
|
|
1137
|
+
const left = Math.min(Math.max(margin, Math.round(rawLeft)), Math.max(margin, viewW - margin - width))
|
|
1138
|
+
const centerY = card.top + card.height / 2 - height / 2
|
|
1139
|
+
const top = Math.min(Math.max(margin, Math.round(centerY)), Math.max(margin, viewH - margin - height))
|
|
1140
|
+
return { left, top, width, height, side }
|
|
1141
|
+
}
|
|
1142
|
+
|
|
1143
|
+
/* ── v0.25:媒体收藏 ───────────────────────────────────────────────────
|
|
1144
|
+
只活在 localStorage(`readPref / writePref` 那一族:这是**语义偏好**,不是界面几何)。
|
|
1145
|
+
**不改宿主、不加接口** ⇒ 只需要硬刷新,不用重启 DSH。
|
|
1146
|
+
|
|
1147
|
+
顺序规则只有一条:**稳定分区** —— 收藏的按原有顺序排到前面,其余按原有顺序跟在后面。
|
|
1148
|
+
刻意**不做第二套排序**(不按收藏时间排、不按文件名排):用户要的是「收藏的放最前面」,
|
|
1149
|
+
而收藏之间谁在前仍由当前的「相关 / 最新」决定 —— 这样它不会变成第三种排序口径。
|
|
1150
|
+
|
|
1151
|
+
⚠️ 与既有的「固定 / 排除」(`control.*`,宿主存储 `knit_control`)**不是同一件事**:
|
|
1152
|
+
那一套只服务三层 Context Pack,媒体不参与,媒体卡片上也没有那个入口。
|
|
1153
|
+
*/
|
|
1154
|
+
|
|
1155
|
+
/** 落盘的键。值形如 `{ "<root>": ["a.png", "b.mp4"] }`。 */
|
|
1156
|
+
const FAV_KEY = 'dsh-knit:favorites'
|
|
1157
|
+
/** 最多记几个工作区(换项目时旧的不会无限长)。 */
|
|
1158
|
+
const FAV_MAX_ROOTS = 5
|
|
1159
|
+
/** 每个工作区最多记几条(超了按写入顺序截断,不做 LRU)。 */
|
|
1160
|
+
const FAV_MAX_RELS = 200
|
|
1161
|
+
|
|
1162
|
+
/**
|
|
1163
|
+
* 把落盘的值解析成 `{ [root]: string[] }`。
|
|
1164
|
+
*
|
|
1165
|
+
* 畸形输入一律回空表,**不许抛** —— localStorage 里的东西可能是上一版、手改过的、
|
|
1166
|
+
* 或者干脆是别的插件写坏的;这里坏了不能让整个面板白掉。
|
|
1167
|
+
*
|
|
1168
|
+
* @param {string|null} raw - localStorage 里的原始字符串
|
|
1169
|
+
* @returns {Object<string, string[]>} 归一化后的表
|
|
1170
|
+
*/
|
|
1171
|
+
function parseFavorites(raw) {
|
|
1172
|
+
if (typeof raw !== 'string' || !raw) return {}
|
|
1173
|
+
let data = null
|
|
1174
|
+
try { data = JSON.parse(raw) } catch { return {} }
|
|
1175
|
+
if (!data || typeof data !== 'object' || Array.isArray(data)) return {}
|
|
1176
|
+
const out = {}
|
|
1177
|
+
for (const root of Object.keys(data)) {
|
|
1178
|
+
const list = data[root]
|
|
1179
|
+
if (!Array.isArray(list)) continue
|
|
1180
|
+
const rels = []
|
|
1181
|
+
for (const rel of list) {
|
|
1182
|
+
if (typeof rel === 'string' && rel && rels.indexOf(rel) < 0) rels.push(rel)
|
|
1183
|
+
if (rels.length >= FAV_MAX_RELS) break
|
|
1184
|
+
}
|
|
1185
|
+
if (rels.length) out[root] = rels
|
|
1186
|
+
}
|
|
1187
|
+
return out
|
|
1188
|
+
}
|
|
1189
|
+
|
|
1190
|
+
/**
|
|
1191
|
+
* 某个工作区下的收藏。
|
|
1192
|
+
* @param {Object<string, string[]>} table - `parseFavorites()` 的产物
|
|
1193
|
+
* @param {string} root - 工作区根(未知时回空数组)
|
|
1194
|
+
* @returns {string[]} 副本
|
|
1195
|
+
*/
|
|
1196
|
+
function favoriteRelsFor(table, root) {
|
|
1197
|
+
const key = typeof root === 'string' ? root : ''
|
|
1198
|
+
if (!key || !table || !Array.isArray(table[key])) return []
|
|
1199
|
+
return table[key].slice()
|
|
1200
|
+
}
|
|
1201
|
+
|
|
1202
|
+
/**
|
|
1203
|
+
* 加 / 取消一条收藏,返回**新数组**(不改入参)。
|
|
1204
|
+
* 新加的排到最前 —— 同一次会话里立即可见,不用等重新排序。
|
|
1205
|
+
*
|
|
1206
|
+
* @param {string[]} rels - 当前收藏
|
|
1207
|
+
* @param {string} rel - 目标
|
|
1208
|
+
* @returns {string[]} 新数组
|
|
1209
|
+
*/
|
|
1210
|
+
function toggleFavoriteList(rels, rel) {
|
|
1211
|
+
const list = Array.isArray(rels) ? rels.slice() : []
|
|
1212
|
+
if (typeof rel !== 'string' || !rel) return list
|
|
1213
|
+
const at = list.indexOf(rel)
|
|
1214
|
+
if (at >= 0) { list.splice(at, 1); return list }
|
|
1215
|
+
list.unshift(rel)
|
|
1216
|
+
return list.slice(0, FAV_MAX_RELS)
|
|
1217
|
+
}
|
|
1218
|
+
|
|
1219
|
+
/**
|
|
1220
|
+
* 收藏的排到最前(**稳定**:两组内部都保持入参顺序)。
|
|
1221
|
+
* 没有收藏时**原样返回同一个数组**(同一引用,省一次无意义的重渲染)。
|
|
1222
|
+
*
|
|
1223
|
+
* @param {object[]} docs - 当前可见条目
|
|
1224
|
+
* @param {Set<string>|string[]} favorites - 收藏的 rel
|
|
1225
|
+
* @returns {object[]} 排好序的数组(或原数组)
|
|
1226
|
+
*/
|
|
1227
|
+
function orderFavorites(docs, favorites) {
|
|
1228
|
+
const list = Array.isArray(docs) ? docs : []
|
|
1229
|
+
const has = (rel) => (favorites instanceof Set
|
|
1230
|
+
? favorites.has(rel)
|
|
1231
|
+
: (Array.isArray(favorites) && favorites.indexOf(rel) >= 0))
|
|
1232
|
+
if (!list.length) return list
|
|
1233
|
+
const first = []
|
|
1234
|
+
const rest = []
|
|
1235
|
+
for (const doc of list) {
|
|
1236
|
+
if (doc && has(doc.rel)) first.push(doc)
|
|
1237
|
+
else rest.push(doc)
|
|
1238
|
+
}
|
|
1239
|
+
return first.length ? first.concat(rest) : list
|
|
1240
|
+
}
|
|
1241
|
+
|
|
929
1242
|
function mediaLayoutFor(width) {
|
|
930
1243
|
const w = Number(width)
|
|
931
1244
|
const usable = Number.isFinite(w) && w > 0 ? w : MEDIA_FALLBACK_WIDTH
|
|
@@ -968,6 +1281,7 @@ window.__ModuleLoader__.load({
|
|
|
968
1281
|
/* 「命中段」那一格要一个**灰底**而不是白描边(2026-10-07 用户裁决,原话是
|
|
969
1282
|
「叫它寻一个背景就行了,寻灰背景就行了,不需要在背景填充外面再加一个白色的描边」)。 */
|
|
970
1283
|
--knit-chip-bg:rgba(38,49,72,.092); /* 官方 10.20% × 0.90 */
|
|
1284
|
+
|
|
971
1285
|
display:flex;flex-direction:column;height:100%;min-height:0;
|
|
972
1286
|
color:var(--dsw-alias-label-primary,#e8eaed);font-size:13px}
|
|
973
1287
|
body[data-ds-dark-theme] .knit-root{
|
|
@@ -1107,6 +1421,21 @@ body[data-ds-dark-theme] .knit-root{
|
|
|
1107
1421
|
.knit-pipe-method:hover .knit-pipe-method-label,
|
|
1108
1422
|
.knit-pipe-method:focus-visible .knit-pipe-method-label{text-decoration:underline}
|
|
1109
1423
|
.knit-pipe-method[aria-expanded="true"]{color:var(--dsw-alias-label-primary,#e8eaed)}
|
|
1424
|
+
/* v0.25:Git 变更关联那一格。**与检索方式复用同一份视觉语言**(同 --knit-chip-bg、同圆角 6px、
|
|
1425
|
+
同内边距 1px 6px、同字号 11px / 行高 15px),但它是个**二态开关**:没有菜单、没有箭头。
|
|
1426
|
+
开态只把字色提到主文本色(属性选择器 aria-pressed=true)—— **不换底色、不用品牌色**,
|
|
1427
|
+
与检索方式「展开态」那条规则同一个手法:同一行里同类物,靠字重/字色分层,不靠颜色。
|
|
1428
|
+
⚠️ 尾随的 › 在检索方式那边才画;这一格没有箭头,所以下划线直接给文字层即可。 */
|
|
1429
|
+
.knit-pipe-changes{display:inline-flex;align-items:center;flex:none;white-space:nowrap;cursor:pointer;
|
|
1430
|
+
padding:1px 6px;border:0;outline:none;border-radius:6px;
|
|
1431
|
+
background:var(--knit-chip-bg,rgba(255,255,255,.12));
|
|
1432
|
+
font:inherit;font-size:11px;line-height:15px;
|
|
1433
|
+
color:var(--dsw-alias-label-secondary,#61666b);transition:color .14s ease}
|
|
1434
|
+
.knit-pipe-changes:hover,.knit-pipe-changes:focus-visible{color:var(--dsw-alias-label-primary,#e8eaed)}
|
|
1435
|
+
.knit-pipe-changes:hover .knit-pipe-changes-label,
|
|
1436
|
+
.knit-pipe-changes:focus-visible .knit-pipe-changes-label{text-decoration:underline}
|
|
1437
|
+
.knit-pipe-changes[aria-pressed="true"]{color:var(--dsw-alias-label-primary,#e8eaed)}
|
|
1438
|
+
@media (prefers-reduced-motion:reduce){.knit-pipe-changes{transition:none}}
|
|
1110
1439
|
/* 箭头:与「最近读取」行最右端那个 › 同一套视觉语言(同字形),基础态旋转 90° 变成「朝下」。
|
|
1111
1440
|
⚠️ 展开态用 **横向翻转 scaleX(-1)**,不是对调角度、也不是 scaleY(-1)(2026-10-13 用户裁决:
|
|
1112
1441
|
「修改成横向翻转……默认箭头向下,交互展开箭头向上」)。
|
|
@@ -1578,6 +1907,51 @@ button.knit-why:hover,button.knit-why:focus-visible{color:var(--dsw-alias-label-
|
|
|
1578
1907
|
.knit-notice{margin:6px 8px 0;padding:7px 10px;border-radius:7px;font-size:11px;line-height:1.5;
|
|
1579
1908
|
background:rgba(255,120,120,.12);border:.5px solid rgba(255,120,120,.3);color:#ffb4b4}
|
|
1580
1909
|
.knit-badge{font-size:10px;margin-right:3px}
|
|
1910
|
+
/* v0.25 媒体收藏:★ 是**状态标记**,所以吃品牌色(与聚焦圈 / 分区「查看全部」同一档);
|
|
1911
|
+
只在**名字行里**占一个字形的位置,不上缩略图、不加底色、不做 hover —— 网格不许长出第二套 chrome。 */
|
|
1912
|
+
.knit-fav{font-size:10px;margin-right:3px;color:var(--knit-accent)}
|
|
1913
|
+
/* v0.25:对话里生成的图 —— 标记用**文字**(承担信息:还没存进项目、存进去就消失)。
|
|
1914
|
+
字色取次级灰:它不是层级,是来源说明,不该抢过 ★。 */
|
|
1915
|
+
.knit-conv{font-size:10px;margin-right:3px;color:var(--dsw-alias-label-caption,#80868b)}
|
|
1916
|
+
/* v0.25 媒体档「悬停看大图」—— 与入口浮窗同一套外框(圆角 / 阴影 / 边框 / 层级)。
|
|
1917
|
+
⚠️ pointer-events:none 是必须的:它只是看一眼,绝不许挡住卡片的点击。
|
|
1918
|
+
尺寸由 JS 下发(上限 800,按可用空间收缩),这里只负责「图在盒子里等比铺满」。 */
|
|
1919
|
+
.knit-shot{position:fixed;z-index:60;display:flex;align-items:center;justify-content:center;
|
|
1920
|
+
padding:6px;border-radius:12px;pointer-events:none;
|
|
1921
|
+
background:var(--dsw-alias-bg-layer-2,#2c2c2e);
|
|
1922
|
+
border:.5px solid var(--dsw-alias-border-l4,rgba(255,255,255,.12));
|
|
1923
|
+
box-shadow:0 12px 32px rgba(0,0,0,.32)}
|
|
1924
|
+
.knit-shot img{display:block;max-width:100%;max-height:100%;border-radius:8px;object-fit:contain}
|
|
1925
|
+
/* v0.25 媒体档「双击全屏」:整窗遮罩 + 毛玻璃。层级在悬停浮窗(60)与菜单之上。
|
|
1926
|
+
左侧留 96px 给缩略图带(它绝对定位在遮罩里);图片按 contain 铺满剩下的区域。 */
|
|
1927
|
+
.knit-lightbox{position:fixed;inset:0;z-index:2147483000;display:flex;align-items:center;justify-content:center;
|
|
1928
|
+
padding:32px 32px 32px 96px;outline:none;cursor:zoom-out;
|
|
1929
|
+
/* ⚠️ 遮罩的 α 是**人眼定的**(与 box-shadow 同一性质,推不出来);两套值**必须不同**,
|
|
1930
|
+
否则「随深色模式变化」就是假话(有守卫)。
|
|
1931
|
+
⚠️ 这两个变量故意**挂在查看器自己身上** —— 它被 portal 到 document.body 之后
|
|
1932
|
+
不在 .knit-root 里了,读不到那层的变量(第一版就是这么静默变成透明遮罩的)。 */
|
|
1933
|
+
--knit-scrim:rgba(255,255,255,.62);
|
|
1934
|
+
background:var(--knit-scrim);backdrop-filter:blur(22px) saturate(1.1);
|
|
1935
|
+
-webkit-backdrop-filter:blur(22px) saturate(1.1)}
|
|
1936
|
+
body[data-ds-dark-theme] .knit-lightbox{--knit-scrim:rgba(18,18,20,.72)}
|
|
1937
|
+
.knit-lightbox-stage{flex:1 1 auto;min-width:0;min-height:0;display:flex;align-items:center;
|
|
1938
|
+
justify-content:center;cursor:default}
|
|
1939
|
+
.knit-lightbox-img{max-width:100%;max-height:100%;object-fit:contain;border-radius:10px;cursor:default;
|
|
1940
|
+
box-shadow:0 24px 64px rgba(0,0,0,.36);background:var(--dsw-alias-bg-base,#fff)}
|
|
1941
|
+
.knit-lightbox-tools{position:absolute;top:18px;right:62px;display:flex;align-items:center;gap:6px}
|
|
1942
|
+
.knit-lightbox-close{position:absolute;top:18px;right:18px;width:34px;height:34px;padding:0;
|
|
1943
|
+
display:flex;align-items:center;justify-content:center;border:0;border-radius:10px;
|
|
1944
|
+
cursor:pointer;font-family:inherit;font-size:15px;line-height:1;
|
|
1945
|
+
color:var(--dsw-alias-label-primary,#0f1115);background:transparent;opacity:.7}
|
|
1946
|
+
.knit-lightbox-close:hover{opacity:1;background:var(--knit-hover-bg,transparent)}
|
|
1947
|
+
.knit-lightbox-rail{position:absolute;left:10px;top:50%;transform:translateY(-50%);display:flex;
|
|
1948
|
+
flex-direction:column;gap:6px;max-height:88vh;overflow-y:auto;padding:4px;cursor:default}
|
|
1949
|
+
.knit-lightbox-thumb{flex:none;width:64px;height:64px;padding:0;border:0;border-radius:8px;overflow:hidden;
|
|
1950
|
+
cursor:pointer;background:transparent;opacity:.68;transition:opacity .16s ease}
|
|
1951
|
+
.knit-lightbox-thumb img{width:100%;height:100%;object-fit:cover;display:block}
|
|
1952
|
+
.knit-lightbox-thumb:hover{opacity:1}
|
|
1953
|
+
.knit-lightbox-thumb.active{opacity:1;box-shadow:0 0 0 2px var(--knit-accent,var(--dsw-alias-brand-primary-new-colorprimary-new-color))}
|
|
1954
|
+
@media (prefers-reduced-motion: reduce){.knit-lightbox-thumb{transition:none}}
|
|
1581
1955
|
|
|
1582
1956
|
/* ── 列表下方的预览面板 ───────────────────────────────
|
|
1583
1957
|
要让人一眼看出「这是另一层,不是列表的续行」,靠**结构**而不是底色:
|
|
@@ -1694,6 +2068,26 @@ body[data-ds-dark-theme] .knit-preview{box-shadow:0 -8px 24px rgba(0,0,0,.38)}
|
|
|
1694
2068
|
一上一下两条细线把这一小块夹成了独立一截,用户的原话是「有点割裂」。
|
|
1695
2069
|
现在这一层不画任何横线,收紧的 padding 就是它的边界。
|
|
1696
2070
|
注意 CSS 里不要写反引号 —— 这段样式是模板字符串,一个反引号就会把它截断。 */
|
|
2071
|
+
/* v0.25 查找条:与 .knit-links 同一层(夹在头与正文之间,**不参与正文滚动**)。
|
|
2072
|
+
输入框直接复用工具栏那套(.knit-searchwrap + .knit-filter)—— 同一份视觉语言,不新造控件;
|
|
2073
|
+
这里只把它的最大宽度放开(查找条要占满一行)。
|
|
2074
|
+
⚠️ 注意:本段注释里不许出现反引号 —— 整个 CSS 在一个模板串里。 */
|
|
2075
|
+
.knit-findbar{flex:none;display:flex;align-items:center;gap:6px;padding:4px 12px 6px}
|
|
2076
|
+
.knit-findbar .knit-searchwrap{flex:1 1 auto;max-width:none}
|
|
2077
|
+
.knit-findcount{flex:none;font-size:11px;color:var(--dsw-alias-label-caption,#80868b);
|
|
2078
|
+
font-variant-numeric:tabular-nums}
|
|
2079
|
+
.knit-findnav{flex:none;width:22px;height:22px;border-radius:6px;cursor:pointer;
|
|
2080
|
+
display:inline-flex;align-items:center;justify-content:center;font-size:12px;
|
|
2081
|
+
background:transparent;border:none;color:var(--dsw-alias-label-secondary,#9aa0a6)}
|
|
2082
|
+
.knit-findnav:hover:not(:disabled){background:var(--knit-hover-bg,rgba(255,255,255,.03));
|
|
2083
|
+
color:var(--dsw-alias-label-primary,#e8eaed)}
|
|
2084
|
+
.knit-findnav:disabled{opacity:.4;cursor:default}
|
|
2085
|
+
/* 命中的样式 —— **只有底色**。没有 padding、没有 border、颜色继承 —— 一有内边距就会改变行高与折行,
|
|
2086
|
+
而代码预览的命中横带是按「滚动高度 ÷ 行数」算行高的,动了就会错位。
|
|
2087
|
+
两级灰阶建立层级(普通命中 = hover 那档,当前命中 = 命中段那档),不引入第二种颜色。 */
|
|
2088
|
+
mark.knit-find{background:var(--knit-hover-bg,rgba(255,255,255,.03));color:inherit;
|
|
2089
|
+
padding:0;border:0;border-radius:2px}
|
|
2090
|
+
mark.knit-find-current{background:var(--knit-chip-bg)}
|
|
1697
2091
|
.knit-links{flex:none;font-size:11px;color:var(--dsw-alias-label-secondary,#9aa0a6)}
|
|
1698
2092
|
.knit-links-state{padding:5px 12px;color:var(--dsw-alias-label-caption,#80868b)}
|
|
1699
2093
|
.knit-links-head{box-sizing:border-box;display:flex;align-items:center;gap:6px;width:100%;
|
|
@@ -1931,6 +2325,28 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
1931
2325
|
return readPref(RETRIEVAL_KEY) === 'hybrid' ? 'hybrid' : 'lexical'
|
|
1932
2326
|
}
|
|
1933
2327
|
|
|
2328
|
+
/**
|
|
2329
|
+
* 读「Git 变更关联」开关。**没写过、写坏了都是关** —— 默认值必须是「不动基础检索行为」那一个。
|
|
2330
|
+
* @returns {boolean} 是否开启
|
|
2331
|
+
*/
|
|
2332
|
+
function readChangesPref() {
|
|
2333
|
+
return readPref(CHANGES_KEY) === '1'
|
|
2334
|
+
}
|
|
2335
|
+
|
|
2336
|
+
/** 宿主给的 Git 原因码 → i18n 键(与 `semanticReasonKey` 同一条纪律:宿主只给码)。 */
|
|
2337
|
+
function changeReasonKey(reason) {
|
|
2338
|
+
if (reason === 'not-a-repo') return 'changes.reason.notARepo'
|
|
2339
|
+
if (reason === 'git-missing') return 'changes.reason.gitMissing'
|
|
2340
|
+
if (reason === 'timeout') return 'changes.reason.timeout'
|
|
2341
|
+
if (reason === 'output-too-large') return 'changes.reason.tooLarge'
|
|
2342
|
+
if (reason === 'failed-fatal') return 'changes.reason.failed'
|
|
2343
|
+
// v0.25 收尾:这一条**不是**宿主的原因码,而是客户端自己的 —— 独立接口那次请求本身
|
|
2344
|
+
// 失败(网络/解析异常、非 ok 响应)。「读不到 git」与「没问到」是两件事,不许都写成
|
|
2345
|
+
// 「原因未知」,否则用户分不清该去检查仓库还是该重试。
|
|
2346
|
+
if (reason === 'request') return 'changes.reason.request'
|
|
2347
|
+
return 'changes.reason.unknown'
|
|
2348
|
+
}
|
|
2349
|
+
|
|
1934
2350
|
/**
|
|
1935
2351
|
* provider 地址是不是**本机回环**。只有回环才敢说「内容不离开这台机器」;
|
|
1936
2352
|
* 其它(含空地址)一律按「会发送到你配置的服务」披露 —— 宁可说得重一点。
|
|
@@ -2147,6 +2563,20 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
2147
2563
|
return `${RAW_API}?sessionId=${encodeURIComponent(sessionId)}&rel=${encodeURIComponent(rel)}`
|
|
2148
2564
|
}
|
|
2149
2565
|
|
|
2566
|
+
/**
|
|
2567
|
+
* 对话里生成的图(v0.25)的字节地址。
|
|
2568
|
+
*
|
|
2569
|
+
* ⚠️ **只传 sha256 id,不传路径** —— 宿主那条路由只认 `sha256:<64 hex>`,而且只读
|
|
2570
|
+
* **本会话出现过**的 id。这不是硬凑的 URL 形状,是那条边界的全部:给不出路径就没有穿越。
|
|
2571
|
+
*
|
|
2572
|
+
* @param {string} sessionId - 会话 id
|
|
2573
|
+
* @param {string} id - `sha256:<64 hex>`
|
|
2574
|
+
* @returns {string} 同源地址
|
|
2575
|
+
*/
|
|
2576
|
+
function attachmentUrl(sessionId, id) {
|
|
2577
|
+
return `${ATTACH_RAW_API}?sessionId=${encodeURIComponent(sessionId)}&id=${encodeURIComponent(id)}`
|
|
2578
|
+
}
|
|
2579
|
+
|
|
2150
2580
|
/**
|
|
2151
2581
|
* 秒 → `m:ss` / `h:mm:ss`,用于视频时长角标。
|
|
2152
2582
|
* @param {number} seconds - 秒
|
|
@@ -2166,6 +2596,81 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
2166
2596
|
return !!doc && (doc.kind === 'image' || doc.kind === 'video')
|
|
2167
2597
|
}
|
|
2168
2598
|
|
|
2599
|
+
/**
|
|
2600
|
+
* v0.25 收尾:把独立接口那份载荷归成**三种状态之一**(状态行与列表提示共用同一个判断)。
|
|
2601
|
+
*
|
|
2602
|
+
* @param {object|null} data - `state.changes`
|
|
2603
|
+
* @returns {{read: boolean, reason: string|null, filesTotal: number, hasRows: boolean}}
|
|
2604
|
+
* `read=false` ⇒ 读不到(接口失败或 git 读不到),`reason` 是给用户看的原因码;
|
|
2605
|
+
* `read=true` ⇒ 拿到了 git 事实,`filesTotal` 是变更文件数。
|
|
2606
|
+
*/
|
|
2607
|
+
function changeStatusOf(data) {
|
|
2608
|
+
if (!data) return { read: false, reason: null, filesTotal: 0 }
|
|
2609
|
+
if (data.failed === true) return { read: false, reason: data.reason || 'request', filesTotal: 0 }
|
|
2610
|
+
const git = data.git || null
|
|
2611
|
+
if (!git || git.available !== true) {
|
|
2612
|
+
return { read: false, reason: (git && git.reason) || 'unknown', filesTotal: 0 }
|
|
2613
|
+
}
|
|
2614
|
+
return { read: true, reason: null, filesTotal: Number(git.filesTotal) || 0 }
|
|
2615
|
+
}
|
|
2616
|
+
|
|
2617
|
+
/**
|
|
2618
|
+
* v0.25:`/knit/api/changes` 的**专用结构** → 列表行(只做形状映射,不做判断)。
|
|
2619
|
+
*
|
|
2620
|
+
* 宿主给的是「变更起点 / 关联目标 / 关系类型 / 行号」这套事实;这里把它摊成与列表行
|
|
2621
|
+
* 同形状的一层,好让**既有那套行渲染 + 证据弹层**直接用上(零第二条渲染路径)。
|
|
2622
|
+
* 两个刻意的决定:
|
|
2623
|
+
* · `provenance: 'change'` 是**客户端自己**给这一区贴的来源词(宿主的结构里没有这个词),
|
|
2624
|
+
* 只决定行右端那个「变更关联」;**不给 `reason`** —— 见下面那段说明;
|
|
2625
|
+
* · 证据行映射回 `{type, dir, other: 起点, line}`:`other` = 那个被改过的文件,
|
|
2626
|
+
* 与 v0.21 的行级证据**逐字同源**,所以弹层里「谁 · 什么 · 第几行」照旧可读。
|
|
2627
|
+
*
|
|
2628
|
+
* @param {object|null} data - `/knit/api/changes` 的载荷
|
|
2629
|
+
* @returns {Array<object>} 行(没有数据 ⇒ 空数组,调用方据此不渲染这一区)
|
|
2630
|
+
*/
|
|
2631
|
+
function changeRowsOf(data) {
|
|
2632
|
+
const links = (data && Array.isArray(data.links)) ? data.links : []
|
|
2633
|
+
return links.map((link) => ({
|
|
2634
|
+
rel: link.target,
|
|
2635
|
+
title: link.title || link.target,
|
|
2636
|
+
summary: link.summary || '',
|
|
2637
|
+
mtimeMs: link.mtimeMs,
|
|
2638
|
+
kind: link.kind,
|
|
2639
|
+
source: link.source,
|
|
2640
|
+
provenance: 'change',
|
|
2641
|
+
// ⚠️ **刻意不给 `reason`**(v0.25 收尾):`changeRelated` 那个理由码曾经让宿主
|
|
2642
|
+
// 「声明了一个自己不再产出」的码。现在「为什么在这一区」由**区标题 + 提示句**回答
|
|
2643
|
+
// (「变更关联 / 由未提交的改动牵出」),每一行的**具体依据**在证据弹层里
|
|
2644
|
+
// (类型 + 起点 + 行号)—— 行级渲染本来就不给没有 reason 的条目出那一行。
|
|
2645
|
+
relations: (Array.isArray(link.evidence) ? link.evidence : []).map((e) => ({
|
|
2646
|
+
type: e.type,
|
|
2647
|
+
dir: e.dir,
|
|
2648
|
+
other: e.origin,
|
|
2649
|
+
// `line` 是 `null` 时**不给这个键** —— 弹层据此说「文件名约定,没行号」
|
|
2650
|
+
...(Number.isInteger(e.line) ? { line: e.line } : {}),
|
|
2651
|
+
})),
|
|
2652
|
+
...(Number.isInteger(link.evidenceTotal) && link.evidenceTotal > (Array.isArray(link.evidence) ? link.evidence.length : 0)
|
|
2653
|
+
? { relationsTotal: link.evidenceTotal } : {}),
|
|
2654
|
+
}))
|
|
2655
|
+
}
|
|
2656
|
+
|
|
2657
|
+
/**
|
|
2658
|
+
* 一个条目符不符合过滤框里的那串字(标题 / 摘要 / 相对路径)。
|
|
2659
|
+
*
|
|
2660
|
+
* v0.25 抽出来的:`visibleDocs`(列表那一份)与「变更关联」区都要用同一条判据 ——
|
|
2661
|
+
* 用户在搜索框里打了字,两处都该跟着收窄,而**两处都不许**各自写一份。
|
|
2662
|
+
*
|
|
2663
|
+
* @param {object} doc - 条目(面板条目或宿主给的记录)
|
|
2664
|
+
* @param {string} q - 已经 trim + toLowerCase 过的查询串;空串表示不过滤
|
|
2665
|
+
* @returns {boolean}
|
|
2666
|
+
*/
|
|
2667
|
+
function docMatchesQuery(doc, q) {
|
|
2668
|
+
if (!q) return true
|
|
2669
|
+
return String(doc.title || '').toLowerCase().includes(q)
|
|
2670
|
+
|| String(doc.summary || '').toLowerCase().includes(q)
|
|
2671
|
+
|| String(doc.rel || '').toLowerCase().includes(q)
|
|
2672
|
+
}
|
|
2673
|
+
|
|
2169
2674
|
/**
|
|
2170
2675
|
* 命中片段的**行号区间**文本(v0.20,需求 §11 / §12)。
|
|
2171
2676
|
*
|
|
@@ -2983,7 +3488,7 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
2983
3488
|
* @param {object} props - 与 DocRow 同构,外加 src
|
|
2984
3489
|
* @returns {import('react').ReactElement} 元素
|
|
2985
3490
|
*/
|
|
2986
|
-
function MediaCard({ doc, now, active, cursor, src, onSelect, onOpenTab, optionId }) {
|
|
3491
|
+
function MediaCard({ doc, now, active, cursor, src, onSelect, onOpenTab, onZoom, onPreview, optionId, favorite, conversation, onHoverStart, onHoverEnd }) {
|
|
2987
3492
|
const fresh = now - doc.mtimeMs < NEW_WINDOW_MS
|
|
2988
3493
|
return h('div', {
|
|
2989
3494
|
className: `knit-media-card${active ? ' active' : ''}${cursor ? ' cursor' : ''}${fresh ? ' fresh' : ''}`,
|
|
@@ -2992,13 +3497,29 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
2992
3497
|
id: optionId,
|
|
2993
3498
|
'aria-selected': active ? 'true' : 'false',
|
|
2994
3499
|
'data-knit-rel': doc.rel,
|
|
2995
|
-
|
|
3500
|
+
// v0.25:对话里生成的图没有工作区路径 —— 提示语换成「还没保存到本地」
|
|
3501
|
+
title: conversation ? t('attach.title') : t('row.tooltip', { path: doc.rel }),
|
|
2996
3502
|
onClick: () => onSelect(doc),
|
|
2997
|
-
|
|
3503
|
+
/* v0.25(2026-10-22 用户裁决):媒体档**取消单击就地预览** —— 双击才是「看」。
|
|
3504
|
+
按类型分流:
|
|
3505
|
+
· 图片 → 全屏查看器(`onZoom`,里面自带收藏 / 本地打开);
|
|
3506
|
+
· 视频 → **仍走就地预览**(`onPreview`):查看器只做图片,不这么走的话
|
|
3507
|
+
播放器、收藏、本地打开就全没了入口。 */
|
|
3508
|
+
onDoubleClick: () => (doc.kind === 'image'
|
|
3509
|
+
? (onZoom && onZoom(doc))
|
|
3510
|
+
: (onPreview ? onPreview(doc) : onOpenTab(doc))),
|
|
3511
|
+
// v0.25:悬停看大图(只对图片;视频交给点击预览)。事件里带矩形,几何在纯函数里算。
|
|
3512
|
+
onMouseEnter: onHoverStart ? (event) => onHoverStart(doc, src, event) : undefined,
|
|
3513
|
+
onMouseLeave: onHoverEnd || undefined,
|
|
2998
3514
|
},
|
|
2999
3515
|
h('div', { className: 'knit-media-thumbbox' }, h(MediaThumb, { doc, src })),
|
|
3000
3516
|
h('div', { className: 'knit-media-meta' },
|
|
3001
3517
|
h('div', { className: 'knit-media-name', title: doc.name },
|
|
3518
|
+
// v0.25:对话里生成的图带一个「对话」标记 —— 它解释两件事:这张还没存进项目、
|
|
3519
|
+
// 存进去之后它会自己消失(去重规则)。用文字不用图标:它承担信息。
|
|
3520
|
+
conversation ? h('span', { className: 'knit-conv' }, t('attach.badge')) : null,
|
|
3521
|
+
// v0.25 媒体收藏:★ 是**状态标记**(不是装饰)—— 它解释「这张为什么排在最前面」
|
|
3522
|
+
favorite ? h('span', { className: 'knit-fav', title: t('fav.mark'), 'aria-label': t('fav.mark') }, '★') : null,
|
|
3002
3523
|
fresh ? h('span', { className: 'knit-badge' }, '🆕') : null,
|
|
3003
3524
|
doc.name),
|
|
3004
3525
|
h('div', { className: 'knit-media-time' }, relTime(doc.mtimeMs, now))))
|
|
@@ -3347,6 +3868,214 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3347
3868
|
return true
|
|
3348
3869
|
}
|
|
3349
3870
|
|
|
3871
|
+
/* ── v0.25:预览里的「查找」(Cmd+F)───────────────────────────────────
|
|
3872
|
+
用户要的是「像 Chrome 那样在文档里搜关键词并定位」。三条房规决定了它长什么样:
|
|
3873
|
+
|
|
3874
|
+
① **不自己渲染 Markdown**(见 DocPane 那条注释:那会变成第二套渲染器)
|
|
3875
|
+
⇒ 与 `docAnchorHit` 同一套办法:渲染完成后走 TreeWalker,在**已经渲染出来的文本**上找。
|
|
3876
|
+
② **匹配是纯函数**,DOM 那一层只负责画。测试替身没有 document,所以能被真断言钉住的
|
|
3877
|
+
只有纯函数那一半 —— 这是刻意的分工,与 `docAnchorNeedles`(纯)/
|
|
3878
|
+
`docAnchorHit`(DOM)那条已有的分界线一致。
|
|
3879
|
+
③ **命中只上底色,绝不动几何**:`mark` 不许有 padding / border,也不许改行高
|
|
3880
|
+
—— 代码预览的命中横带是按「滚动高度 ÷ 行数」算行高的,动了就会错位。
|
|
3881
|
+
|
|
3882
|
+
⚠️ 已知边界(与既有锚点定位同一条):命中**不跨文本节点**。渲染会把 `**粗**字`
|
|
3883
|
+
拆成两个节点,所以正好被 Markdown 语法截断的关键词(一半在「粗」左边、一半在右边)找不到。
|
|
3884
|
+
跨节点要额外把「归一化后的下标」分别映射回两个节点的原文下标,代价与收益不成比例。
|
|
3885
|
+
`preview.truncated` 那句「仅预览前 512 KB」不算文档内容,跳过不搜。
|
|
3886
|
+
*/
|
|
3887
|
+
|
|
3888
|
+
/**
|
|
3889
|
+
* 在一段文本里找出**所有**字面量命中。
|
|
3890
|
+
*
|
|
3891
|
+
* - **字面量,不是正则**:输入 `(`、`*`、`[` 时必须原样找 —— 既不许当元字符,也不许抛
|
|
3892
|
+
* (用户搜的是关键词,不是模式)。
|
|
3893
|
+
* - **不重叠、按出现顺序**(与 Chrome 的计数口径一致)。
|
|
3894
|
+
* - **大小写不敏感,但只在折叠后长度不变时才用折叠串**:少数 Unicode 字符折叠后会**变长**
|
|
3895
|
+
* (如 `İ`),那样下标就与原文错位、画出来的命中会偏一格。这种输入退回大小写敏感 ——
|
|
3896
|
+
* 宁可少匹配几个,也不许标错位置。
|
|
3897
|
+
*
|
|
3898
|
+
* @param {string} haystack - 被搜的文本
|
|
3899
|
+
* @param {string} query - 关键词
|
|
3900
|
+
* @returns {{start:number,end:number}[]} 命中区间(原文下标,左闭右开)
|
|
3901
|
+
*/
|
|
3902
|
+
function findRanges(haystack, query) {
|
|
3903
|
+
const text = typeof haystack === 'string' ? haystack : ''
|
|
3904
|
+
const needle = typeof query === 'string' ? query : ''
|
|
3905
|
+
if (!text || !needle) return []
|
|
3906
|
+
const foldedText = text.toLowerCase()
|
|
3907
|
+
const foldedNeedle = needle.toLowerCase()
|
|
3908
|
+
const foldable = foldedText.length === text.length && foldedNeedle.length === needle.length
|
|
3909
|
+
const hay = foldable ? foldedText : text
|
|
3910
|
+
const pin = foldable ? foldedNeedle : needle
|
|
3911
|
+
const out = []
|
|
3912
|
+
let from = 0
|
|
3913
|
+
for (;;) {
|
|
3914
|
+
const at = hay.indexOf(pin, from)
|
|
3915
|
+
if (at < 0) break
|
|
3916
|
+
out.push({ start: at, end: at + pin.length })
|
|
3917
|
+
from = at + pin.length
|
|
3918
|
+
}
|
|
3919
|
+
return out
|
|
3920
|
+
}
|
|
3921
|
+
|
|
3922
|
+
/**
|
|
3923
|
+
* 归一化文本的**下标 → 原文下标**映射。
|
|
3924
|
+
*
|
|
3925
|
+
* 搜索要先把换行折叠成空格再找(渲染出来的文本就是这样,不折叠就对不上),
|
|
3926
|
+
* 但**画的时候必须切原文** —— 所以需要这座桥:返回数组第 i 项 = 归一化文本第 i 个字符
|
|
3927
|
+
* 在原文里的下标。归一化规则与 `docAnchorHit` 逐字同一条:一串空白 → 一个空格。
|
|
3928
|
+
*
|
|
3929
|
+
* @param {string} original - 原文
|
|
3930
|
+
* @returns {number[]} 映射(长度 == 归一化后的长度)
|
|
3931
|
+
*/
|
|
3932
|
+
function normalizedIndexMap(original) {
|
|
3933
|
+
const text = typeof original === 'string' ? original : ''
|
|
3934
|
+
const map = []
|
|
3935
|
+
let i = 0
|
|
3936
|
+
while (i < text.length) {
|
|
3937
|
+
map.push(i)
|
|
3938
|
+
const isSpace = /\s/.test(text[i])
|
|
3939
|
+
i += 1
|
|
3940
|
+
if (isSpace) while (i < text.length && /\s/.test(text[i])) i += 1
|
|
3941
|
+
}
|
|
3942
|
+
return map
|
|
3943
|
+
}
|
|
3944
|
+
|
|
3945
|
+
/**
|
|
3946
|
+
* 下一个命中下标(**环绕**,与 Chrome 一致:最后一个再按「下一个」回到第一个)。
|
|
3947
|
+
*
|
|
3948
|
+
* @param {number} current - 当前下标
|
|
3949
|
+
* @param {number} total - 命中总数
|
|
3950
|
+
* @param {number} delta - 方向(负数 = 上一个)
|
|
3951
|
+
* @returns {number} 新下标(total 为 0 时恒 0)
|
|
3952
|
+
*/
|
|
3953
|
+
function stepFindIndex(current, total, delta) {
|
|
3954
|
+
if (!(total > 0)) return 0
|
|
3955
|
+
const at = Number.isFinite(current) ? Math.min(Math.max(0, Math.round(current)), total - 1) : 0
|
|
3956
|
+
const next = (at + (delta < 0 ? -1 : 1)) % total
|
|
3957
|
+
return next < 0 ? next + total : next
|
|
3958
|
+
}
|
|
3959
|
+
|
|
3960
|
+
/** 查找时跳过的子树:`preview.truncated` 那句提示不是文档内容。 */
|
|
3961
|
+
function findSkippedNode(node) {
|
|
3962
|
+
let el = node && node.parentNode
|
|
3963
|
+
while (el && el.nodeType === 1) {
|
|
3964
|
+
if (String(el.className || '').indexOf('knit-preview-note') >= 0) return true
|
|
3965
|
+
el = el.parentNode
|
|
3966
|
+
}
|
|
3967
|
+
return false
|
|
3968
|
+
}
|
|
3969
|
+
|
|
3970
|
+
/**
|
|
3971
|
+
* 把命中画成 `mark.knit-find`,返回**按文档顺序**的命中元素。
|
|
3972
|
+
*
|
|
3973
|
+
* 一个文本节点里可能有多个命中 —— 先把该节点切成「文本 + mark + 文本…」再整体替换它,
|
|
3974
|
+
* 所以顺序天然是对的;`insertBefore` 逐片插在旧节点前面、最后删掉旧节点。
|
|
3975
|
+
* 没有 document(测试替身)时**静默返回空数组** —— 与 `scrollToDocAnchor` 同一层守卫。
|
|
3976
|
+
*
|
|
3977
|
+
* @param {HTMLElement|null} box - 正文容器
|
|
3978
|
+
* @param {string} query - 关键词
|
|
3979
|
+
* @returns {HTMLElement[]} 命中元素(文档顺序)
|
|
3980
|
+
*/
|
|
3981
|
+
function paintFindMarks(box, query) {
|
|
3982
|
+
if (!box || typeof document === 'undefined' || typeof document.createTreeWalker !== 'function') return []
|
|
3983
|
+
if (typeof document.createElement !== 'function' || !query) return []
|
|
3984
|
+
const walker = document.createTreeWalker(box, 4) // 4 = SHOW_TEXT
|
|
3985
|
+
const targets = []
|
|
3986
|
+
let node = walker.nextNode()
|
|
3987
|
+
while (node) {
|
|
3988
|
+
const value = String(node.nodeValue || '')
|
|
3989
|
+
if (value && !findSkippedNode(node)) {
|
|
3990
|
+
const flat = value.replace(/\s+/g, ' ')
|
|
3991
|
+
const ranges = findRanges(flat, query)
|
|
3992
|
+
if (ranges.length && node.parentNode) {
|
|
3993
|
+
targets.push({ node, value, ranges, map: normalizedIndexMap(value) })
|
|
3994
|
+
}
|
|
3995
|
+
}
|
|
3996
|
+
node = walker.nextNode()
|
|
3997
|
+
}
|
|
3998
|
+
const marks = []
|
|
3999
|
+
for (const target of targets) {
|
|
4000
|
+
const pieces = []
|
|
4001
|
+
let at = 0
|
|
4002
|
+
for (const range of target.ranges) {
|
|
4003
|
+
const from = target.map[range.start]
|
|
4004
|
+
const to = range.end < target.map.length ? target.map[range.end] : target.value.length
|
|
4005
|
+
if (!(from >= at) || !(to > from)) continue
|
|
4006
|
+
if (from > at) pieces.push(document.createTextNode(target.value.slice(at, from)))
|
|
4007
|
+
const mark = document.createElement('mark')
|
|
4008
|
+
mark.className = 'knit-find'
|
|
4009
|
+
mark.textContent = target.value.slice(from, to)
|
|
4010
|
+
pieces.push(mark)
|
|
4011
|
+
marks.push(mark)
|
|
4012
|
+
at = to
|
|
4013
|
+
}
|
|
4014
|
+
if (!pieces.length) continue
|
|
4015
|
+
if (at < target.value.length) pieces.push(document.createTextNode(target.value.slice(at)))
|
|
4016
|
+
const parent = target.node.parentNode
|
|
4017
|
+
for (const piece of pieces) parent.insertBefore(piece, target.node)
|
|
4018
|
+
parent.removeChild(target.node)
|
|
4019
|
+
}
|
|
4020
|
+
return marks
|
|
4021
|
+
}
|
|
4022
|
+
|
|
4023
|
+
/**
|
|
4024
|
+
* 还原:把每个 `mark.knit-find` 换回纯文本节点,再把相邻文本节点合并。
|
|
4025
|
+
*
|
|
4026
|
+
* **必须还原得干净** —— 否则下一次画是在「已经画过的树」上再画一层,
|
|
4027
|
+
* 命中数会越算越多,而且退出查找后正文里永远留着标签。
|
|
4028
|
+
*
|
|
4029
|
+
* @param {HTMLElement|null} box - 正文容器
|
|
4030
|
+
* @returns {void}
|
|
4031
|
+
*/
|
|
4032
|
+
function clearFindMarks(box) {
|
|
4033
|
+
if (!box || typeof box.querySelectorAll !== 'function' || typeof document === 'undefined') return
|
|
4034
|
+
const marks = box.querySelectorAll('mark.knit-find')
|
|
4035
|
+
const parents = []
|
|
4036
|
+
for (let i = 0; i < marks.length; i += 1) {
|
|
4037
|
+
const mark = marks[i]
|
|
4038
|
+
const parent = mark.parentNode
|
|
4039
|
+
if (!parent) continue
|
|
4040
|
+
parent.replaceChild(document.createTextNode(String(mark.textContent || '')), mark)
|
|
4041
|
+
if (parents.indexOf(parent) < 0) parents.push(parent)
|
|
4042
|
+
}
|
|
4043
|
+
for (const parent of parents) if (typeof parent.normalize === 'function') parent.normalize()
|
|
4044
|
+
}
|
|
4045
|
+
|
|
4046
|
+
/** 标出「当前这一条命中」(其余保持普通底色)。 */
|
|
4047
|
+
function markFindCurrent(marks, index) {
|
|
4048
|
+
if (!Array.isArray(marks)) return
|
|
4049
|
+
for (let i = 0; i < marks.length; i += 1) {
|
|
4050
|
+
const el = marks[i]
|
|
4051
|
+
if (!el || !el.classList) continue
|
|
4052
|
+
if (i === index) el.classList.add('knit-find-current')
|
|
4053
|
+
else el.classList.remove('knit-find-current')
|
|
4054
|
+
}
|
|
4055
|
+
}
|
|
4056
|
+
|
|
4057
|
+
/**
|
|
4058
|
+
* 把当前命中滚进视野 —— 与 `scrollToDocAnchor` **同一套手动算术**。
|
|
4059
|
+
*
|
|
4060
|
+
* 刻意不用 `scrollIntoView`:那会连带滚外层容器与整个面板,长文里的位置会飘
|
|
4061
|
+
* (见 `scrollToDocAnchor` 那条注释,同一个坑)。这里滚的仍是 `.knit-preview-body`。
|
|
4062
|
+
* 位置取**居中**:逐个往下找时,命中停在视野中间最好读。
|
|
4063
|
+
*
|
|
4064
|
+
* @param {HTMLElement|null} mark - 当前命中的元素
|
|
4065
|
+
* @returns {boolean} 是否真的滚了
|
|
4066
|
+
*/
|
|
4067
|
+
function scrollMarkIntoView(mark) {
|
|
4068
|
+
if (!mark || typeof mark.getBoundingClientRect !== 'function') return false
|
|
4069
|
+
const box = typeof mark.closest === 'function' ? mark.closest('.knit-preview-body') : null
|
|
4070
|
+
if (!box || !Number.isFinite(box.scrollTop) || typeof box.getBoundingClientRect !== 'function') return false
|
|
4071
|
+
const rect = box.getBoundingClientRect()
|
|
4072
|
+
const delta = mark.getBoundingClientRect().top - rect.top
|
|
4073
|
+
const viewH = Number.isFinite(rect.height) ? rect.height : 0
|
|
4074
|
+
const target = box.scrollTop + delta - Math.max(0, viewH / 2 - 10)
|
|
4075
|
+
box.scrollTop = Math.max(0, Math.round(target))
|
|
4076
|
+
return true
|
|
4077
|
+
}
|
|
4078
|
+
|
|
3350
4079
|
/**
|
|
3351
4080
|
* Markdown 预览:在 `MarkdownText` 外面包一层,只为把「跳到你点的那一段」接上。
|
|
3352
4081
|
*
|
|
@@ -3504,7 +4233,14 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3504
4233
|
: null)
|
|
3505
4234
|
}
|
|
3506
4235
|
|
|
3507
|
-
|
|
4236
|
+
/**
|
|
4237
|
+
* 预览面板(头 + 引用条 + 正文)。
|
|
4238
|
+
*
|
|
4239
|
+
* @param {object} props - 渲染入参。
|
|
4240
|
+
* `find`(v0.25)= 查找条那一组:状态在 `KnitBody`(快捷键挂在面板根上,
|
|
4241
|
+
* 所以状态不能只活在这一层);`bodyRef` = 正文容器 ref,由 `KnitBody` 拿去做 DOM 命中绘制。
|
|
4242
|
+
*/
|
|
4243
|
+
function PreviewPanel({ preview, pathImages, fullscreen, ratio, links, linksExpanded, onToggleLinks, onOpenLink, onClose, onOpenLocal, onReveal, onOpenMap, onOpenWeb, onToggleFullscreen, onResizeStart, find, bodyRef, favorite, onToggleFavorite }) {
|
|
3508
4244
|
const isMedia = preview.kind === 'image' || preview.kind === 'video'
|
|
3509
4245
|
const previewPath = splitRelPath(preview.rel)
|
|
3510
4246
|
|
|
@@ -3569,6 +4305,51 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3569
4305
|
h('span', { className: 'knit-link-name' }, item.title),
|
|
3570
4306
|
h('span', { className: 'knit-link-path' }, item.rel))))))
|
|
3571
4307
|
|
|
4308
|
+
/* v0.25 查找条:位置与 `linksBar` 同一层(夹在头与正文之间,**不参与正文滚动**)。
|
|
4309
|
+
只在查找打开、且这篇有可搜正文(非媒体)时出现;它占的是预览内部的行高,
|
|
4310
|
+
预览的**外框高度是写死的**(style.height = 拖出来的比例)⇒ 列表不会被它推着动。 */
|
|
4311
|
+
const findBar = find && find.on && !isMedia
|
|
4312
|
+
? h('div', { className: 'knit-findbar' },
|
|
4313
|
+
h('div', { className: 'knit-searchwrap' },
|
|
4314
|
+
h('input', {
|
|
4315
|
+
// 第二个 class 是给测试与样式用的锚点:替身返回的是**扁平**节点表,
|
|
4316
|
+
// 没有父子关系可查,而工具栏那个过滤框也叫 .knit-filter —— 不区分就分不出谁是谁。
|
|
4317
|
+
className: 'knit-filter knit-findinput',
|
|
4318
|
+
ref: find.inputRef,
|
|
4319
|
+
value: find.query,
|
|
4320
|
+
placeholder: t('find.placeholder'),
|
|
4321
|
+
'aria-label': t('find.aria'),
|
|
4322
|
+
onChange: (event) => find.onQuery(event.target.value),
|
|
4323
|
+
onKeyDown: (event) => {
|
|
4324
|
+
if (event.key === 'Enter') {
|
|
4325
|
+
event.preventDefault()
|
|
4326
|
+
find.onStep(event.shiftKey ? -1 : 1)
|
|
4327
|
+
} else if (event.key === 'Escape') {
|
|
4328
|
+
// 双保险:根上的捕获阶段通常已经处理掉了(那里要抢在列表的 Esc 之前)
|
|
4329
|
+
event.stopPropagation()
|
|
4330
|
+
find.onClose()
|
|
4331
|
+
}
|
|
4332
|
+
},
|
|
4333
|
+
})),
|
|
4334
|
+
h('span', { className: 'knit-findcount', 'aria-live': 'polite' },
|
|
4335
|
+
!find.query
|
|
4336
|
+
? ''
|
|
4337
|
+
: (find.count > 0
|
|
4338
|
+
? t('find.count', { current: Math.min(find.index, find.count - 1) + 1, total: find.count })
|
|
4339
|
+
: t('find.none'))),
|
|
4340
|
+
h('button', {
|
|
4341
|
+
type: 'button', className: 'knit-findnav', title: t('find.prev'),
|
|
4342
|
+
disabled: find.count === 0, onClick: () => find.onStep(-1),
|
|
4343
|
+
}, '↑'),
|
|
4344
|
+
h('button', {
|
|
4345
|
+
type: 'button', className: 'knit-findnav', title: t('find.next'),
|
|
4346
|
+
disabled: find.count === 0, onClick: () => find.onStep(1),
|
|
4347
|
+
}, '↓'),
|
|
4348
|
+
h('button', {
|
|
4349
|
+
type: 'button', className: 'knit-preview-close', title: t('find.close'), onClick: find.onClose,
|
|
4350
|
+
}, '✕'))
|
|
4351
|
+
: null
|
|
4352
|
+
|
|
3572
4353
|
const linksBar = (() => {
|
|
3573
4354
|
if (!links || !onToggleLinks) return null
|
|
3574
4355
|
if (links.status === 'loading') {
|
|
@@ -3720,6 +4501,27 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3720
4501
|
onClick: onToggleFullscreen,
|
|
3721
4502
|
title: fullscreen ? t('preview.exitFullscreenTitle') : t('preview.fullscreenTitle'),
|
|
3722
4503
|
}, fullscreen ? t('preview.exitFullscreen') : t('preview.fullscreen')),
|
|
4504
|
+
// v0.25 媒体收藏:只给媒体档。
|
|
4505
|
+
// 「收藏」在文档 / 代码上是另一个概念(那是 Context Pack 的「固定」,宿主存储),
|
|
4506
|
+
// 这里不混用,也不给媒体做固定 —— 两套语义各自独立。
|
|
4507
|
+
isMedia && onToggleFavorite
|
|
4508
|
+
? h('button', {
|
|
4509
|
+
className: 'knit-btn',
|
|
4510
|
+
onClick: () => onToggleFavorite(preview.rel),
|
|
4511
|
+
title: favorite ? t('fav.removeTitle') : t('fav.addTitle'),
|
|
4512
|
+
}, favorite ? t('fav.on') : t('fav.off'))
|
|
4513
|
+
: null,
|
|
4514
|
+
// v0.25 追加:**查找**按钮。
|
|
4515
|
+
// 为什么除了快捷键还要有这个按钮:外层应用(飞书客户端的内置浏览器等)有自己的
|
|
4516
|
+
// 原生 Cmd+F,它在按键**进入网页之前**就被处理掉了 —— 网页侧抢不回来。
|
|
4517
|
+
// 所以能力必须有一个**不依赖快捷键**的入口。只给有正文的档:媒体档没有可搜的东西。
|
|
4518
|
+
!isMedia
|
|
4519
|
+
? h('button', {
|
|
4520
|
+
className: 'knit-btn',
|
|
4521
|
+
onClick: () => { if (find) find.onOpen() },
|
|
4522
|
+
title: t('find.openTitle'),
|
|
4523
|
+
}, t('find.openBtn'))
|
|
4524
|
+
: null,
|
|
3723
4525
|
// v0.19 追加:**网页预览** —— 只给 HTML。
|
|
3724
4526
|
// 它开的是官方文档预览标签页(`actions.openResource`,与双击列表行**同一条**路),
|
|
3725
4527
|
// 那一侧有 DSH 自带的 HTML 渲染器,出来的是**网页**而不是源码。
|
|
@@ -3750,8 +4552,11 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3750
4552
|
h('button', { className: 'knit-preview-close', onClick: onClose, title: t('preview.close') }, '✕')),
|
|
3751
4553
|
// v0.12 引用条:夹在头与正文之间,不参与正文滚动
|
|
3752
4554
|
linksBar,
|
|
4555
|
+
// v0.25 查找条:同上,也是「夹在头与正文之间」
|
|
4556
|
+
findBar,
|
|
3753
4557
|
h('div', {
|
|
3754
4558
|
className: `knit-preview-body${isMedia ? ' is-media' : ''}`,
|
|
4559
|
+
ref: bodyRef,
|
|
3755
4560
|
},
|
|
3756
4561
|
!isMedia && preview.truncated ? h('div', { className: 'knit-preview-note' }, t('preview.truncated')) : null,
|
|
3757
4562
|
body))
|
|
@@ -3818,6 +4623,16 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3818
4623
|
// v0.15「使用情况」的开闸状态(默认关,见 `USAGE_KEY`)。放在最后 —— 前几个 hook
|
|
3819
4624
|
// 的顺序被测试按位预置,别插队。
|
|
3820
4625
|
const [usageOn, setUsageOn] = React.useState(readUsagePref)
|
|
4626
|
+
/* v0.25:Git 变更关联开关。偏好记在 localStorage(与排序 / 类型 / 检索模式同一族),
|
|
4627
|
+
**默认关**。关着时请求里不带 `changes=1` ⇒ 宿主一个 git 进程都不 spawn。
|
|
4628
|
+
⚠️ **刻意声明在 `usageOn` 之后**:`test/client.test.mjs` 用**指数 seed** 来打开
|
|
4629
|
+
「使用情况」(hook 下标 15),插在它前面会把后面所有下标顶开一位。
|
|
4630
|
+
新 hook 一律往**末尾**追加,别插队。 */
|
|
4631
|
+
const [changesOn, setChangesOn] = React.useState(readChangesPref)
|
|
4632
|
+
/* v0.25(第二轮修订):变更关联来自**独立接口** `/knit/api/changes`,不再挂在
|
|
4633
|
+
`/api/recent` 的 `context` 上 —— 所以它有自己的状态槽。**必须追加在末尾**:
|
|
4634
|
+
前面的 hook 位置被 `test/client.test.mjs` 按位预置。 */
|
|
4635
|
+
const [changesData, setChangesData] = React.useState(null)
|
|
3821
4636
|
|
|
3822
4637
|
// v0.17:两个折叠块的开合状态(上下文外读取 / 最近一次变化)。
|
|
3823
4638
|
// **纯瞬时 UI 状态** —— 不写 pref、不进 `dsh-knit:*` 存储,刷新即回默认(收起)。
|
|
@@ -3838,6 +4653,59 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3838
4653
|
const [semBusy, setSemBusy] = React.useState(false)
|
|
3839
4654
|
const [semNotice, setSemNotice] = React.useState('')
|
|
3840
4655
|
|
|
4656
|
+
/* ── v0.25:对话里「工具产出」的图 ─────────────────────────────────────
|
|
4657
|
+
数据来自独立接口(只在本会话的 `tool/result` 事件里收集);**列表零 I/O**。
|
|
4658
|
+
它们**不在工作区里**,所以是这一档唯一「不是文件」的条目:
|
|
4659
|
+
· 已经在工作区里存在同内容文件(sha256 相同)的 ⇒ 宿主侧就过滤掉了,不重复出现;
|
|
4660
|
+
· 一旦你把图存进项目,下一次轮询它就自己消失 —— 这就是用户要的那条规则。 */
|
|
4661
|
+
const [attachments, setAttachments] = React.useState([])
|
|
4662
|
+
/** 附件 → 伪文档:让它走**同一条**网格渲染/预览/键盘路径,不新开一套。 */
|
|
4663
|
+
const attachmentDocs = React.useMemo(() => (Array.isArray(attachments) ? attachments : [])
|
|
4664
|
+
.slice()
|
|
4665
|
+
.sort((a, b) => (Number.isFinite(b.at) ? b.at : 0) - (Number.isFinite(a.at) ? a.at : 0))
|
|
4666
|
+
.map((item) => ({
|
|
4667
|
+
rel: item.id,
|
|
4668
|
+
name: item.name,
|
|
4669
|
+
title: item.name,
|
|
4670
|
+
path: '',
|
|
4671
|
+
kind: item.kind === 'video' ? 'video' : 'image',
|
|
4672
|
+
mtimeMs: Number.isFinite(item.at) ? item.at : Date.now(),
|
|
4673
|
+
size: Number.isFinite(item.bytes) ? item.bytes : 0,
|
|
4674
|
+
summary: '',
|
|
4675
|
+
score: null,
|
|
4676
|
+
attachmentId: item.id,
|
|
4677
|
+
conversation: true,
|
|
4678
|
+
})), [attachments])
|
|
4679
|
+
|
|
4680
|
+
/* ── v0.25:媒体收藏(同样**追加在末尾**:替身按下标 seed useState/useRef)──────
|
|
4681
|
+
只存 localStorage;工作区换了就重读那一格。写入时只保留最近 FAV_MAX_ROOTS 个工作区。 */
|
|
4682
|
+
const [favorites, setFavorites] = React.useState([])
|
|
4683
|
+
React.useEffect(() => {
|
|
4684
|
+
setFavorites(favoriteRelsFor(parseFavorites(readPref(FAV_KEY)), state.root))
|
|
4685
|
+
}, [state.root])
|
|
4686
|
+
const favoriteSet = React.useMemo(() => new Set(favorites), [favorites])
|
|
4687
|
+
/** 加 / 取消收藏,并立刻落盘。 */
|
|
4688
|
+
const toggleFavorite = React.useCallback((rel) => {
|
|
4689
|
+
const next = toggleFavoriteList(favorites, rel)
|
|
4690
|
+
setFavorites(next)
|
|
4691
|
+
const key = state.root || ''
|
|
4692
|
+
if (!key) return // 工作区未知 ⇒ 只活到这次会话结束,不写脏数据
|
|
4693
|
+
const table = parseFavorites(readPref(FAV_KEY))
|
|
4694
|
+
// 取消到空就把这一格**删掉**,不留 `{"<root>":[]}` 这种垃圾键
|
|
4695
|
+
if (next.length) table[key] = next
|
|
4696
|
+
else delete table[key]
|
|
4697
|
+
// 只保留最近几个工作区;**当前这个永远保留**(别把用户刚标的丢掉)
|
|
4698
|
+
const roots = Object.keys(table)
|
|
4699
|
+
while (roots.length > FAV_MAX_ROOTS) {
|
|
4700
|
+
const drop = roots.find((r) => r !== key)
|
|
4701
|
+
if (!drop) break
|
|
4702
|
+
delete table[drop]
|
|
4703
|
+
roots.splice(roots.indexOf(drop), 1)
|
|
4704
|
+
}
|
|
4705
|
+
writePref(FAV_KEY, JSON.stringify(table))
|
|
4706
|
+
}, [favorites, state.root])
|
|
4707
|
+
|
|
4708
|
+
|
|
3841
4709
|
/* ── 曾经在这里的三个状态 + 一个 ref:右栏的形态 ──────────
|
|
3842
4710
|
`packWidth`(310) / `packFloat`(null) / `packSnap`(false) / `packColRef`。
|
|
3843
4711
|
**2026-09-29 随右栏一起删除**。当时它们**只存在内存里**(刷新回默认值),
|
|
@@ -3867,6 +4735,14 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3867
4735
|
才 bump)。原先每 5 s 都无条件落一个新对象:整屏重渲染一遍 + 一轮 FLIP 强制布局 +
|
|
3868
4736
|
GC,用户体感就是「卡顿卡顿的」。签名存在状态自己身上,所以不需要新 hook
|
|
3869
4737
|
(前面那些 hook 的位置被测试按位预置,别插队)。 */
|
|
4738
|
+
/* v0.25(2026-10-22 用户裁决):**媒体档不看相关性,一律按时间倒序**。
|
|
4739
|
+
原话:「媒体这里不用跟随 Agent 读了它进行排序,目前就是以上传时间排序就可以,
|
|
4740
|
+
最新的放在前面就够了……文档可以是调用,但是图片不需要有这种逻辑」。
|
|
4741
|
+
|
|
4742
|
+
⇒ 请求**就是 time**(不只改显示):这样宿主不做无用的相关度计算、截断也按时间切。
|
|
4743
|
+
排序偏好本身**不做修改** —— 切回文档/代码还是你原来选的那个。 */
|
|
4744
|
+
const effectiveSort = kind === KIND_MEDIA ? 'time' : sort
|
|
4745
|
+
|
|
3870
4746
|
const load = React.useCallback(async (alive) => {
|
|
3871
4747
|
const live = () => typeof alive !== 'function' || alive()
|
|
3872
4748
|
if (!live()) return
|
|
@@ -3879,7 +4755,9 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3879
4755
|
// 没打开「使用情况」的会话,宿主侧一个事件都不读。
|
|
3880
4756
|
// v0.23:`retrieval` 是**选填**参数 —— 老宿主忽略它(那就等于词法),
|
|
3881
4757
|
// 而词法模式下宿主**一次 provider 调用都不会发**(方案 §9.2 判据 1)。
|
|
3882
|
-
|
|
4758
|
+
// ⚠️ v0.25(第二轮修订):`/api/recent` 上**一个字节的变更关联都没有** ——
|
|
4759
|
+
// 它的响应形状与 v0.24 逐字相同。变更关联走**独立接口**,见下面那次 fetch。
|
|
4760
|
+
const url = `${LIST_API}?sessionId=${encodeURIComponent(sessionId)}&limit=40&sort=${effectiveSort}&kind=${kind}&retrieval=${effectiveSort === 'relevance' && retrieval === 'hybrid' ? 'hybrid' : 'lexical'}${usageOn ? '&usage=1' : ''}`
|
|
3883
4761
|
const res = await fetch(url, { headers: { accept: 'application/json' }, cache: 'no-store' })
|
|
3884
4762
|
const data = await res.json()
|
|
3885
4763
|
if (!live()) return
|
|
@@ -3914,11 +4792,59 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3914
4792
|
if (!live()) return
|
|
3915
4793
|
setState({ status: 'error', docs: [], root: '', total: 0, error: String((error && error.message) || error), mode: 'time', context: null, usage: null })
|
|
3916
4794
|
}
|
|
4795
|
+
/* v0.25(第二轮修订):**独立接口** `/knit/api/changes`。
|
|
4796
|
+
· 关着时**一个请求都不发**(宿主因此一个 git 进程都不 spawn)——判据 5 的客户端那一半;
|
|
4797
|
+
· 只在「相关」序要它(时间序没有 Context Pack,变更关联无处可落);
|
|
4798
|
+
· 复用宿主刚刚那次扫描(服务端 8 s 同窗)⇒ 两个请求 = 一次扫描 + 一次 git;
|
|
4799
|
+
· 失败一律降级成 `null`(这一区消失),**绝不带坏列表** —— 列表已经落好了。 */
|
|
4800
|
+
// v0.25:媒体档额外取「对话里工具产出的图」。**只在这一档取** —— 别的档不显示它们。
|
|
4801
|
+
// 失败/老宿主没有这条路由 ⇒ 保持安静(列表为空),不弹错、不挡列表。
|
|
4802
|
+
if (kind === KIND_MEDIA) {
|
|
4803
|
+
try {
|
|
4804
|
+
const ares = await fetch(`${ATTACH_LIST_API}?sessionId=${encodeURIComponent(sessionId)}`, {
|
|
4805
|
+
headers: { accept: 'application/json' }, cache: 'no-store',
|
|
4806
|
+
})
|
|
4807
|
+
const adata = await ares.json()
|
|
4808
|
+
if (!live()) return
|
|
4809
|
+
if (adata && adata.ok && Array.isArray(adata.items)) {
|
|
4810
|
+
const items = adata.items
|
|
4811
|
+
// 一字未变就返回**同一个数组**(与列表同一套去重理由:省一次整屏重渲染)
|
|
4812
|
+
setAttachments((prev) => (prev.length === items.length
|
|
4813
|
+
&& items.every((item, i) => item && prev[i] && item.id === prev[i].id) ? prev : items))
|
|
4814
|
+
}
|
|
4815
|
+
} catch { /* 安静:这一档少几张图,不影响文件列表 */ }
|
|
4816
|
+
}
|
|
4817
|
+
|
|
4818
|
+
const wantChanges = effectiveSort === 'relevance' && changesOn
|
|
4819
|
+
if (!wantChanges) {
|
|
4820
|
+
setChangesData((prev) => (prev === null ? prev : null))
|
|
4821
|
+
return
|
|
4822
|
+
}
|
|
4823
|
+
try {
|
|
4824
|
+
// ⚠️ **没有 `kind` 参数**:这一路固定用「文档 + 代码」那一份不分档语料,
|
|
4825
|
+
// 和面板当前在哪个档位无关(档位只切列表那一栏)。
|
|
4826
|
+
const res = await fetch(`${CHANGES_API}?sessionId=${encodeURIComponent(sessionId)}&limit=40&sort=relevance`, {
|
|
4827
|
+
headers: { accept: 'application/json' }, cache: 'no-store',
|
|
4828
|
+
})
|
|
4829
|
+
const data = await res.json()
|
|
4830
|
+
if (!live()) return
|
|
4831
|
+
setChangesData((prev) => {
|
|
4832
|
+
// ⚠️ 「请求失败」与「读不到 git」**不许**都变成 `null`:`null` 是「这个功能没开」,
|
|
4833
|
+
// 用它表示失败会让用户以为「没有变更」。失败有自己的形状(见 `changeStatusOf`)。
|
|
4834
|
+
if (!data || !data.ok) return { failed: true, reason: 'request' }
|
|
4835
|
+
// 载荷一字未变就返回**同一个对象**,React 跳过这次更新(与列表同一套去重理由)
|
|
4836
|
+
const sig = JSON.stringify(data)
|
|
4837
|
+
return (prev && prev.sig === sig) ? prev : { ...data, sig }
|
|
4838
|
+
})
|
|
4839
|
+
} catch {
|
|
4840
|
+
if (!live()) return
|
|
4841
|
+
setChangesData({ failed: true, reason: 'request' })
|
|
4842
|
+
}
|
|
3917
4843
|
// 「读了多久」是按分钟变的相对时间:只有**分钟数**真的变了才落一次刷新信号(其余时候
|
|
3918
4844
|
// 返回同一个值,React 直接跳过这次更新)。标签读的是渲染时刻的钟,不受这里影响。
|
|
3919
4845
|
const now = Date.now()
|
|
3920
4846
|
bumpTick((prev) => (Math.floor(now / 60000) === Math.floor(prev / 60000) ? prev : now))
|
|
3921
|
-
}, [sessionId, sort, kind, usageOn, retrieval])
|
|
4847
|
+
}, [sessionId, sort, kind, usageOn, retrieval, changesOn])
|
|
3922
4848
|
|
|
3923
4849
|
React.useEffect(() => {
|
|
3924
4850
|
// 看不见就一个定时器都不挂:`visible` 变回 true 时本 effect 重跑,立刻 load 一次。
|
|
@@ -3970,10 +4896,7 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
3970
4896
|
const all = Array.isArray(state.docs) ? state.docs : []
|
|
3971
4897
|
const q = query.trim().toLowerCase()
|
|
3972
4898
|
if (!q) return all
|
|
3973
|
-
return all.filter((doc) =>
|
|
3974
|
-
String(doc.title || '').toLowerCase().includes(q)
|
|
3975
|
-
|| String(doc.summary || '').toLowerCase().includes(q)
|
|
3976
|
-
|| String(doc.rel || '').toLowerCase().includes(q))
|
|
4899
|
+
return all.filter((doc) => docMatchesQuery(doc, q))
|
|
3977
4900
|
}, [state.docs, query])
|
|
3978
4901
|
|
|
3979
4902
|
// ResizeObserver 量到的是 .knit-list(它自己也有左右内边距),
|
|
@@ -4043,7 +4966,9 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4043
4966
|
// (AGENTS.md §6.5 同一个坑踩过三次)。
|
|
4044
4967
|
h('div', { className: 'knit-tierline', role: 'presentation' },
|
|
4045
4968
|
h('span', { className: 'knit-tiername' }, t(section.titleKey)),
|
|
4046
|
-
section.hintKey
|
|
4969
|
+
section.hintKey
|
|
4970
|
+
? h('span', { className: 'knit-tierhint' }, t(section.hintKey, section.hintParams))
|
|
4971
|
+
: null),
|
|
4047
4972
|
// ⚠️ 幽灵行(正在离开的)也走 `docsGrid`,所以它照样是一个 `.knit-doc` ——
|
|
4048
4973
|
// 会被 `byClass` 数到,但**不在** `navDocs` 里(键盘与 cursor 都到不了)。
|
|
4049
4974
|
docsGrid(withGhosts(section.key, section.docs), view.numbers, section.key === 'primary', true)))
|
|
@@ -4112,6 +5037,45 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4112
5037
|
if (pinned.length > 0) {
|
|
4113
5038
|
sections.push({ key: 'pinned', titleKey: 'context.pinned', hintKey: 'context.pinnedHint', docs: pinned })
|
|
4114
5039
|
}
|
|
5040
|
+
/* v0.25:**Git 变更关联**。它与固定区是同一类东西:一组有证据、但**不属于这一轮名次**的
|
|
5041
|
+
条目,所以独立成一区、不编号(`numbers` 那边一并跳过它)。
|
|
5042
|
+
⚠️ 这里**不能**用 `visible`(它来自 `state.docs` 那 40 条的切片)—— 一条变更关联的
|
|
5043
|
+
文件很可能排在 40 名之外,用 `visible` 过滤会让整区凭空空掉。它只受**过滤框**约束,
|
|
5044
|
+
与用户在搜索框里打的字保持一致。 */
|
|
5045
|
+
const changeRows = changeRowsOf(changesData)
|
|
5046
|
+
// ⚠️ 这里**自己派生一次**,不复用状态行那份 `changeStatus`:那个常量声明在这个
|
|
5047
|
+
// useMemo **之后**(靠近状态行的渲染),引它会 `Cannot access before initialization`
|
|
5048
|
+
// —— 运行时直接白屏(写完当场被测试抓到)。同一个纯函数、同一个入参,不会分叉。
|
|
5049
|
+
const changeState = changeStatusOf(changesData)
|
|
5050
|
+
const q = query.trim().toLowerCase()
|
|
5051
|
+
const changeDocs = changeRows.filter((item) => !isMedia(item) && docMatchesQuery(item, q)).map(withHits)
|
|
5052
|
+
if (changeDocs.length > 0) {
|
|
5053
|
+
sections.push({ key: 'changes', titleKey: 'context.changes', hintKey: 'context.changesHint', docs: changeDocs })
|
|
5054
|
+
} else if (changesOn && changesData !== null && !changeState.read) {
|
|
5055
|
+
/* v0.25 收尾:**读不到时把原因直接写出来**,不再只放在悬停里。
|
|
5056
|
+
为什么加这一条:真人反馈(2026-10-13)—— 用户看到那一格写「变更 —」,
|
|
5057
|
+
读成了「这个数据没记录到」,而真正的原因是「这个工作区不是 Git 仓库」,
|
|
5058
|
+
它只藏在 `title` 里,不悬停就看不见。
|
|
5059
|
+
⚠️ 条件里的 `changesData !== null` 是必须的:功能刚打开、第一次取数还没回来时
|
|
5060
|
+
`read` 也是 false,那时写「原因未知」是**假话**(不是读不到,是还没读到)。
|
|
5061
|
+
那一瞬间不出这一区,等下一条轮询落地。 */
|
|
5062
|
+
sections.push({
|
|
5063
|
+
key: 'changes', titleKey: 'context.changes', hintKey: 'context.changesUnreadable',
|
|
5064
|
+
hintParams: { reason: t(changeReasonKey(changeState.reason)) },
|
|
5065
|
+
docs: [],
|
|
5066
|
+
})
|
|
5067
|
+
} else if (changesOn && changeState.read && changeState.filesTotal > 0) {
|
|
5068
|
+
/* v0.25 收尾:**有变更、但一条关联证据都没有**时要说得出来。
|
|
5069
|
+
这一区是**只带提示句、不带行**的(区头照常出现)—— 用户因此能区分
|
|
5070
|
+
「没有变更」(那一格写 0,这里什么都不出)与「有变更但没找到该一起看的」。
|
|
5071
|
+
读不到 git 的那种情况**不在这里**:它的提示在状态行那一格(「变更 —」 + 悬停原因),
|
|
5072
|
+
因为「读不到」不是一条列表内容。 */
|
|
5073
|
+
sections.push({
|
|
5074
|
+
key: 'changes', titleKey: 'context.changes',
|
|
5075
|
+
hintKey: 'context.changesEmpty', hintParams: { files: changeState.filesTotal },
|
|
5076
|
+
docs: [],
|
|
5077
|
+
})
|
|
5078
|
+
}
|
|
4115
5079
|
for (const [tierKey, titleKey, hintKey] of tiers) {
|
|
4116
5080
|
const items = Array.isArray(pack[tierKey]) ? pack[tierKey] : []
|
|
4117
5081
|
const docs = items.filter((item) => visible.has(item.rel)).map(withHits)
|
|
@@ -4125,6 +5089,8 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4125
5089
|
}
|
|
4126
5090
|
// 固定区里的也在包里 —— 它们同样不该出现在「其他相关文档」。
|
|
4127
5091
|
for (const item of (Array.isArray(pack.pinned) ? pack.pinned : [])) placed.add(item.rel)
|
|
5092
|
+
// 变更关联区里的也不再出现在「其他相关文档」(同一篇不该在两处出现)
|
|
5093
|
+
for (const item of changeRows) placed.add(item.rel)
|
|
4128
5094
|
const rest = visibleDocs.filter((doc) => !isMedia(doc) && !placed.has(doc.rel))
|
|
4129
5095
|
if (rest.length > 0) {
|
|
4130
5096
|
sections.push({ key: 'other', titleKey: 'context.other', hintKey: '', docs: rest })
|
|
@@ -4136,14 +5102,14 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4136
5102
|
// v0.21:**固定区也不编号** —— 它的位置由用户决定,不由阅读顺序决定。
|
|
4137
5103
|
const numbers = new Map()
|
|
4138
5104
|
for (const section of sections) {
|
|
4139
|
-
if (section.key === 'other' || section.key === 'pinned') continue
|
|
5105
|
+
if (section.key === 'other' || section.key === 'pinned' || section.key === 'changes') continue
|
|
4140
5106
|
for (const doc of section.docs) numbers.set(doc.rel, numbers.size + 1)
|
|
4141
5107
|
}
|
|
4142
5108
|
// 键盘到达顺序 = 屏幕上从上到下的顺序(分组顺序 + 组内顺序)
|
|
4143
5109
|
const flat = []
|
|
4144
5110
|
for (const section of sections) for (const doc of section.docs) flat.push(doc)
|
|
4145
5111
|
return { sections, flat, numbers }
|
|
4146
|
-
}, [relevance, kind, state.context, visibleDocs])
|
|
5112
|
+
}, [relevance, kind, state.context, changesData, visibleDocs, query])
|
|
4147
5113
|
|
|
4148
5114
|
/**
|
|
4149
5115
|
* 键盘与 cursor 真正能到达的条目。
|
|
@@ -4152,7 +5118,19 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4152
5118
|
* 否则「其他相关文档」区里的条目键盘到不了,而已经在 Related 层里的条目
|
|
4153
5119
|
* 会被算两次。(媒体档走的是网格,`visibleDocs` 就是那批媒体。)
|
|
4154
5120
|
*/
|
|
4155
|
-
|
|
5121
|
+
/* v0.25:媒体档的「可见条目」= 收藏在前 + 对话里生成的 + 其余。
|
|
5122
|
+
`navDocs` 也用它 —— 否则键盘导航会把对话里那几张**跳过去**(看得见、走不到)。
|
|
5123
|
+
收藏仍然排在最前:这一条没变,只是把「还没存进项目的图」插在收藏之后。 */
|
|
5124
|
+
const mediaDocs = React.useMemo(() => {
|
|
5125
|
+
/* 媒体档的**唯一**顺序:按时间倒序(最新在前)。文档/代码才看相关性。
|
|
5126
|
+
工作区文件用 `mtimeMs`,对话里生成的图用事件时间(`at` → 伪文档的 `mtimeMs`)——
|
|
5127
|
+
两者同一条时间轴,所以「刚生成的」自然在最前;存进项目后它变成文件、时间也还在附近。
|
|
5128
|
+
收藏仍然前移(`orderFavorites` 是**稳定**分区 ⇒ 两组内部都还是时间倒序)。 */
|
|
5129
|
+
const byTimeDesc = (a, b) => (Number.isFinite(b.mtimeMs) ? b.mtimeMs : 0) - (Number.isFinite(a.mtimeMs) ? a.mtimeMs : 0)
|
|
5130
|
+
const merged = (Array.isArray(visibleDocs) ? visibleDocs : []).concat(attachmentDocs)
|
|
5131
|
+
return orderFavorites(merged.slice().sort(byTimeDesc), favoriteSet)
|
|
5132
|
+
}, [visibleDocs, favoriteSet, attachmentDocs])
|
|
5133
|
+
const navDocs = kind === KIND_MEDIA && !contextView ? mediaDocs : (contextView ? contextView.flat : visibleDocs)
|
|
4156
5134
|
|
|
4157
5135
|
// cursor 消失(被过滤掉 / 被上限截断 / 列表刷新)时落回第一项
|
|
4158
5136
|
React.useEffect(() => {
|
|
@@ -4205,7 +5183,9 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4205
5183
|
anchor: anchor || null, anchorSeq: 0,
|
|
4206
5184
|
}
|
|
4207
5185
|
if (isMedia(doc)) {
|
|
4208
|
-
|
|
5186
|
+
// v0.25:对话里生成的图走 sha256 那条地址(它没有工作区路径)
|
|
5187
|
+
const src = doc.attachmentId ? attachmentUrl(sessionId, doc.attachmentId) : mediaUrl(sessionId, doc.rel)
|
|
5188
|
+
return { ...base, kind: doc.kind, src, status: 'ready' }
|
|
4209
5189
|
}
|
|
4210
5190
|
return { ...base, kind: doc.kind || ARTIFACT_DOC, status: 'loading' }
|
|
4211
5191
|
}, [sessionId])
|
|
@@ -4273,6 +5253,75 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4273
5253
|
* (这里以前一律传 `docLayout.columns`,而文档列数与媒体列数根本不是一回事 ——
|
|
4274
5254
|
* 媒体档的 ←→ 一直是按文档的 2 列在走。改动顺便把它对齐了。)
|
|
4275
5255
|
*/
|
|
5256
|
+
/* ── v0.25:媒体档「双击全屏」(**追加在末尾**:替身按下标 seed useState/useRef)
|
|
5257
|
+
存的是 `rel` 而不是下标 —— 列表每 5 秒会换一份,下标会漂;`rel` 不会。
|
|
5258
|
+
列表里找不到它了(被删 / 被存进项目 / 切了档)就自己关掉。 */
|
|
5259
|
+
const [lightboxRel, setLightboxRel] = React.useState('')
|
|
5260
|
+
const lightboxRef = React.useRef(null)
|
|
5261
|
+
const lightboxIndex = React.useMemo(
|
|
5262
|
+
() => (lightboxRel ? mediaDocs.findIndex((doc) => doc.rel === lightboxRel) : -1),
|
|
5263
|
+
[mediaDocs, lightboxRel],
|
|
5264
|
+
)
|
|
5265
|
+
const lightboxDoc = lightboxIndex >= 0 ? mediaDocs[lightboxIndex] : null
|
|
5266
|
+
const lightboxRailView = React.useMemo(
|
|
5267
|
+
() => lightboxRail(mediaDocs, lightboxIndex),
|
|
5268
|
+
[mediaDocs, lightboxIndex],
|
|
5269
|
+
)
|
|
5270
|
+
React.useEffect(() => {
|
|
5271
|
+
if (lightboxRel && lightboxIndex < 0) setLightboxRel('')
|
|
5272
|
+
}, [lightboxRel, lightboxIndex])
|
|
5273
|
+
const lightboxOpen = React.useCallback((doc) => {
|
|
5274
|
+
if (!doc || doc.kind !== 'image') return
|
|
5275
|
+
setLightboxRel(doc.rel)
|
|
5276
|
+
// 悬停浮窗这时必须收掉:它在查看器下面,留着就是两层大字
|
|
5277
|
+
if (hoverTimerRef.current) clearTimeout(hoverTimerRef.current)
|
|
5278
|
+
hoverTimerRef.current = 0
|
|
5279
|
+
setHoverShot(null)
|
|
5280
|
+
}, [])
|
|
5281
|
+
const lightboxClose = React.useCallback(() => setLightboxRel(''), [])
|
|
5282
|
+
/* 翻到第 9 张时,左列如果溢出,当前那张会被留在视野外 —— 每次换图都把它**滚进来**
|
|
5283
|
+
(`block:'nearest'`:已经在视野里就一格都不动,不会抖)。没有 DOM 就跳过。 */
|
|
5284
|
+
const lightboxRailRef = React.useRef(null)
|
|
5285
|
+
React.useEffect(() => {
|
|
5286
|
+
if (!lightboxRel) return
|
|
5287
|
+
const rail = lightboxRailRef.current
|
|
5288
|
+
if (!rail || typeof rail.querySelector !== 'function') return
|
|
5289
|
+
const active = rail.querySelector('.knit-lightbox-thumb.active')
|
|
5290
|
+
if (active && typeof active.scrollIntoView === 'function') {
|
|
5291
|
+
try { active.scrollIntoView({ block: 'nearest' }) } catch { /* 老浏览器:算了,不影响换图 */ }
|
|
5292
|
+
}
|
|
5293
|
+
}, [lightboxRel])
|
|
5294
|
+
/** 查看器里的「本地打开」:与预览头同一条宿主通道,只是路径从 rel 现算。 */
|
|
5295
|
+
const lightboxAbs = lightboxDoc
|
|
5296
|
+
? (lightboxDoc.path || joinPath(state.hostRoot || state.root, lightboxDoc.rel))
|
|
5297
|
+
: ''
|
|
5298
|
+
const lightboxOpenLocal = React.useCallback(async () => {
|
|
5299
|
+
setNotice((await openLocalPath(lightboxAbs)) || '')
|
|
5300
|
+
}, [lightboxAbs])
|
|
5301
|
+
/* 打开时把焦点交给遮罩:键盘用户一进来 Esc / ← → 就该能用(真机才有 DOM)。 */
|
|
5302
|
+
React.useLayoutEffect(() => {
|
|
5303
|
+
if (!lightboxRel) return
|
|
5304
|
+
const node = lightboxRef.current
|
|
5305
|
+
if (node && typeof node.focus === 'function') node.focus()
|
|
5306
|
+
}, [lightboxRel])
|
|
5307
|
+
/**
|
|
5308
|
+
* 在带子里前后翻(环绕)。
|
|
5309
|
+
*
|
|
5310
|
+
* ⚠️ 必须用**函数式更新**从「当前 state」推下一步,不能读渲染时捕获的 `lightboxIndex`:
|
|
5311
|
+
* 连着按两下 → 如果两下都落在同一次渲染的闭包里,第二下会用**陈旧的下标**再算一遍,
|
|
5312
|
+
* 结果只前进一格(证伪时就是这么抓到的)。现在每一步都以「此刻的 rel」为起点。
|
|
5313
|
+
*/
|
|
5314
|
+
const lightboxStep = React.useCallback((delta) => {
|
|
5315
|
+
if (!mediaDocs.length) return
|
|
5316
|
+
setLightboxRel((current) => {
|
|
5317
|
+
const at = mediaDocs.findIndex((doc) => doc.rel === current)
|
|
5318
|
+
const from = at >= 0 ? at : 0
|
|
5319
|
+
const next = (from + (delta < 0 ? -1 : 1) + mediaDocs.length) % mediaDocs.length
|
|
5320
|
+
const doc = mediaDocs[next]
|
|
5321
|
+
return doc ? doc.rel : current
|
|
5322
|
+
})
|
|
5323
|
+
}, [mediaDocs])
|
|
5324
|
+
|
|
4276
5325
|
const onListKeyDown = React.useCallback((event) => {
|
|
4277
5326
|
if (navDocs.length === 0) return
|
|
4278
5327
|
const index = navDocs.findIndex((doc) => doc.rel === cursor)
|
|
@@ -4284,13 +5333,21 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4284
5333
|
if (target >= 0) {
|
|
4285
5334
|
event.preventDefault()
|
|
4286
5335
|
const doc = navDocs[target]
|
|
4287
|
-
if (doc) {
|
|
5336
|
+
if (doc) {
|
|
5337
|
+
setCursor(doc.rel)
|
|
5338
|
+
// 媒体档不做就地预览(2026-10-22 用户裁决):方向键只移光标,看大图用 Enter / 双击
|
|
5339
|
+
if (kind !== KIND_MEDIA) openPreview(doc)
|
|
5340
|
+
}
|
|
4288
5341
|
return
|
|
4289
5342
|
}
|
|
4290
5343
|
if (event.key === 'Enter') {
|
|
4291
5344
|
event.preventDefault()
|
|
4292
5345
|
const doc = navDocs.find((d) => d.rel === cursor) || navDocs[0]
|
|
4293
|
-
if (doc)
|
|
5346
|
+
if (doc) {
|
|
5347
|
+
// 与双击同一套分流(键盘不能比鼠标少一条路)
|
|
5348
|
+
if (kind === KIND_MEDIA && doc.kind === 'image') lightboxOpen(doc)
|
|
5349
|
+
else togglePreview(doc)
|
|
5350
|
+
}
|
|
4294
5351
|
return
|
|
4295
5352
|
}
|
|
4296
5353
|
if (event.key === 'Escape') {
|
|
@@ -4298,7 +5355,7 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4298
5355
|
if (fullscreen) setFullscreen(false)
|
|
4299
5356
|
else closePreview()
|
|
4300
5357
|
}
|
|
4301
|
-
}, [navDocs, cursor, fullscreen, kind, mediaLayout.columns, openPreview, togglePreview, closePreview])
|
|
5358
|
+
}, [navDocs, cursor, fullscreen, kind, mediaLayout.columns, openPreview, togglePreview, closePreview, lightboxOpen])
|
|
4302
5359
|
|
|
4303
5360
|
/** 拖拽预览面板上缘改变高度。 */
|
|
4304
5361
|
const onResizeStart = React.useCallback((event) => {
|
|
@@ -4507,7 +5564,10 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4507
5564
|
}, [])
|
|
4508
5565
|
|
|
4509
5566
|
/** 媒体条目的同源字节地址(缩略图 / 就地预览)。 */
|
|
4510
|
-
const srcFor = React.useCallback(
|
|
5567
|
+
const srcFor = React.useCallback(
|
|
5568
|
+
(doc) => (doc.attachmentId ? attachmentUrl(sessionId, doc.attachmentId) : mediaUrl(sessionId, doc.rel)),
|
|
5569
|
+
[sessionId],
|
|
5570
|
+
)
|
|
4511
5571
|
|
|
4512
5572
|
/**
|
|
4513
5573
|
* 切换检索模式并记住偏好。**只切偏好**:真正的 provider 调用发生在宿主侧,
|
|
@@ -4520,6 +5580,16 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4520
5580
|
setSemNotice('')
|
|
4521
5581
|
}, [])
|
|
4522
5582
|
|
|
5583
|
+
/**
|
|
5584
|
+
* v0.25:切换「Git 变更关联」并记住偏好。**只切偏好** —— 真正跑 git 的是宿主,
|
|
5585
|
+
* 下一次 `load()` 会带上 `changes=1`。关掉时请求里就不带了(宿主零开销)。
|
|
5586
|
+
* @param {boolean} value - 是否开启
|
|
5587
|
+
*/
|
|
5588
|
+
const pickChanges = React.useCallback((value) => {
|
|
5589
|
+
writePref(CHANGES_KEY, value ? '1' : '0')
|
|
5590
|
+
setChangesOn(value)
|
|
5591
|
+
}, [])
|
|
5592
|
+
|
|
4523
5593
|
/** 切换列表类型并记住偏好;同时收起上一类型的预览。 */
|
|
4524
5594
|
const pickKind = React.useCallback((value) => {
|
|
4525
5595
|
writePref(KIND_KEY, value)
|
|
@@ -4822,7 +5892,21 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4822
5892
|
passage: firstMatchOf(doc),
|
|
4823
5893
|
onPassage: openPassage,
|
|
4824
5894
|
}
|
|
4825
|
-
if (isMedia(doc))
|
|
5895
|
+
if (isMedia(doc)) {
|
|
5896
|
+
return h(MediaCard, {
|
|
5897
|
+
...common,
|
|
5898
|
+
/* 单击**只移光标**(`active` 不再亮、下方不再弹预览)——
|
|
5899
|
+
这是用户 2026-10-22 明确要撤掉的那个交互。 */
|
|
5900
|
+
onSelect: () => setCursor(doc.rel),
|
|
5901
|
+
onPreview: togglePreview,
|
|
5902
|
+
src: srcFor(doc),
|
|
5903
|
+
favorite: favoriteSet.has(doc.rel),
|
|
5904
|
+
conversation: Boolean(doc.conversation),
|
|
5905
|
+
onHoverStart: hoverStart,
|
|
5906
|
+
onHoverEnd: hoverEnd,
|
|
5907
|
+
onZoom: lightboxOpen,
|
|
5908
|
+
})
|
|
5909
|
+
}
|
|
4826
5910
|
// `whyText` 只认 Context Pack 条目上挂的 `reason` —— 平铺列表里没有这个字段,
|
|
4827
5911
|
// 于是返回空串,那一行不渲染。
|
|
4828
5912
|
// `num` / `primary` 只有分层视图会传(Design §11 / §13);平铺列表照旧无序号。
|
|
@@ -4868,7 +5952,10 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4868
5952
|
: kind === KIND_CODE
|
|
4869
5953
|
? t('list.emptyCode')
|
|
4870
5954
|
: t('list.empty')
|
|
4871
|
-
|
|
5955
|
+
/* ⚠️ 为什么是**函数**而不是常量:这里要读「面板末尾才声明」的状态(媒体收藏)。
|
|
5956
|
+
写成常量会在这一行就求值 ⇒ TDZ(`Cannot access 'favoriteSet' before initialization`)。
|
|
5957
|
+
包成函数、在 return 里调用一次,既不改渲染结果,也不会再被后面的新状态绊倒。 */
|
|
5958
|
+
const listBody = () => (state.status === 'loading' && state.docs.length === 0
|
|
4872
5959
|
? h('div', { className: 'knit-msg' }, t('list.scanning'))
|
|
4873
5960
|
: state.status === 'error'
|
|
4874
5961
|
? h('div', { className: 'knit-msg' }, t('list.failed', { error: state.error }), h('br'), t('list.failedHint'))
|
|
@@ -4877,10 +5964,10 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
4877
5964
|
: visibleDocs.length === 0
|
|
4878
5965
|
? h('div', { className: 'knit-msg' }, t('list.noMatch', { query: query.trim() }))
|
|
4879
5966
|
: kind === KIND_MEDIA
|
|
4880
|
-
? mediaGrid(
|
|
5967
|
+
? mediaGrid(mediaDocs)
|
|
4881
5968
|
: contextView
|
|
4882
5969
|
? contextBody(contextView)
|
|
4883
|
-
: docsGrid(withGhosts(MOTION_TIER_FLAT, visibleDocs))
|
|
5970
|
+
: docsGrid(withGhosts(MOTION_TIER_FLAT, visibleDocs)))
|
|
4884
5971
|
|
|
4885
5972
|
// 排序说明那一行(.knit-topic)**2026-09-30 已整体删除**:排序方式由头部那个
|
|
4886
5973
|
// 「相关 / 最新」切换按钮自己表达(按钮上就写着当前选的是哪个),再补一句
|
|
@@ -5329,6 +6416,42 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5329
6416
|
className: 'knit-retmenu-cfg',
|
|
5330
6417
|
onClick: () => { setRetMenuOpen(false); setSemCfgOpen((value) => !value) },
|
|
5331
6418
|
}, t(semCfgOpen ? 'sem.cfg.hide' : 'sem.cfg.show')) : null) : null)
|
|
6419
|
+
/* v0.25:Git 变更关联那一格(见上面 CSS 的说明)。三种话术,都由**宿主的事实**决定:
|
|
6420
|
+
关着 / 开着且有数 / 开着但读不到(写原因)。读完就关也不会留下悬念。 */
|
|
6421
|
+
/* v0.25(第二轮修订):这一格的数字来自**独立接口**的那份载荷,不再来自 Context Pack。
|
|
6422
|
+
v0.25 收尾:**三种状态必须互相可辨**(这是原来那版最实的一个缺口 ——
|
|
6423
|
+
请求失败时那一格显示成「关着」的样子,用户会把「读不到」读成「没有变更」):
|
|
6424
|
+
· 关着 → 归一成 `null` → 「变更」
|
|
6425
|
+
· 开着但读不到 → `failed` / `git.available === false` → 「变更 —」+ 悬停写原因
|
|
6426
|
+
· 开着且读到了 → `git.available === true` → 「变更 N」(N = 变更文件数)
|
|
6427
|
+
⚠️ 「有变更但没有关联」与「有变更且有关联」在状态行上是同一个 `变更 N` ——
|
|
6428
|
+
它们的区别在**列表里那一区的提示句**(见 `contextView`),不在这一格。 */
|
|
6429
|
+
const changeStatus = changeStatusOf(changesData)
|
|
6430
|
+
const changeInfo = changeStatus.read ? { ...changeStatus, relatedTotal: Number(changesData.linksTotal) || 0 } : null
|
|
6431
|
+
const changeFiles = changeInfo && Number.isFinite(changeInfo.filesTotal) ? changeInfo.filesTotal : 0
|
|
6432
|
+
const changesLabel = !changesOn
|
|
6433
|
+
? t('pipe.changesOff')
|
|
6434
|
+
: (!changeStatus.read
|
|
6435
|
+
? t('pipe.changesUnavailable')
|
|
6436
|
+
: t('pipe.changesOn', { n: changeFiles }))
|
|
6437
|
+
const changesTitle = !changesOn
|
|
6438
|
+
? t('changes.titleOff')
|
|
6439
|
+
: (!changeStatus.read
|
|
6440
|
+
? t('changes.titleUnavailable', { reason: t(changeReasonKey(changeStatus.reason)) })
|
|
6441
|
+
: t('changes.titleOn', {
|
|
6442
|
+
files: changeFiles,
|
|
6443
|
+
related: changeInfo ? (Number(changeInfo.relatedTotal) || 0) : 0,
|
|
6444
|
+
}))
|
|
6445
|
+
const changesNode = h('button', {
|
|
6446
|
+
type: 'button',
|
|
6447
|
+
className: 'knit-pipe-changes',
|
|
6448
|
+
'aria-pressed': changesOn ? 'true' : 'false',
|
|
6449
|
+
title: changesTitle,
|
|
6450
|
+
onClick: (event) => {
|
|
6451
|
+
if (event && typeof event.stopPropagation === 'function') event.stopPropagation()
|
|
6452
|
+
pickChanges(!changesOn)
|
|
6453
|
+
},
|
|
6454
|
+
}, h('span', { className: 'knit-pipe-changes-label' }, changesLabel))
|
|
5332
6455
|
const pipeNode = h('div', { className: 'knit-pipe' },
|
|
5333
6456
|
pipeCell(t('pipe.collect', { n: collected })),
|
|
5334
6457
|
pipeDot(),
|
|
@@ -5344,6 +6467,10 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5344
6467
|
pipeCell(t('pipe.relations', { n: relCount })),
|
|
5345
6468
|
pipeDot(),
|
|
5346
6469
|
pipeCell(t('pipe.pin', { n: pinnedCount })),
|
|
6470
|
+
pipeDot(),
|
|
6471
|
+
// v0.25:入口就是这一格 —— **默认关**,关着也出现(藏起来用户就永远打不开)。
|
|
6472
|
+
// 它说的是宿主回的**事实**(几个变更文件 / 读不到的原因),不是「你点了什么」。
|
|
6473
|
+
changesNode,
|
|
5347
6474
|
pipeSep(),
|
|
5348
6475
|
// 唯一略微加重的一格:它是这一行里被后续阶段消费的那个数字(需求 §三.8:
|
|
5349
6476
|
// 只提字重,不用品牌色、不做徽章)。
|
|
@@ -5356,9 +6483,184 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5356
6483
|
? state.control.excluded.filter((item) => item.exists)
|
|
5357
6484
|
: []
|
|
5358
6485
|
|
|
6486
|
+
/* ── v0.25:预览里的查找(Cmd+F)──────────────────────────────────────
|
|
6487
|
+
⚠️ **这一整块必须留在组件末尾** —— 测试替身按**下标**预置 useState/useRef 的初值
|
|
6488
|
+
(`harness.seed`),而只有 useState/useRef 占槽位。插在中间会把后面每一个槽位
|
|
6489
|
+
整体挪位,`seeded[15]` 那条就直接落到别的状态上(上一轮 `changesOn` 已经踩过一次,
|
|
6490
|
+
这次的 `query.trim is not a function` 是第二次)。新钩子一律**追加在最后**。
|
|
6491
|
+
|
|
6492
|
+
/* ── v0.25:预览里的查找(Cmd+F)──────────────────────────────────────
|
|
6493
|
+
状态放在**这一层**而不是 PreviewPanel:快捷键挂在面板根上(见
|
|
6494
|
+
`onRootKeyDownCapture`)—— 焦点通常在左边那个列表上(↑↓ 开着预览),
|
|
6495
|
+
挂在 `.knit-preview` 上根本收不到那个事件。
|
|
6496
|
+
`findSeq` 只在**显式导航**时 +1(打开 / 输入 / 上一下一个),它是「要不要滚」的唯一开关:
|
|
6497
|
+
5 秒轮询会重画命中,**但绝不滚动** —— 否则用户读到一半每 5 秒被拽回去一次
|
|
6498
|
+
(AGENTS.md §6.13 ② 那个「列表自己跳」的坑,同一个道理)。 */
|
|
6499
|
+
const [findOn, setFindOn] = React.useState(false)
|
|
6500
|
+
const [findQuery, setFindQuery] = React.useState('')
|
|
6501
|
+
const [findIndex, setFindIndex] = React.useState(0)
|
|
6502
|
+
const [findSeq, setFindSeq] = React.useState(0)
|
|
6503
|
+
const [findCount, setFindCount] = React.useState(0)
|
|
6504
|
+
const findMarksRef = React.useRef([])
|
|
6505
|
+
const findInputRef = React.useRef(null)
|
|
6506
|
+
const previewBodyRef = React.useRef(null)
|
|
6507
|
+
|
|
6508
|
+
/* 关掉预览就关掉查找(否则下次打开会带着上一次的关键词与一树残留标记)。 */
|
|
6509
|
+
React.useEffect(() => {
|
|
6510
|
+
if (preview) return
|
|
6511
|
+
setFindOn(false)
|
|
6512
|
+
setFindQuery('')
|
|
6513
|
+
}, [preview])
|
|
6514
|
+
|
|
6515
|
+
/* 画命中 —— 开关 / 关键词 / 这一篇的内容,任一变了就重画。
|
|
6516
|
+
⚠️ 依赖里没有轮询刷出来的数组;`preview` 换了一篇或文件被改过就重画一次,
|
|
6517
|
+
但**不滚** —— 滚动只由 `findSeq` 那条 effect 负责。 */
|
|
6518
|
+
React.useLayoutEffect(() => {
|
|
6519
|
+
const box = previewBodyRef.current
|
|
6520
|
+
clearFindMarks(box)
|
|
6521
|
+
findMarksRef.current = []
|
|
6522
|
+
if (!box || !findOn || !findQuery) {
|
|
6523
|
+
setFindCount(0)
|
|
6524
|
+
return
|
|
6525
|
+
}
|
|
6526
|
+
const marks = paintFindMarks(box, findQuery)
|
|
6527
|
+
findMarksRef.current = marks
|
|
6528
|
+
setFindCount(marks.length)
|
|
6529
|
+
}, [findOn, findQuery, preview && preview.rel, preview && preview.text])
|
|
6530
|
+
|
|
6531
|
+
/* 标出「当前这一条」并滚到它。
|
|
6532
|
+
⚠️ **只依赖 `findSeq`**(显式导航才 +1)、命中数组走 ref 读:把重画当成「用户动了光标」,
|
|
6533
|
+
就会每 5 秒把用户读到一半的视图拽回去一次(§6.13 ② 那条坑,同一个道理)。 */
|
|
6534
|
+
React.useLayoutEffect(() => {
|
|
6535
|
+
const marks = findMarksRef.current
|
|
6536
|
+
if (!findOn || !marks.length) return
|
|
6537
|
+
const index = Math.min(Math.max(0, findIndex), marks.length - 1)
|
|
6538
|
+
markFindCurrent(marks, index)
|
|
6539
|
+
scrollMarkIntoView(marks[index])
|
|
6540
|
+
}, [findSeq])
|
|
6541
|
+
|
|
6542
|
+
/* 打开后把焦点交给输入框(挂上去之后再 focus)。 */
|
|
6543
|
+
React.useLayoutEffect(() => {
|
|
6544
|
+
if (!findOn) return
|
|
6545
|
+
const input = findInputRef.current
|
|
6546
|
+
if (input && typeof input.focus === 'function') input.focus()
|
|
6547
|
+
}, [findOn])
|
|
6548
|
+
|
|
6549
|
+
/**
|
|
6550
|
+
* 打开查找条并把焦点给它。
|
|
6551
|
+
*
|
|
6552
|
+
* 两条入口都用它:**Cmd+F**(焦点在面板里时),以及预览头那个**「查找」按钮** ——
|
|
6553
|
+
* 后者是兜底:外层应用的原生快捷键在按键进入网页之前就被它自己处理了,网页侧抢不回来。
|
|
6554
|
+
* 已经开着时 `findOn` 不变、聚焦那条 effect 不会再跑,所以这里就地补一次 focus。
|
|
6555
|
+
*/
|
|
6556
|
+
const openFind = React.useCallback(() => {
|
|
6557
|
+
setFindOn(true)
|
|
6558
|
+
const input = findInputRef.current
|
|
6559
|
+
if (input && typeof input.focus === 'function') input.focus()
|
|
6560
|
+
}, [])
|
|
6561
|
+
|
|
6562
|
+
/** 关掉查找条(不清正文内容,也不动预览)。 */
|
|
6563
|
+
const closeFind = React.useCallback(() => {
|
|
6564
|
+
setFindOn(false)
|
|
6565
|
+
setFindQuery('')
|
|
6566
|
+
}, [])
|
|
6567
|
+
|
|
6568
|
+
/** 上一个 / 下一个(环绕)。 */
|
|
6569
|
+
const findStep = React.useCallback((delta) => {
|
|
6570
|
+
const total = findMarksRef.current.length
|
|
6571
|
+
if (!total) return
|
|
6572
|
+
setFindIndex((current) => stepFindIndex(current, total, delta))
|
|
6573
|
+
setFindSeq((n) => n + 1)
|
|
6574
|
+
}, [])
|
|
6575
|
+
|
|
6576
|
+
/** 改关键词:回到第一条命中并滚过去(与 Chrome 一致)。 */
|
|
6577
|
+
const onFindQuery = React.useCallback((value) => {
|
|
6578
|
+
setFindQuery(value)
|
|
6579
|
+
setFindIndex(0)
|
|
6580
|
+
setFindSeq((n) => n + 1)
|
|
6581
|
+
}, [])
|
|
6582
|
+
|
|
6583
|
+
/**
|
|
6584
|
+
* 面板根上的**捕获阶段**键盘处理。
|
|
6585
|
+
*
|
|
6586
|
+
* 为什么是「这一层」:焦点通常在左边那个列表上(↑↓ 打开预览),把快捷键挂在
|
|
6587
|
+
* `.knit-preview` 上收不到那个事件(事件从列表冒泡,不经过预览)。
|
|
6588
|
+
* 为什么是「捕获」:列表自己有 Esc(关预览 / 退全屏),而查找开着时 Esc 的语义
|
|
6589
|
+
* 应当是**先关查找条** —— 捕获先于子节点执行,这里 stopPropagation 就把它拦下了。
|
|
6590
|
+
*
|
|
6591
|
+
* 只拦两件事(Cmd/Ctrl+F、查找开着时的 Esc),其余一律放行:不抢输入框、不抢列表方向键。
|
|
6592
|
+
*/
|
|
6593
|
+
const onRootKeyDownCapture = React.useCallback((event) => {
|
|
6594
|
+
if (!event) return
|
|
6595
|
+
// ⚠️ 查看器是**最上层**:它开着时 Esc / ← / → 先归它(不许漏到列表的键盘导航上)
|
|
6596
|
+
if (lightboxRel) {
|
|
6597
|
+
if (event.key === 'Escape') {
|
|
6598
|
+
event.preventDefault(); event.stopPropagation(); lightboxClose(); return
|
|
6599
|
+
}
|
|
6600
|
+
/* 左列是**竖排**的,所以 ↑↓ 必须能用(用户 2026-10-22 追加要求);
|
|
6601
|
+
←→ 一并留着 —— 有人就是习惯左右翻,两条路没有冲突。 */
|
|
6602
|
+
if (event.key === 'ArrowRight' || event.key === 'ArrowLeft'
|
|
6603
|
+
|| event.key === 'ArrowDown' || event.key === 'ArrowUp') {
|
|
6604
|
+
event.preventDefault(); event.stopPropagation()
|
|
6605
|
+
const back = event.key === 'ArrowLeft' || event.key === 'ArrowUp'
|
|
6606
|
+
lightboxStep(back ? -1 : 1)
|
|
6607
|
+
return
|
|
6608
|
+
}
|
|
6609
|
+
}
|
|
6610
|
+
const mod = !!(event.metaKey || event.ctrlKey)
|
|
6611
|
+
if (mod && !event.altKey && String(event.key || '').toLowerCase() === 'f') {
|
|
6612
|
+
// 媒体档没有可搜的正文 ⇒ 不拦,交回宿主 / 浏览器自己的行为
|
|
6613
|
+
if (!preview || preview.kind === 'image' || preview.kind === 'video') return
|
|
6614
|
+
event.preventDefault()
|
|
6615
|
+
event.stopPropagation()
|
|
6616
|
+
openFind()
|
|
6617
|
+
return
|
|
6618
|
+
}
|
|
6619
|
+
if (event.key === 'Escape' && findOn) {
|
|
6620
|
+
event.preventDefault()
|
|
6621
|
+
event.stopPropagation()
|
|
6622
|
+
setFindOn(false)
|
|
6623
|
+
setFindQuery('')
|
|
6624
|
+
}
|
|
6625
|
+
}, [preview, findOn, openFind, lightboxRel, lightboxClose, lightboxStep])
|
|
6626
|
+
|
|
6627
|
+
/* ── v0.25:媒体档「悬停看大图」(同样**追加在末尾**:替身按下标 seed useState/useRef)
|
|
6628
|
+
只对图片;停 HOVER_SHOT_DELAY_MS 才出现;离开 / 滚动 / 换档立刻收。 */
|
|
6629
|
+
const [hoverShot, setHoverShot] = React.useState(null)
|
|
6630
|
+
const hoverTimerRef = React.useRef(0)
|
|
6631
|
+
const hoverStart = React.useCallback((doc, src, event) => {
|
|
6632
|
+
if (!doc || doc.kind !== 'image' || !src) return
|
|
6633
|
+
if (hoverTimerRef.current) clearTimeout(hoverTimerRef.current)
|
|
6634
|
+
// 矩形从事件里取(真机有 currentTarget);取不到就交给纯函数走「视口居中」那条路
|
|
6635
|
+
let rect = null
|
|
6636
|
+
try {
|
|
6637
|
+
const el = event && event.currentTarget
|
|
6638
|
+
if (el && typeof el.getBoundingClientRect === 'function') rect = el.getBoundingClientRect()
|
|
6639
|
+
} catch { rect = null }
|
|
6640
|
+
const view = {
|
|
6641
|
+
width: typeof window !== 'undefined' && Number.isFinite(window.innerWidth) ? window.innerWidth : 1024,
|
|
6642
|
+
height: typeof window !== 'undefined' && Number.isFinite(window.innerHeight) ? window.innerHeight : 768,
|
|
6643
|
+
}
|
|
6644
|
+
const box = hoverShotBox(rect, view)
|
|
6645
|
+
hoverTimerRef.current = setTimeout(() => {
|
|
6646
|
+
hoverTimerRef.current = 0
|
|
6647
|
+
setHoverShot({ rel: doc.rel, src, box })
|
|
6648
|
+
}, HOVER_SHOT_DELAY_MS)
|
|
6649
|
+
}, [])
|
|
6650
|
+
const hoverEnd = React.useCallback(() => {
|
|
6651
|
+
if (hoverTimerRef.current) clearTimeout(hoverTimerRef.current)
|
|
6652
|
+
hoverTimerRef.current = 0
|
|
6653
|
+
setHoverShot((prev) => (prev ? null : prev))
|
|
6654
|
+
}, [])
|
|
6655
|
+
React.useEffect(() => () => {
|
|
6656
|
+
if (hoverTimerRef.current) clearTimeout(hoverTimerRef.current)
|
|
6657
|
+
}, [])
|
|
6658
|
+
|
|
5359
6659
|
return h('div', {
|
|
5360
6660
|
className: `knit-root${fullscreen ? ' fullscreen' : ''}`,
|
|
5361
6661
|
ref: rootRef,
|
|
6662
|
+
// v0.25 查找:捕获阶段(要抢在列表的 Esc 之前,见 onRootKeyDownCapture 的注释)
|
|
6663
|
+
onKeyDownCapture: onRootKeyDownCapture,
|
|
5362
6664
|
},
|
|
5363
6665
|
h('div', { className: 'knit-head' },
|
|
5364
6666
|
h('button', {
|
|
@@ -5389,16 +6691,22 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5389
6691
|
② 搜索排最后、贴最右:它只过滤当前列表,不重置排序与类型(§三.3)。
|
|
5390
6692
|
③ 六个选项彼此独立 —— 选「代码」再选「最新」= 最新的代码。
|
|
5391
6693
|
顺序即控件顺序,别再挪(细则在 CSS 那边的 .knit-bar / .knit-filter 注释里)。 */
|
|
6694
|
+
/* v0.25(2026-10-22 用户裁决):**媒体档不看相关性** ⇒ 这一组在那一档禁用,
|
|
6695
|
+
并且**如实显示「最新」在生效**(显示的是「当前实际顺序」,不是存着的偏好)。
|
|
6696
|
+
偏好本身不动:切回文档/代码还是你原来选的那个。
|
|
6697
|
+
⚠️ 是「禁用」不是「删掉」:控件不消失,布局不跳,鼠标悬停也有一句解释。 */
|
|
5392
6698
|
h('div', { className: 'knit-seg' },
|
|
5393
6699
|
h('button', {
|
|
5394
|
-
className: `knit-seg-btn${
|
|
6700
|
+
className: `knit-seg-btn${effectiveSort === 'relevance' ? ' active' : ''}`,
|
|
5395
6701
|
onClick: () => pickSort('relevance'),
|
|
5396
|
-
|
|
6702
|
+
disabled: kind === KIND_MEDIA,
|
|
6703
|
+
title: kind === KIND_MEDIA ? t('sort.mediaTimeTitle') : t('sort.relevanceTitle'),
|
|
5397
6704
|
}, t('sort.relevance')),
|
|
5398
6705
|
h('button', {
|
|
5399
|
-
className: `knit-seg-btn${
|
|
6706
|
+
className: `knit-seg-btn${effectiveSort === 'time' ? ' active' : ''}`,
|
|
5400
6707
|
onClick: () => pickSort('time'),
|
|
5401
|
-
|
|
6708
|
+
disabled: kind === KIND_MEDIA,
|
|
6709
|
+
title: kind === KIND_MEDIA ? t('sort.mediaTimeTitle') : t('sort.timeTitle'),
|
|
5402
6710
|
}, t('sort.time'))),
|
|
5403
6711
|
// ⚠️ 2026-10-12 用户裁决:排序组与类型组之间**那根竖线去掉了** —— 它的类名与 CSS 规则都已整体删除。
|
|
5404
6712
|
// 两组靠 `.knit-bar` 的 gap 分开就够 —— 「边界」不再需要一根线来表达。
|
|
@@ -5480,6 +6788,8 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5480
6788
|
ref: listRef,
|
|
5481
6789
|
tabIndex: 0,
|
|
5482
6790
|
onKeyDown: onListKeyDown,
|
|
6791
|
+
// v0.25:滚动就收起悬停大图 —— 它是 fixed 定位,不跟着卡片走,留着只会错位
|
|
6792
|
+
onScroll: hoverEnd,
|
|
5483
6793
|
role: 'listbox',
|
|
5484
6794
|
'aria-label': t('list.aria'),
|
|
5485
6795
|
// 焦点始终在容器上(roving 焦点会打断「移动即预览」),
|
|
@@ -5488,7 +6798,7 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5488
6798
|
'aria-activedescendant': navDocs.some((doc) => doc.rel === cursor)
|
|
5489
6799
|
? docOptionId(navDocs.find((doc) => doc.rel === cursor))
|
|
5490
6800
|
: undefined,
|
|
5491
|
-
},
|
|
6801
|
+
}, listBody())
|
|
5492
6802
|
/* ── 曾经在这里的一层:双栏装配 ────────────────────────
|
|
5493
6803
|
`if (!contextView) return listNode` 之后是 `.knit-context-layout`
|
|
5494
6804
|
(两列网格:左 `.knit-col-list` + 右 `.knit-context-column`)、
|
|
@@ -5507,6 +6817,22 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5507
6817
|
pathImages,
|
|
5508
6818
|
fullscreen,
|
|
5509
6819
|
ratio,
|
|
6820
|
+
// v0.25 查找:状态在 KnitBody,正文容器 ref 也交出去给 DOM 绘制用
|
|
6821
|
+
find: {
|
|
6822
|
+
on: findOn,
|
|
6823
|
+
query: findQuery,
|
|
6824
|
+
index: findIndex,
|
|
6825
|
+
count: findCount,
|
|
6826
|
+
inputRef: findInputRef,
|
|
6827
|
+
onOpen: openFind,
|
|
6828
|
+
onQuery: onFindQuery,
|
|
6829
|
+
onStep: findStep,
|
|
6830
|
+
onClose: closeFind,
|
|
6831
|
+
},
|
|
6832
|
+
bodyRef: previewBodyRef,
|
|
6833
|
+
// v0.25 媒体收藏
|
|
6834
|
+
favorite: favoriteSet.has(preview.rel),
|
|
6835
|
+
onToggleFavorite: toggleFavorite,
|
|
5510
6836
|
// v0.12 引用条
|
|
5511
6837
|
links,
|
|
5512
6838
|
linksExpanded,
|
|
@@ -5532,7 +6858,93 @@ video.knit-preview-media{width:100%;background:#000}
|
|
|
5532
6858
|
onClose: closePreview,
|
|
5533
6859
|
onToggleFullscreen: () => setFullscreen((v) => !v),
|
|
5534
6860
|
onResizeStart,
|
|
5535
|
-
}) : null
|
|
6861
|
+
}) : null,
|
|
6862
|
+
/* v0.25:媒体档「悬停看大图」。`position:fixed` + CSS 的 `pointer-events:none` ——
|
|
6863
|
+
它只是「看一眼」:不参与布局、不挡点击、不抢焦点。盒子由 `hoverShotBox()` 算好。 */
|
|
6864
|
+
hoverShot
|
|
6865
|
+
? h('div', {
|
|
6866
|
+
className: 'knit-shot',
|
|
6867
|
+
style: {
|
|
6868
|
+
left: `${hoverShot.box.left}px`,
|
|
6869
|
+
top: `${hoverShot.box.top}px`,
|
|
6870
|
+
width: `${hoverShot.box.width}px`,
|
|
6871
|
+
height: `${hoverShot.box.height}px`,
|
|
6872
|
+
},
|
|
6873
|
+
}, h('img', { src: hoverShot.src, alt: '', draggable: false }))
|
|
6874
|
+
: null,
|
|
6875
|
+
/* v0.25:媒体档「双击全屏」查看器。
|
|
6876
|
+
· 点**图片以外**(遮罩)⇒ 关;点图片本身 ⇒ 不关(`stopPropagation`),
|
|
6877
|
+
否则「点一下想看清细节」就把查看器点没了;
|
|
6878
|
+
· 左侧一列缩略图(当前这张附近 10 张)——点它换图,也不许冒泡去关;
|
|
6879
|
+
· `role="dialog"` + `aria-modal` + 可聚焦:Esc / ← → 由根上的捕获阶段接管。 */
|
|
6880
|
+
lightboxDoc
|
|
6881
|
+
? mountLightbox(h('div', {
|
|
6882
|
+
className: 'knit-lightbox',
|
|
6883
|
+
role: 'dialog',
|
|
6884
|
+
'aria-modal': 'true',
|
|
6885
|
+
'aria-label': t('lightbox.aria', { name: lightboxDoc.name || lightboxDoc.rel }),
|
|
6886
|
+
tabIndex: 0,
|
|
6887
|
+
ref: lightboxRef,
|
|
6888
|
+
onClick: lightboxClose,
|
|
6889
|
+
},
|
|
6890
|
+
h('div', {
|
|
6891
|
+
className: 'knit-lightbox-rail',
|
|
6892
|
+
ref: lightboxRailRef,
|
|
6893
|
+
onClick: (event) => { if (event && event.stopPropagation) event.stopPropagation() },
|
|
6894
|
+
}, lightboxRailView.items.map((doc, i) => h('button', {
|
|
6895
|
+
key: doc.rel,
|
|
6896
|
+
type: 'button',
|
|
6897
|
+
className: `knit-lightbox-thumb${doc.rel === lightboxDoc.rel ? ' active' : ''}`,
|
|
6898
|
+
title: doc.name || doc.rel,
|
|
6899
|
+
'data-thumb-index': lightboxRailView.start + i,
|
|
6900
|
+
onClick: () => setLightboxRel(doc.rel),
|
|
6901
|
+
}, h('img', { src: srcFor(doc), alt: '', draggable: false })))),
|
|
6902
|
+
/* 查看器工具条:「收藏」「本地打开」原来只活在**被撤掉的**媒体预览头里 ——
|
|
6903
|
+
不搬过来就等于静默丢掉两个功能(用户 2026-10-21 明确要过「收藏排第一」)。
|
|
6904
|
+
收藏只对工作区文件有意义(对话里的图还没有路径),所以对话图不显示这一条。 */
|
|
6905
|
+
h('div', { className: 'knit-lightbox-tools' },
|
|
6906
|
+
lightboxDoc.conversation
|
|
6907
|
+
? null
|
|
6908
|
+
: h('button', {
|
|
6909
|
+
className: 'knit-btn',
|
|
6910
|
+
type: 'button',
|
|
6911
|
+
onClick: () => toggleFavorite(lightboxDoc.rel),
|
|
6912
|
+
title: favoriteSet.has(lightboxDoc.rel) ? t('fav.removeTitle') : t('fav.addTitle'),
|
|
6913
|
+
}, favoriteSet.has(lightboxDoc.rel) ? t('fav.on') : t('fav.off')),
|
|
6914
|
+
lightboxDoc.conversation
|
|
6915
|
+
? null
|
|
6916
|
+
: h('button', {
|
|
6917
|
+
className: 'knit-btn',
|
|
6918
|
+
type: 'button',
|
|
6919
|
+
onClick: lightboxOpenLocal,
|
|
6920
|
+
title: t('preview.openLocal', { path: lightboxDoc.rel }),
|
|
6921
|
+
}, t('preview.openLocalBtn'))),
|
|
6922
|
+
/* 右上角 ✕ —— 照 DSH 自带查看器那套(全屏之后必须有一个**看得见的**出口:
|
|
6923
|
+
光靠「点图片以外」和 Esc,第一次用的人不知道往哪点)。 */
|
|
6924
|
+
h('button', {
|
|
6925
|
+
className: 'knit-lightbox-close',
|
|
6926
|
+
type: 'button',
|
|
6927
|
+
title: t('lightbox.close'),
|
|
6928
|
+
'aria-label': t('lightbox.close'),
|
|
6929
|
+
onClick: () => lightboxClose(),
|
|
6930
|
+
}, '✕'),
|
|
6931
|
+
/* 滚轮翻页:只在**图片这一块**生效。左列自己会滚(它 overflow-y:auto),
|
|
6932
|
+
在它上面滚轮应该滚列表,而不是换图 —— 所以监听挂在 stage 上、不挂在遮罩上。 */
|
|
6933
|
+
h('div', {
|
|
6934
|
+
className: 'knit-lightbox-stage',
|
|
6935
|
+
onWheel: (event) => {
|
|
6936
|
+
const delta = event && (event.deltaY || event.deltaX)
|
|
6937
|
+
if (!delta) return
|
|
6938
|
+
lightboxStep(delta > 0 ? 1 : -1)
|
|
6939
|
+
},
|
|
6940
|
+
}, h('img', {
|
|
6941
|
+
className: 'knit-lightbox-img',
|
|
6942
|
+
src: srcFor(lightboxDoc),
|
|
6943
|
+
alt: lightboxDoc.name || '',
|
|
6944
|
+
draggable: false,
|
|
6945
|
+
onClick: (event) => { if (event && event.stopPropagation) event.stopPropagation() },
|
|
6946
|
+
}))))
|
|
6947
|
+
: null)
|
|
5536
6948
|
}
|
|
5537
6949
|
|
|
5538
6950
|
/* ── 会话入口按钮 ───────────────────────────────── */
|