@coda-console/resource-manager 0.7.2 → 0.8.1
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/README.md +4 -1
- package/lib/info.mjs +9 -75
- package/lib/root.mjs +54 -9
- package/lib/search.mjs +138 -0
- package/lib/tree.mjs +8 -3
- package/lib/walk.mjs +154 -0
- package/main.mjs +20 -10
- package/package.json +1 -1
- package/view/app.mjs +216 -30
- package/view/bar.mjs +22 -2
- package/view/connection.mjs +17 -7
- package/view/file-app.mjs +8 -0
- package/view/find.mjs +254 -0
- package/view/grid.mjs +28 -12
- package/view/icons.mjs +2 -0
- package/view/index.html +8 -2
- package/view/locate.mjs +82 -0
- package/view/menu.mjs +16 -5
- package/view/model.mjs +67 -20
- package/view/press.mjs +2 -1
- package/view/preview.mjs +47 -8
- package/view/protocol.mjs +36 -4
- package/view/rootname.mjs +109 -0
- package/view/search.mjs +144 -0
- package/view/searchbar.mjs +27 -0
- package/view/style.css +56 -2
- package/view/tree.mjs +44 -25
package/README.md
CHANGED
|
@@ -11,12 +11,15 @@ Coda 插件:会话旁的文件浏览器。浏览这个会话的工作目录,
|
|
|
11
11
|
- **Mac 照 Finder**:**按下**就选中(不等松开),**双击**打开——文件在侧栏里切到预览,文件夹在列表里展开或收起、在图标视图里进入;单击展开箭头只展开,选中不变;按下空白取消选中;右键和按住 Control 的左键不改选中;右键菜单第一项是「打开」(文件夹在列表里写「展开」「收起」),不能打开的条目没有。**iPhone** 轻点就打开(文件夹展开或进入,文件在页内切到预览,不另开页面)。
|
|
12
12
|
- **按键的质感**(`0.7.2`):两端按下就有底色反馈(页面自己加状态,不靠 `:active`;快点一下也看得到,滑动时不闪;菜单开着时点外面那一下只关菜单),Mac 的按钮是箭头光标;菜单有阴影,iPhone 的菜单出现时有淡入加缩放;iPhone 打开文件、属性页和返回(含侧滑)是滑动过渡,图标视图进出目录是淡入。系统打开「减弱动态效果」后所有动画和过渡都不做,按下反馈照常。没有触感(契约没有这个接口)。
|
|
13
13
|
- 图标视图回上一层:iPhone 用系统的返回,Mac 点头部最左边的返回键或按 ⌘↑,退回的那一层里选中刚才进去的文件夹。**没有预览面板**:只有一个侧栏,也没有面包屑。
|
|
14
|
-
- **Mac 的键盘**:点一下目录树或图标视图让它拿到焦点(Tab 也能进来),↑ ↓ 移动选中(图标视图按行列走),列表里 → 展开、← 收起或选中所在的文件夹,图标视图里 ← → 选左右的条目;⌘↓ 同双击(打开、展开、进入);⌘↑
|
|
14
|
+
- **Mac 的键盘**:点一下目录树或图标视图让它拿到焦点(Tab 也能进来),↑ ↓ 移动选中(图标视图按行列走),列表里 → 展开、← 收起或选中所在的文件夹,图标视图里 ← → 选左右的条目;⌘↓ 同双击(打开、展开、进入);⌘↑ 在图标视图里回上一层,在预览里返回目录树或图标视图;⌘F 聚焦搜索框。搜索框里 ↓ 进结果,Esc 清空;结果里 Esc 回搜索框。不做多选、按字母跳转,Return 和空格也没绑定。读屏的 `aria-activedescendant` 没做(见 `docs/backlog.md`)。
|
|
15
15
|
- 文本预览(带行号,可跨行选中复制,最多读 1 MiB)和图片预览(PNG、JPEG、GIF、WebP、SVG,最多 8 MiB)。
|
|
16
16
|
- 代码按语言上色:三十多种常见语言,只按文件名和扩展名认,不猜内容,深浅各一套配色;认不出的显示纯文本。超过 128 KiB 的文件不上色,说明区注明「不高亮」。用的是近似的语法规则,不是语法检查,个别文件会认错(如 `.h` 一律按 C++,`.m` 一律按 Objective-C),不保证完整支持。
|
|
17
17
|
- Agent 一轮结束后,已展开的目录和正在看的文件自动更新。
|
|
18
18
|
- 每行带修改日期和大小:Mac 在名字右边(按日期排序时显示日期,否则显示大小,侧栏很窄时隐藏),iPhone 在名字下面一行。右键或长按的菜单里有大小和完整修改时间。文件夹不显示大小(列表和菜单都没有),只有修改日期。
|
|
19
19
|
- 可以按名称、种类、日期、大小排序,在「更多」菜单(Mac)或「⋯」菜单(iPhone)的「显示」›「排序」里选,当前项有对勾。两种视图用同一个排序。每种排序的方向固定:名称、种类升序,日期、大小降序(最新、最大在前),没有升降序切换。超过 2 万条的目录,日期和大小排序不可用,退回按名称并提示。排序全局一份,换了排序滚动位置回到顶部,选当前项什么都不做。
|
|
20
|
+
- **文件名搜索**(`0.8.0`):目录树和图标视图顶上常驻一个搜索框,Mac 按 ⌘F 聚焦它(选中里面的字)。有字时列表换成结果,清空(Esc 或清除按钮)回到原来的浏览,展开、滚动、选中都还在。搜整个工作目录(后台逐层走,先浅后深),只比**名字**,不比路径(带斜杠的词找不到):不分大小写、包含就算,中文和分解形式的字(如 `é` 的两种写法)都能找到。始终不进 `.git`、`node_modules`(它们自己能作为结果),隐藏文件跟「显示隐藏文件」开关,不跟着链接进目录,不读 `.gitignore`。最多 500 条,最多看 20 万项或 5 秒,到了就停并注明「没搜完」,只显示已找到的;每次重新走树,没有索引。结果按「名字以搜索词开头的在前、浅的在前、再按名称」排,不跟「显示」菜单的排序走。每行是图标、名字(匹配的部分加粗)、所在目录(Mac 在右边,iPhone 在第二行)。Mac 单击选中、双击或 ⌘↓ 打开,↑ ↓ 移动;iPhone 轻点打开;右键或长按有「打开」「添加到聊天」「复制路径」「在目录中显示」「属性」。「在目录中显示」逐级展开(图标视图是进入它所在的目录)并把它选中、滚到中间;这期间你点、滚、按键、打开东西就停下,不会和你抢。结果里打开文件夹也是先定位再展开(或进入)它。刷新、「一轮结束」和切换「显示隐藏文件」会重搜;搜索词和结果不存进会话状态,页面重建后是空的。iPhone 的系统返回:结果里打开的预览或属性页返回到结果,结果本身不算一级。
|
|
21
|
+
- **文件内查找**(`0.8.0`):只找打开的这个文本文件。Mac 在侧栏预览或独立窗口里按 ⌘F,iPhone 在预览头部「⋯」菜单里点「查找」,预览头部下面出现查找条:输入框、「3/17」、上一个、下一个、完成。不分大小写,高亮全部匹配,当前这一处颜色更深并滚到可见区;回车或 ⌘G 下一个,Shift+回车或 ⇧⌘G 上一个(首尾循环);Esc 或「完成」关闭。最多标 10000 处,超过写「10000+」,导航只在前 10000 处里走。图片、二进制、读取中、读不到的文件没有查找(⌘F 不拦,菜单里没有这一项)。文件内容变了(刷新、Agent 一轮结束)时查找词和查找条留着、重新找,当前这一处取离原来最近的;打开别的文件、换了根目录、关预览,查找条一并关闭。高亮用浏览器的 Custom Highlight API,不支持的环境只计数、上一个下一个和滚动,不标颜色。有长行的文件(和代码上色共用的门槛:有一行超过 5000 字,如压缩过的 JS)不标高亮,只计数、上一个下一个和滚动:长行里注册高亮会让浏览器同步重画整行,页面会卡死(实测 50 KiB 单行超过 20 秒)。当前这一处文字用正文色,不显示代码着色。
|
|
22
|
+
- **worktree 会话的标题**(`0.8.1`):Coda 的 worktree 目录以一串 UUID 命名,只看目录名认不出项目。会话的工作目录是 worktree 时,根目录标题(Mac 目录树上方、iPhone 顶部工具条、图标视图头部)写成「项目名 worktree-编号」,如 `ActaView worktree-c037`:项目名是 Coda 里这个会话所属项目的名字(粗体;默认就是原仓库的文件夹名,在 Coda 里改过名字时显示改后的),后缀用常规字重、浅灰、小一号;编号是目录名(UUID)的前 4 位,目录名不是 UUID 时取整个目录名。放不下时依次:后缀缩成 `wt-编号`(完整写法超过可用宽度的 90% 就缩,不贴边),再把项目名从中间省略(至少留 2 个字,`wt-编号` 不动),最后整段从尾部省略;拖侧栏、转屏时重算。Mac 目录树的标题比以前大一号(普通文件夹名也是);悬停标题显示完整路径,属性页的名称和路径不变;iPhone 的系统返回里是纯文字的完整写法。项目名从 Coda 的项目列表取(会话详情里的项目 id,加上 `agents` 回答里的项目列表,这两样都不是文档写明的接口,集中在 `lib/root.mjs` 一处;列表缓存一分钟,查不到 id 时重取),不读 git 元数据,也不读工作目录之外的任何文件;取不到、或者会话的工作目录不是 worktree 时,照旧显示文件夹名。
|
|
20
23
|
- 切换会话时换成新会话的内容,切回来恢复展开状态和滚动位置。
|
|
21
24
|
- 右键(Mac)或长按(iPhone)一行:添加到聊天、复制相对路径、复制绝对路径、属性。「添加到聊天」把相对路径接在输入框已有文字后面;指向工作目录外或已失效的链接、不能打开的条目没有这一项。成功时底部提示「已添加到输入框」,约 2 秒消失;写不进去时改为复制,提示「没能写入输入框,已复制」;剪贴板也写不进去时提示「没能写入,也没能复制」。
|
|
22
25
|
- **选中文字右键(只有 Mac)**:在文件预览(侧栏和独立窗口)里选中文字后右键,有「添加到聊天(内容)」「添加到聊天(位置)」「复制」。位置是 `src/app.ts:12-18`,只选一行时是 `src/app.ts:12`,只精确到行。选中的内容太长放不进一条消息时直接复制,提示「选中内容太长,已复制」。iPhone 用系统自带的选区菜单,不加这一项。
|
package/lib/info.mjs
CHANGED
|
@@ -4,11 +4,10 @@ import { basename, join, relative, sep } from 'node:path';
|
|
|
4
4
|
import { EntryKind } from '../view/protocol.mjs';
|
|
5
5
|
import { fromFsError, parseRelative, resolveInRoot } from './paths.mjs';
|
|
6
6
|
import { classifyLink } from './tree.mjs';
|
|
7
|
+
import { startWalk } from './walk.mjs';
|
|
7
8
|
|
|
8
9
|
export const DIR_SIZE_ITEMS = 200_000;
|
|
9
10
|
export const DIR_SIZE_MS = 5000;
|
|
10
|
-
// 一批同时排进并发上限的 lstat 数;等它们回来才排下一批。
|
|
11
|
-
const BATCH = 4;
|
|
12
11
|
|
|
13
12
|
const integer = value => (Number.isFinite(value) ? Math.floor(value) : undefined);
|
|
14
13
|
|
|
@@ -54,84 +53,19 @@ export async function statPath(listing, root, path) {
|
|
|
54
53
|
return { ...body, ...metaOf(info, kind) };
|
|
55
54
|
}
|
|
56
55
|
|
|
57
|
-
//
|
|
58
|
-
// - 同一时间只读一个目录,用只取名字的 readdir(不用 opendir、withFileTypes:文件系统不报类型时它们可能同步 lstat)。
|
|
59
|
-
// - lstat 一批最多 BATCH 个,经视图的并发上限排队,等回来才排下一批;排到名额后先核对停止条件再读。
|
|
56
|
+
// 文件夹大小:边读边统计,走树的部分在 lib/walk.mjs(深度优先、什么目录都进,包括 .git)。
|
|
60
57
|
// - 不跟随链接:链接算一项,不计大小。
|
|
61
58
|
// - 项数到 limit 或用时到 timeoutMs,立刻回答 complete: false,已发出的读取结果不再计入;
|
|
62
59
|
// signal 中止、valid() 为假(会话、根目录变了或视图关了)静默停止,返回 null,不回答。
|
|
63
60
|
// - 5 秒从收到请求算起:计时和取消监听先建,解析起点(resolve,默认 resolveInRoot)与它们竞速;
|
|
64
61
|
// 解析回来先核对 valid() 和 signal,才读。到点还没解析完回答 items: 0、complete: false;解析失败按错误回答。
|
|
65
62
|
// - 子目录读不到、条目 lstat 失败都计入 unreadable;起点读不到才算错误。
|
|
66
|
-
export async function dirSize(listing, root, path, {
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
let over = false;
|
|
72
|
-
|
|
73
|
-
return new Promise((resolve, reject) => {
|
|
74
|
-
let timer = null;
|
|
75
|
-
// 结算一次:之后的一切读取结果、定时器、中止都不再有影响。
|
|
76
|
-
const settle = done => {
|
|
77
|
-
if (over) return;
|
|
78
|
-
over = true;
|
|
79
|
-
clearTimeout(timer);
|
|
80
|
-
signal?.removeEventListener('abort', onAbort);
|
|
81
|
-
done();
|
|
82
|
-
};
|
|
83
|
-
const end = result => settle(() => resolve(result));
|
|
84
|
-
const onAbort = () => end(null);
|
|
85
|
-
// 停了没有。valid() 为假或已中止的在这里顺便结算成静默停止。
|
|
86
|
-
const stopped = () => {
|
|
87
|
-
if (over) return true;
|
|
88
|
-
if (signal?.aborted || !valid()) { end(null); return true; }
|
|
89
|
-
return false;
|
|
90
|
-
};
|
|
91
|
-
|
|
92
|
-
if (signal?.aborted) return end(null);
|
|
93
|
-
signal?.addEventListener('abort', onAbort, { once: true });
|
|
94
|
-
timer = setTimeout(() => end({ ...total, complete: false }), timeoutMs);
|
|
95
|
-
|
|
96
|
-
// 数一个条目。读失败的也算一项。
|
|
97
|
-
async function measure(dir, name, dirs) {
|
|
98
|
-
if (stopped()) return; // 排到名额之后先核对
|
|
99
|
-
let info = null;
|
|
100
|
-
try { info = await fs.lstat(join(dir, name)); } catch { /* 下面计入 unreadable */ }
|
|
101
|
-
if (stopped()) return; // 已经停了,回来的结果不再计入
|
|
102
|
-
total.items++;
|
|
103
|
-
if (!info) total.unreadable++;
|
|
104
|
-
else if (info.isDirectory()) dirs.push(join(dir, name));
|
|
105
|
-
else if (info.isFile()) total.size += Math.max(0, Math.floor(info.size) || 0);
|
|
106
|
-
}
|
|
107
|
-
|
|
108
|
-
async function walk() {
|
|
109
|
-
// 解析慢时由计时和中止先结算;这里回来之后 stopped() 再核对一遍,已经停了就不读。
|
|
110
|
-
const start = await resolvePath(root, path);
|
|
111
|
-
if (stopped()) return;
|
|
112
|
-
const dirs = [start]; // 待访问的目录,数量不超过项数上限
|
|
113
|
-
while (dirs.length > 0 && !stopped()) {
|
|
114
|
-
const dir = dirs.pop();
|
|
115
|
-
let names;
|
|
116
|
-
try { names = await fs.readdir(dir); } catch (error) {
|
|
117
|
-
if (dir === start) throw fromFsError(error);
|
|
118
|
-
if (stopped()) return;
|
|
119
|
-
total.unreadable++;
|
|
120
|
-
continue;
|
|
121
|
-
}
|
|
122
|
-
let at = 0;
|
|
123
|
-
while (at < names.length) {
|
|
124
|
-
if (stopped()) return;
|
|
125
|
-
if (total.items >= limit) return end({ ...total, complete: false });
|
|
126
|
-
const batch = names.slice(at, at + Math.min(BATCH, limit - total.items));
|
|
127
|
-
at += batch.length;
|
|
128
|
-
await Promise.all(batch.map(name => listing.run(() => measure(dir, name, dirs))));
|
|
129
|
-
}
|
|
130
|
-
if (!stopped() && total.items >= limit && dirs.length > 0) return end({ ...total, complete: false });
|
|
131
|
-
}
|
|
132
|
-
end({ ...total, complete: true });
|
|
133
|
-
}
|
|
134
|
-
|
|
135
|
-
walk().catch(error => settle(() => reject(error)));
|
|
63
|
+
export async function dirSize(listing, root, path, { valid, signal, limit = DIR_SIZE_ITEMS, timeoutMs = DIR_SIZE_MS, resolve } = {}) {
|
|
64
|
+
let size = 0;
|
|
65
|
+
const walk = startWalk(listing, root, path, {
|
|
66
|
+
valid, signal, limit, timeoutMs, resolve,
|
|
67
|
+
visit: ({ info }) => { if (info.isFile()) size += Math.max(0, Math.floor(info.size) || 0); return true; },
|
|
136
68
|
});
|
|
69
|
+
const done = await walk.result;
|
|
70
|
+
return done && { size, items: done.items, unreadable: done.unreadable, complete: done.reason === 'done' };
|
|
137
71
|
}
|
package/lib/root.mjs
CHANGED
|
@@ -1,26 +1,71 @@
|
|
|
1
|
-
// 从会话取根目录。这是唯一读取 `threads/<id>` 返回结构(checkout
|
|
1
|
+
// 从会话取根目录。这是唯一读取 `threads/<id>` 返回结构(checkout)和 `agents` 返回结构(projects)的地方,它们都不是文档写明的契约。
|
|
2
2
|
import { realpath, stat } from 'node:fs/promises';
|
|
3
3
|
import { RootState } from '../view/protocol.mjs';
|
|
4
4
|
|
|
5
|
-
export const NO_ROOT = Object.freeze({ state: RootState.NONE, path: null });
|
|
5
|
+
export const NO_ROOT = Object.freeze({ state: RootState.NONE, path: null, project: null });
|
|
6
6
|
|
|
7
|
-
|
|
7
|
+
// project 不是根目录的身份(保存、恢复、换根都只看路径),但变了页面要重画标题,所以算进来。
|
|
8
|
+
export const sameRoot = (a, b) => a?.state === b?.state && a?.path === b?.path && (a?.project ?? null) === (b?.project ?? null);
|
|
9
|
+
|
|
10
|
+
// worktree 的项目名:Coda 里这个会话所属项目的名字。Coda 的 worktree 目录以 UUID 命名,只看目录名认不出项目。
|
|
11
|
+
// 项目 id 是会话详情里 checkout 的 projectId(缺了看 detail.thread.projectId),名字查 `agents` 回答里的 projects([{ id, name }])。
|
|
12
|
+
// 会话详情 `threads/<id>` 的回答结构是 { thread: { …, projectId }, draft, checkout, … }:thread 是详情里的一个字段,checkout 和它并列,不是 thread 的子字段。
|
|
13
|
+
// 项目名默认是原仓库的文件夹名;在 Coda 里改过名字时显示改后的。不读任何文件:项目名不来自工作目录之外的东西(设计第 19.7 节)。
|
|
14
|
+
// 取不到(没有 id、接口失败、列表里没有这个 id、名字为空)都是 null,页面退回显示文件夹名;这里从不抛:
|
|
15
|
+
// queryRoot 抛出的意思是「保留上一次的根目录」,项目名取不到不该触发它。
|
|
16
|
+
// 项目列表按机器缓存(WeakMap:一个 coda 一份),很少变:超过 MAX_AGE 或查不到这个 id 时重取,两次请求之间至少隔 MISS_AGE(接口失败也算一次),不会反复请求;同时发起的查询共用一次请求。
|
|
17
|
+
const MAX_AGE = 60_000, MISS_AGE = 5_000, NAME_LIMIT = 256;
|
|
18
|
+
const caches = new WeakMap(); // coda → { names: Map(id → name) | null, at: 上次请求的时间, pending: 在途的请求 | null }
|
|
19
|
+
|
|
20
|
+
// 名字:去掉首尾空白,空的、含控制字符的不用,太长的按码点截断。
|
|
21
|
+
function cleanName(name) {
|
|
22
|
+
if (typeof name !== 'string') return null;
|
|
23
|
+
const text = name.trim();
|
|
24
|
+
if (!text || /\p{Cc}/u.test(text)) return null;
|
|
25
|
+
return Array.from(text).slice(0, NAME_LIMIT).join('');
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
async function fetchNames(coda, cache, now) {
|
|
29
|
+
cache.at = now();
|
|
30
|
+
try {
|
|
31
|
+
const reply = await coda.api('agents');
|
|
32
|
+
const names = new Map();
|
|
33
|
+
for (const project of Array.isArray(reply?.projects) ? reply.projects : []) {
|
|
34
|
+
if (typeof project?.id === 'string' && project.id) names.set(project.id, cleanName(project.name));
|
|
35
|
+
}
|
|
36
|
+
cache.names = names;
|
|
37
|
+
} catch { /* 取不到:保留上一次的列表,名字退回文件夹名 */ }
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
async function projectNameOf(coda, projectId, now) {
|
|
41
|
+
if (typeof projectId !== 'string' || !projectId) return null;
|
|
42
|
+
try {
|
|
43
|
+
let cache = caches.get(coda);
|
|
44
|
+
if (!cache) caches.set(coda, cache = { names: null, at: -Infinity, pending: null });
|
|
45
|
+
const age = now() - cache.at, stale = !cache.names || age >= MAX_AGE || (!cache.names.has(projectId) && age >= MISS_AGE);
|
|
46
|
+
if (stale) await (cache.pending ??= fetchNames(coda, cache, now).finally(() => { cache.pending = null; }));
|
|
47
|
+
else if (cache.pending) await cache.pending;
|
|
48
|
+
return cache.names?.get(projectId) ?? null;
|
|
49
|
+
} catch {
|
|
50
|
+
return null;
|
|
51
|
+
}
|
|
52
|
+
}
|
|
8
53
|
|
|
9
54
|
// checkout.state 是 preparing、ready、failed。failed 没有可看的目录,按 none;
|
|
10
55
|
// ready 但目录已不在(归档后工作树被回收)是 gone。
|
|
11
56
|
// 查询失败(接口出错、读目录权限)直接抛出,由调用方保留上一次的结果。
|
|
12
|
-
export async function queryRoot(coda, session) {
|
|
57
|
+
export async function queryRoot(coda, session, { now = Date.now } = {}) {
|
|
13
58
|
if (!session) return NO_ROOT;
|
|
14
|
-
const
|
|
15
|
-
const checkout =
|
|
59
|
+
const detail = await coda.api(`threads/${encodeURIComponent(session)}`);
|
|
60
|
+
const checkout = detail?.checkout;
|
|
16
61
|
if (!checkout || typeof checkout !== 'object') return NO_ROOT;
|
|
17
|
-
if (checkout.state === 'preparing') return { state: RootState.PREPARING, path: null };
|
|
62
|
+
if (checkout.state === 'preparing') return { state: RootState.PREPARING, path: null, project: null };
|
|
18
63
|
if (checkout.state !== 'ready' || typeof checkout.path !== 'string' || !checkout.path) return NO_ROOT;
|
|
19
64
|
try {
|
|
20
65
|
const real = await realpath(checkout.path);
|
|
21
|
-
if ((await stat(real)).isDirectory()) return { state: RootState.READY, path: real };
|
|
66
|
+
if ((await stat(real)).isDirectory()) return { state: RootState.READY, path: real, project: checkout.kind === 'worktree' ? await projectNameOf(coda, checkout.projectId ?? detail.thread?.projectId, now) : null };
|
|
22
67
|
} catch (error) {
|
|
23
68
|
if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') throw error;
|
|
24
69
|
}
|
|
25
|
-
return { state: RootState.GONE, path: checkout.path };
|
|
70
|
+
return { state: RootState.GONE, path: checkout.path, project: null };
|
|
26
71
|
}
|
package/lib/search.mjs
ADDED
|
@@ -0,0 +1,138 @@
|
|
|
1
|
+
// 文件名搜索(设计见 docs/design/phase-3.md 第 18.2 节):按层走完整棵工作目录,只比名字,不分大小写,包含就算。
|
|
2
|
+
// 走树本身在 lib/walk.mjs(和文件夹大小共用);这里管请求校验、单槽、排空屏障、匹配、收集、排序和字节上限。
|
|
3
|
+
//
|
|
4
|
+
// 每个异步机制的五样(谁持有、何时开始、何时结束、超时、被替换或作废):
|
|
5
|
+
// - 搜索槽 slot:{ generation, requestId, root, abort },由这个视图的 searcher 持有。search 请求收到时开始,回答(或静默)时结束;
|
|
6
|
+
// 新的 search 先中止旧的(旧的静默结束);search_cancel 要代次和请求号都对上才中止;hello(页面重建)、换会话、根目录变化、视图关闭时 clear。
|
|
7
|
+
// 回答前(成功和出错两个出口)都核对 alive():槽里还是我、没被中止、valid()(代次、根目录)仍成立,不是就静默结束。
|
|
8
|
+
// - 排空屏障 barrier:上一次走树的 drained。走树启动时换成它自己的,到排空(已停止派发且启动过的读取全部结束)才算数;
|
|
9
|
+
// 它独立于槽:被替换、hello 清槽都只让旧走树停止派发,屏障留着,新的搜索照样要等。
|
|
10
|
+
// - 待启动:收到请求之后、屏障排空之前,请求在这里等。位置只有一个:更新的请求先中止它,它醒来发现自己不是最新就退出,不回答、不取得读取权。
|
|
11
|
+
// - 5 秒计时 deadline:请求收到时开始(含等屏障),结算时清掉。到点还在等屏障就回答空结果和 stop: 'time'、scanned: 0;已经在走就 stop('time'),回答已收集的。
|
|
12
|
+
// 被替换、取消、作废时和请求一起结束,不回答。
|
|
13
|
+
import { Buffer } from 'node:buffer';
|
|
14
|
+
import { EntryKind, ErrorCode, MAX_PATH, PAGE_BYTES, QUERY_MAX, SEARCH_RESULTS, Type, fail, foldName, hasControl, isHidden } from '../view/protocol.mjs';
|
|
15
|
+
import { classifyLink, compareNames } from './tree.mjs';
|
|
16
|
+
import { QUEUE_BYTES, WALK_ITEMS, startWalk } from './walk.mjs';
|
|
17
|
+
|
|
18
|
+
export const SEARCH_MS = 5000;
|
|
19
|
+
// 搜索自己的规则:始终不进这两种目录(它们自己可以作为结果);不是隐藏名单,不随「显示隐藏文件」。
|
|
20
|
+
const SKIP_DIRS = new Set(['.git', 'node_modules']);
|
|
21
|
+
|
|
22
|
+
// 请求校验:query 是字符串,去掉首尾空白后 1~QUERY_MAX 个字符(UTF-16 单元),不含控制字符;hidden 是布尔值。
|
|
23
|
+
function parse(message) {
|
|
24
|
+
const query = typeof message.query === 'string' ? message.query.trim() : null;
|
|
25
|
+
if (query === null || query === '' || query.length > QUERY_MAX || hasControl(query) || typeof message.hidden !== 'boolean') {
|
|
26
|
+
throw fail(ErrorCode.INVALID_QUERY, '搜索词无效');
|
|
27
|
+
}
|
|
28
|
+
return { folded: foldName(query), hidden: message.hidden };
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
const depthOf = path => path.split('/').length;
|
|
32
|
+
function comparePaths(a, b) {
|
|
33
|
+
const x = a.split('/'), y = b.split('/');
|
|
34
|
+
for (let i = 0; i < Math.min(x.length, y.length); i++) {
|
|
35
|
+
const order = compareNames(x[i], y[i]);
|
|
36
|
+
if (order !== 0) return order;
|
|
37
|
+
}
|
|
38
|
+
return x.length - y.length;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
// 排序:名字以搜索词开头的在前;同一组里浅的在前;再按路径逐段用目录列表的名称比较。
|
|
42
|
+
function sortResults(results, folded) {
|
|
43
|
+
const keyed = results.map(item => {
|
|
44
|
+
const name = item.path.slice(item.path.lastIndexOf('/') + 1);
|
|
45
|
+
return { item, starts: foldName(name).startsWith(folded) ? 0 : 1, depth: depthOf(item.path) };
|
|
46
|
+
});
|
|
47
|
+
keyed.sort((a, b) => a.starts - b.starts || a.depth - b.depth || comparePaths(a.item.path, b.item.path));
|
|
48
|
+
return keyed.map(({ item }) => item);
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
// 最终回答(含信封)的 JSON UTF-8 字节不超过 pageBytes:排好序后从尾部去掉放不下的。返回保留的条数。
|
|
52
|
+
function fit(results, envelope, pageBytes) {
|
|
53
|
+
let used = Buffer.byteLength(JSON.stringify({ ...envelope, results: [] })), count = 0;
|
|
54
|
+
for (const item of results) {
|
|
55
|
+
const size = Buffer.byteLength(JSON.stringify(item)) + (count > 0 ? 1 : 0);
|
|
56
|
+
if (used + size > pageBytes) break;
|
|
57
|
+
used += size;
|
|
58
|
+
count++;
|
|
59
|
+
}
|
|
60
|
+
return count;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
// limits 只给测试用:results、items、timeoutMs、queueBytes、pageBytes、resolve(起点解析,默认 resolveInRoot)。
|
|
64
|
+
export function createSearcher(listing, limits = {}) {
|
|
65
|
+
const {
|
|
66
|
+
results: maxResults = SEARCH_RESULTS, items = WALK_ITEMS, timeoutMs = SEARCH_MS, queueBytes = QUEUE_BYTES, pageBytes = PAGE_BYTES, resolve,
|
|
67
|
+
} = limits;
|
|
68
|
+
let slot = null;
|
|
69
|
+
let barrier = Promise.resolve();
|
|
70
|
+
|
|
71
|
+
async function search(message, { root, valid, generation, requestId }) {
|
|
72
|
+
const { folded, hidden } = parse(message);
|
|
73
|
+
const mine = { generation, requestId, root, abort: new AbortController() };
|
|
74
|
+
slot?.abort.abort();
|
|
75
|
+
slot = mine;
|
|
76
|
+
const alive = () => slot === mine && !mine.abort.signal.aborted && valid();
|
|
77
|
+
|
|
78
|
+
let expired = false, walk = null, wake = () => {};
|
|
79
|
+
const woken = new Promise(done => { wake = done; });
|
|
80
|
+
const deadline = setTimeout(() => { expired = true; if (walk) walk.stop('time'); else wake(); }, timeoutMs);
|
|
81
|
+
mine.abort.signal.addEventListener('abort', wake, { once: true });
|
|
82
|
+
try {
|
|
83
|
+
await Promise.race([barrier, woken]); // 待启动:等上一次走树排空
|
|
84
|
+
if (!alive()) return null;
|
|
85
|
+
if (expired) return { results: [], stop: 'time', scanned: 0, unreadable: 0 };
|
|
86
|
+
|
|
87
|
+
const found = [];
|
|
88
|
+
walk = startWalk(listing, root, '', {
|
|
89
|
+
order: 'breadth', ordered: true, valid: alive, signal: mine.abort.signal, limit: items, queueBytes, resolve,
|
|
90
|
+
async visit({ dir, tag, name, info, stop }) {
|
|
91
|
+
const rel = tag === '' ? name : `${tag}/${name}`;
|
|
92
|
+
if (rel.length > MAX_PATH) return false; // 路径放不进协议:不算结果,也不进
|
|
93
|
+
const control = hasControl(name), hiddenName = !hidden && isHidden(name);
|
|
94
|
+
if (!hiddenName && foldName(name).includes(folded)) {
|
|
95
|
+
// 名字含控制字符的算 other(只显示,不能打开),不进
|
|
96
|
+
let kind = control ? EntryKind.OTHER : info.isDirectory() ? EntryKind.DIR : info.isFile() ? EntryKind.FILE : EntryKind.OTHER, link = false;
|
|
97
|
+
if (!control && info.isSymbolicLink()) {
|
|
98
|
+
// 匹配上的链接按目录列表的规则分类(经并发上限,计入在途读取)
|
|
99
|
+
const linked = await walk.track(() => listing.run(() => classifyLink(listing.fs, root, dir, name)));
|
|
100
|
+
if (walk.done()) return false;
|
|
101
|
+
({ kind } = linked);
|
|
102
|
+
link = linked.link === true;
|
|
103
|
+
}
|
|
104
|
+
found.push({ path: rel, kind, ...(link ? { link: true } : {}) });
|
|
105
|
+
if (found.length >= maxResults) stop('count');
|
|
106
|
+
}
|
|
107
|
+
return !control && !hiddenName && info.isDirectory() && !SKIP_DIRS.has(name) ? { tag: rel } : false;
|
|
108
|
+
},
|
|
109
|
+
});
|
|
110
|
+
barrier = walk.drained;
|
|
111
|
+
const done = await walk.result;
|
|
112
|
+
if (done === null || !alive()) return null;
|
|
113
|
+
|
|
114
|
+
const sorted = sortResults(found, folded);
|
|
115
|
+
const body = { stop: done.reason, scanned: done.items, unreadable: done.unreadable };
|
|
116
|
+
const keep = fit(sorted, { type: Type.SEARCHED, generation, requestId, ...body }, pageBytes);
|
|
117
|
+
if (keep < sorted.length && (body.stop === 'done' || body.stop === 'count')) body.stop = 'bytes';
|
|
118
|
+
return { results: sorted.slice(0, keep), ...body };
|
|
119
|
+
} catch (error) {
|
|
120
|
+
if (!alive()) return null; // 出错的出口也核对身份
|
|
121
|
+
throw error;
|
|
122
|
+
} finally {
|
|
123
|
+
clearTimeout(deadline);
|
|
124
|
+
mine.abort.signal.removeEventListener('abort', wake);
|
|
125
|
+
if (slot === mine) slot = null;
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
return {
|
|
130
|
+
search,
|
|
131
|
+
// 取消:代次和请求号都对上才停,迟到的取消不会误伤新的搜索。
|
|
132
|
+
cancel({ generation, requestId }) {
|
|
133
|
+
if (slot?.generation === generation && slot.requestId === requestId) slot.abort.abort();
|
|
134
|
+
},
|
|
135
|
+
// 页面重建、换会话、根目录变化、视图关闭:中止当前搜索。屏障不清,旧走树的读取排空之前新的搜索照样要等。
|
|
136
|
+
clear() { slot?.abort.abort(); slot = null; },
|
|
137
|
+
};
|
|
138
|
+
}
|
package/lib/tree.mjs
CHANGED
|
@@ -60,6 +60,13 @@ function keyOf(entry, key) {
|
|
|
60
60
|
// 每种排序的方向,只在这里定义:名称、种类升序,日期、大小降序(最新、最大在前)。
|
|
61
61
|
const DESCENDING = new Set([SortKey.DATE, SortKey.SIZE]);
|
|
62
62
|
|
|
63
|
+
// 名字的比较:不分大小写升序,平手按原名。目录列表的名称排序和搜索结果的路径排序共用。
|
|
64
|
+
export function compareNames(a, b) {
|
|
65
|
+
const p = a.toLowerCase(), q = b.toLowerCase();
|
|
66
|
+
if (p !== q) return p < q ? -1 : 1;
|
|
67
|
+
return a === b ? 0 : a < b ? -1 : 1;
|
|
68
|
+
}
|
|
69
|
+
|
|
63
70
|
// 全序:文件夹在前(不随方向反向);键按该排序的方向,缺的不管方向都在最后;平手按名字(不分大小写)升序,最后按原名。
|
|
64
71
|
function comparer(key) {
|
|
65
72
|
const desc = DESCENDING.has(key);
|
|
@@ -71,9 +78,7 @@ function comparer(key) {
|
|
|
71
78
|
if (y === undefined) return -1;
|
|
72
79
|
return (x < y ? -1 : 1) * (desc ? -1 : 1);
|
|
73
80
|
}
|
|
74
|
-
|
|
75
|
-
if (p !== q) return p < q ? -1 : 1;
|
|
76
|
-
return a.name === b.name ? 0 : a.name < b.name ? -1 : 1;
|
|
81
|
+
return compareNames(a.name, b.name);
|
|
77
82
|
};
|
|
78
83
|
}
|
|
79
84
|
|
package/lib/walk.mjs
ADDED
|
@@ -0,0 +1,154 @@
|
|
|
1
|
+
// 走树:文件夹大小(lib/info.mjs 的 dirSize)和文件名搜索(lib/search.mjs)共用的一份遍历(设计见 docs/design/phase-3.md 第 18.2 节)。
|
|
2
|
+
// 只读:都经视图共用的读取状态(lib/tree.mjs 的 createListing)的 fs 和并发上限。
|
|
3
|
+
// - 同一时间只读一个目录,用只取名字的 readdir(不用 opendir、withFileTypes:文件系统不报类型时它们可能同步 lstat);
|
|
4
|
+
// readdir 和 lstat 都经并发上限排队,排到名额后先核对停止条件再读。条目的 lstat 一批最多 BATCH 个,等回来才排下一批。
|
|
5
|
+
// - 不跟随链接:只有 lstat 说是目录才进;进一个目录之前再 lstat 它一次,已经不是目录(被换成链接)就跳过,读不到计入 unreadable。
|
|
6
|
+
// 这只缩小「校验和使用之间」的窗口,不声称根治(docs/backlog.md 已接受的那一条)。起点由 resolve(默认 resolveInRoot)解析,不再 lstat。
|
|
7
|
+
// - 项数到 limit、用时到 timeoutMs、待访问目录的路径总字节到 queueBytes、调用方自己 stop(reason):立刻结算,已发出的读取不再计入;
|
|
8
|
+
// signal 中止、valid() 为假(会话、根目录变了或视图关了)静默结算为 null,不回答。
|
|
9
|
+
// - 子目录读不到、进目录前的 lstat、条目的 lstat 失败都计入 unreadable;起点读不到才算错误。
|
|
10
|
+
//
|
|
11
|
+
// 两个信号:result 是「请求结算了」,drained 是「读取排空了」。已经发出去的读取撤不回,结算(中止、超时、走完、出错)之后只是不再发新的:
|
|
12
|
+
// drained 要等已经停止派发、并且这次走树启动过的所有读取(起点解析、进目录前的 lstat、readdir、条目的 lstat,
|
|
13
|
+
// 加上调用方用 track 登记的)都结束。走树中途在途个数暂时为 0(一批读完、下一批还没发)不算。
|
|
14
|
+
import { join } from 'node:path';
|
|
15
|
+
import { fromFsError, resolveInRoot } from './paths.mjs';
|
|
16
|
+
|
|
17
|
+
export const WALK_ITEMS = 200_000;
|
|
18
|
+
export const QUEUE_BYTES = 32 * 1024 * 1024;
|
|
19
|
+
// 一批同时排进并发上限的 lstat 数;等它们回来才排下一批。
|
|
20
|
+
const BATCH = 4;
|
|
21
|
+
|
|
22
|
+
// 待访问的目录。depth 是栈(后进先出,文件夹大小用),breadth 是队列(先浅后深,搜索用):
|
|
23
|
+
// 带头部下标的数组,取过的元素释放,不用 shift();头部过半再整理一次。路径的总字节超过 maxBytes,push 返回 false。
|
|
24
|
+
function createQueue(order, maxBytes) {
|
|
25
|
+
let items = [], head = 0, bytes = 0;
|
|
26
|
+
return {
|
|
27
|
+
get size() { return items.length - head; },
|
|
28
|
+
push(item) {
|
|
29
|
+
bytes += Buffer.byteLength(item.dir);
|
|
30
|
+
if (bytes > maxBytes) return false;
|
|
31
|
+
items.push(item);
|
|
32
|
+
return true;
|
|
33
|
+
},
|
|
34
|
+
take() {
|
|
35
|
+
let item;
|
|
36
|
+
if (order === 'breadth') {
|
|
37
|
+
item = items[head];
|
|
38
|
+
items[head++] = undefined;
|
|
39
|
+
if (head >= 1024 && head * 2 >= items.length) { items = items.slice(head); head = 0; }
|
|
40
|
+
} else item = items.pop();
|
|
41
|
+
bytes -= Buffer.byteLength(item.dir);
|
|
42
|
+
return item;
|
|
43
|
+
},
|
|
44
|
+
};
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
// options:
|
|
48
|
+
// - visit({ dir, tag, name, info, stop }):每个 lstat 成功的条目一次,info 是 lstat 的结果;返回要不要进(info 是目录才进)。
|
|
49
|
+
// 真值是 true 或 { tag }:tag 带给进去之后这个目录里条目的 visit。ordered 为真时 visit 可以是异步的,等它回来才处理下一个条目。
|
|
50
|
+
// - ordered:为真时一批 lstat 全回来后,按 readdir 的名字顺序逐个 visit(搜索用);为假时每个 lstat 一回来就 visit(文件夹大小保留现在的样子)。
|
|
51
|
+
// - order:'depth'(默认)或 'breadth'。
|
|
52
|
+
// - timeoutMs:给了才在这里计时;搜索的 5 秒从请求算起,含等屏障,由调用方自己计时再 stop('time')。
|
|
53
|
+
// 返回 { result, drained, stop, track, done, total }:done() 是已经结算了没有;result 解析为 { reason, items, unreadable }(reason:done、items、time、queue 或调用方给的),
|
|
54
|
+
// 静默结算是 null,起点读不到或解析失败是拒绝;stop(reason) 结算;track(fn) 把调用方自己的读取登记进在途个数。
|
|
55
|
+
export function startWalk(listing, root, path, {
|
|
56
|
+
visit, ordered = false, order = 'depth', tag = '', valid = () => true, signal, limit = WALK_ITEMS, timeoutMs = null,
|
|
57
|
+
queueBytes = QUEUE_BYTES, resolve: resolvePath = resolveInRoot,
|
|
58
|
+
}) {
|
|
59
|
+
const { fs } = listing;
|
|
60
|
+
const total = { items: 0, unreadable: 0 };
|
|
61
|
+
let over = false, inflight = 0, timer = null, finish;
|
|
62
|
+
const drained = new Promise(done => { finish = done; });
|
|
63
|
+
const maybeDrained = () => { if (over && inflight === 0) finish(); };
|
|
64
|
+
async function track(fn) {
|
|
65
|
+
inflight++;
|
|
66
|
+
try { return await fn(); } finally { inflight--; maybeDrained(); }
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
const api = { result: null, drained, track, total, stop: () => {}, done: () => over };
|
|
70
|
+
api.result = new Promise((resolve, reject) => {
|
|
71
|
+
// 结算一次:之后的一切读取结果、定时器、中止都不再有影响,也不再派发新的读取。
|
|
72
|
+
const settle = done => {
|
|
73
|
+
if (over) return;
|
|
74
|
+
over = true;
|
|
75
|
+
clearTimeout(timer);
|
|
76
|
+
signal?.removeEventListener('abort', onAbort);
|
|
77
|
+
done();
|
|
78
|
+
maybeDrained();
|
|
79
|
+
};
|
|
80
|
+
const end = reason => settle(() => resolve({ reason, ...total }));
|
|
81
|
+
const onAbort = () => settle(() => resolve(null));
|
|
82
|
+
// 停了没有。valid() 为假或已中止的在这里顺便结算成静默停止。
|
|
83
|
+
const stopped = () => {
|
|
84
|
+
if (over) return true;
|
|
85
|
+
if (signal?.aborted || !valid()) { settle(() => resolve(null)); return true; }
|
|
86
|
+
return false;
|
|
87
|
+
};
|
|
88
|
+
api.stop = end;
|
|
89
|
+
|
|
90
|
+
// 排队读一次:排到名额后先核对停止条件,停了就不读(返回 undefined)。
|
|
91
|
+
const read = fn => track(() => listing.run(() => (stopped() ? undefined : fn())));
|
|
92
|
+
|
|
93
|
+
if (signal?.aborted) return settle(() => resolve(null));
|
|
94
|
+
signal?.addEventListener('abort', onAbort, { once: true });
|
|
95
|
+
if (timeoutMs !== null) timer = setTimeout(() => end('time'), timeoutMs);
|
|
96
|
+
|
|
97
|
+
async function run() {
|
|
98
|
+
// 解析慢时由计时和中止先结算;这里回来之后 stopped() 再核对一遍,已经停了就不读。
|
|
99
|
+
const start = await track(() => resolvePath(root, path));
|
|
100
|
+
if (stopped()) return;
|
|
101
|
+
const queue = createQueue(order, queueBytes);
|
|
102
|
+
queue.push({ dir: start, tag, start: true });
|
|
103
|
+
|
|
104
|
+
// 处理一个 lstat 回来的条目:计数,交给 visit,要进的目录入队。
|
|
105
|
+
async function accept(dir, parentTag, name, info) {
|
|
106
|
+
if (stopped()) return; // 已经停了,回来的结果不再计入
|
|
107
|
+
total.items++;
|
|
108
|
+
if (!info) { total.unreadable++; return; }
|
|
109
|
+
const entered = await visit({ dir, tag: parentTag, name, info, stop: end });
|
|
110
|
+
if (stopped() || !entered || !info.isDirectory()) return;
|
|
111
|
+
if (!queue.push({ dir: join(dir, name), tag: entered?.tag ?? '' })) end('queue');
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
while (queue.size > 0 && !stopped()) {
|
|
115
|
+
const item = queue.take();
|
|
116
|
+
if (!item.start) {
|
|
117
|
+
let info = null, failed = false;
|
|
118
|
+
try { info = await read(() => fs.lstat(item.dir)); } catch { failed = true; }
|
|
119
|
+
if (stopped()) return;
|
|
120
|
+
if (failed) { total.unreadable++; continue; }
|
|
121
|
+
if (!info.isDirectory()) continue; // 已经不是目录了(被换成链接):不进
|
|
122
|
+
}
|
|
123
|
+
let names;
|
|
124
|
+
try { names = await read(() => fs.readdir(item.dir)); } catch (error) {
|
|
125
|
+
if (item.start) throw fromFsError(error);
|
|
126
|
+
if (stopped()) return;
|
|
127
|
+
total.unreadable++;
|
|
128
|
+
continue;
|
|
129
|
+
}
|
|
130
|
+
if (stopped()) return;
|
|
131
|
+
let at = 0;
|
|
132
|
+
while (at < names.length) {
|
|
133
|
+
if (stopped()) return;
|
|
134
|
+
if (total.items >= limit) return end('items');
|
|
135
|
+
const batch = names.slice(at, at + Math.min(BATCH, limit - total.items));
|
|
136
|
+
at += batch.length;
|
|
137
|
+
const infos = new Array(batch.length);
|
|
138
|
+
await Promise.all(batch.map((name, i) => read(async () => {
|
|
139
|
+
let info = null;
|
|
140
|
+
try { info = await fs.lstat(join(item.dir, name)); } catch { /* 下面计入 unreadable */ }
|
|
141
|
+
if (ordered) infos[i] = info; else await accept(item.dir, item.tag, name, info);
|
|
142
|
+
})));
|
|
143
|
+
if (ordered) for (let i = 0; i < batch.length; i++) { if (stopped()) return; await accept(item.dir, item.tag, batch[i], infos[i] ?? null); }
|
|
144
|
+
}
|
|
145
|
+
if (!stopped() && total.items >= limit && queue.size > 0) return end('items');
|
|
146
|
+
}
|
|
147
|
+
end('done');
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
run().catch(error => settle(() => reject(error)));
|
|
151
|
+
});
|
|
152
|
+
|
|
153
|
+
return api;
|
|
154
|
+
}
|
package/main.mjs
CHANGED
|
@@ -4,6 +4,7 @@ import { createListing, listDirectory } from './lib/tree.mjs';
|
|
|
4
4
|
import { readChunk } from './lib/content.mjs';
|
|
5
5
|
import { addText } from './lib/draft.mjs';
|
|
6
6
|
import { dirSize, statPath } from './lib/info.mjs';
|
|
7
|
+
import { createSearcher } from './lib/search.mjs';
|
|
7
8
|
import { NO_ROOT, queryRoot, sameRoot } from './lib/root.mjs';
|
|
8
9
|
import {
|
|
9
10
|
ErrorCode, MESSAGE_LIMIT, REQUEST_ID_MAX, ReplyOf, RootState, Type, fail, messageSize,
|
|
@@ -19,9 +20,9 @@ const sessionOfFile = context => {
|
|
|
19
20
|
return typeof session === 'string' && session !== '' ? session : null;
|
|
20
21
|
};
|
|
21
22
|
|
|
22
|
-
// options 只给测试用,运行时不传:makeListing 换成带假文件系统的读取状态;sizeLimits
|
|
23
|
-
export function activate(coda, { makeListing = createListing, sizeLimits = {} } = {}) {
|
|
24
|
-
const options = { makeListing, sizeLimits };
|
|
23
|
+
// options 只给测试用,运行时不传:makeListing 换成带假文件系统的读取状态;sizeLimits 调文件夹大小的项数、用时上限;searchLimits 调文件名搜索的条数、项数、用时、队列字节、回答字节上限。
|
|
24
|
+
export function activate(coda, { makeListing = createListing, sizeLimits = {}, searchLimits = {} } = {}) {
|
|
25
|
+
const options = { makeListing, sizeLimits, searchLimits };
|
|
25
26
|
coda.views.register('files', { open: view => serve(coda, view, sessionOfTree, options) });
|
|
26
27
|
coda.views.register('file', { open: view => serve(coda, view, sessionOfFile, options) });
|
|
27
28
|
}
|
|
@@ -29,7 +30,7 @@ export function activate(coda, { makeListing = createListing, sizeLimits = {} }
|
|
|
29
30
|
const validRequestId = id => (typeof id === 'string' && id.length <= REQUEST_ID_MAX) || Number.isSafeInteger(id);
|
|
30
31
|
const errorOf = error => (error?.protocol ? { code: error.code, message: error.message } : { code: ErrorCode.IO, message: '读取失败' });
|
|
31
32
|
|
|
32
|
-
function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
33
|
+
function serve(coda, view, sessionOf, { makeListing, sizeLimits, searchLimits }) {
|
|
33
34
|
// 代次:每换一次会话加 1,所有异步出口回来后都要核对。
|
|
34
35
|
const s = {
|
|
35
36
|
session: sessionOf(view.context), generation: 1, root: NO_ROOT, sent: null,
|
|
@@ -42,8 +43,10 @@ function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
|
42
43
|
// 文件夹大小:每个视图同时只有一次统计。新的开始、换会话、根目录变化、视图关闭时旧的静默停止(不回答)。
|
|
43
44
|
let sizing = null; // { generation, requestId, abort }
|
|
44
45
|
const stopSizing = () => { sizing?.abort.abort(); sizing = null; };
|
|
45
|
-
//
|
|
46
|
-
const
|
|
46
|
+
// 文件名搜索:同样每个视图同时只有一次,槽、待启动位和排空屏障都在 lib/search.mjs 的 searcher 里。
|
|
47
|
+
const searcher = createSearcher(s.listing, searchLimits);
|
|
48
|
+
// 换会话、根目录变化、视图关闭:读取状态丢弃,统计和搜索也停。
|
|
49
|
+
const resetReads = () => { s.listing.clear(); stopSizing(); searcher.clear(); };
|
|
47
50
|
|
|
48
51
|
function post(message) {
|
|
49
52
|
if (s.closed) return;
|
|
@@ -59,7 +62,7 @@ function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
|
59
62
|
const postSession = () => post({ type: Type.SESSION, generation: s.generation, session: s.session });
|
|
60
63
|
function postRoot() {
|
|
61
64
|
s.sent = s.root;
|
|
62
|
-
post({ type: Type.ROOT, generation: s.generation, state: s.root.state, path: s.root.path });
|
|
65
|
+
post({ type: Type.ROOT, generation: s.generation, state: s.root.state, path: s.root.path, project: s.root.project });
|
|
63
66
|
}
|
|
64
67
|
|
|
65
68
|
// 重新查询根目录。结果和上次推给页面的不同才推送;查询失败保留上一次的。
|
|
@@ -115,6 +118,7 @@ function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
|
115
118
|
return await dirSize(s.listing, root, message.path, { ...sizeLimits, valid, signal: mine.abort.signal });
|
|
116
119
|
} finally { if (sizing === mine) sizing = null; }
|
|
117
120
|
},
|
|
121
|
+
[Type.SEARCH]: (message, { root, valid, generation, requestId }) => searcher.search(message, { root, valid, generation, requestId }),
|
|
118
122
|
async [Type.ADD_TEXT](message, { generation }) {
|
|
119
123
|
if (!s.session) throw fail(ErrorCode.NO_ROOT, '没有会话');
|
|
120
124
|
return await addText(coda, s.session, message, { valid: () => !stale(generation) }) ? {} : null;
|
|
@@ -122,6 +126,8 @@ function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
|
122
126
|
};
|
|
123
127
|
// 回答依赖根目录的:读完回来根目录换了,不能带旧根目录的内容。
|
|
124
128
|
const rootBound = new Set([Type.LIST, Type.STAT]);
|
|
129
|
+
// 统计和搜索:作废(会话、根目录变了或视图关了)一律静默,不回答。
|
|
130
|
+
const silentWhenVoid = new Set([Type.DIR_SIZE, Type.SEARCH]);
|
|
125
131
|
|
|
126
132
|
async function request(message) {
|
|
127
133
|
const { type, generation, requestId } = message;
|
|
@@ -133,7 +139,7 @@ function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
|
133
139
|
// 读的途中根目录换了(同一会话从 A 换到 B),回答不能带 A 的内容。
|
|
134
140
|
const valid = () => !stale(generation) && s.root.state === RootState.READY && s.root.path === root;
|
|
135
141
|
const body = await handlers[type](message, { root, valid, generation, requestId });
|
|
136
|
-
if (body === null || (type
|
|
142
|
+
if (body === null || (silentWhenVoid.has(type) && !valid())) return; // 统计、搜索完成时根目录已变:不回答
|
|
137
143
|
if (rootBound.has(type) && !valid() && !stale(generation)) throw fail(ErrorCode.NO_ROOT, '工作目录已变化');
|
|
138
144
|
if (!stale(generation)) post({ type: reply, generation, requestId, ...body });
|
|
139
145
|
} catch (error) {
|
|
@@ -146,17 +152,21 @@ function serve(coda, view, sessionOf, { makeListing, sizeLimits }) {
|
|
|
146
152
|
if (!stale(generation) && sizing?.generation === generation && sizing.requestId === requestId) stopSizing();
|
|
147
153
|
}
|
|
148
154
|
|
|
155
|
+
const cancelSearch = ({ generation, requestId }) => { if (!stale(generation)) searcher.cancel({ generation, requestId }); };
|
|
156
|
+
|
|
149
157
|
view.onMessage(async message => {
|
|
150
158
|
if (!message || typeof message !== 'object') return;
|
|
151
159
|
switch (message.type) {
|
|
152
160
|
// 页面(重新)就绪:它什么都不知道,所以不管有没有变,下一次查询的结果都要推。
|
|
153
|
-
|
|
161
|
+
// 旧页面发的统计和搜索不再有人要:中止并清空槽(走树的读取排空屏障照常留着)。
|
|
162
|
+
case Type.HELLO: s.hello = true; s.sent = null; stopSizing(); searcher.clear(); postSession(); return refreshRoot();
|
|
154
163
|
case Type.REFRESH:
|
|
155
164
|
if (stale(message.generation)) return undefined;
|
|
156
165
|
s.listing.detach();
|
|
157
166
|
return refreshRoot();
|
|
158
|
-
case Type.LIST: case Type.READ: case Type.STAT: case Type.DIR_SIZE: case Type.ADD_TEXT: return request(message);
|
|
167
|
+
case Type.LIST: case Type.READ: case Type.STAT: case Type.DIR_SIZE: case Type.ADD_TEXT: case Type.SEARCH: return request(message);
|
|
159
168
|
case Type.DIR_SIZE_CANCEL: return cancelSizing(message);
|
|
169
|
+
case Type.SEARCH_CANCEL: return cancelSearch(message);
|
|
160
170
|
}
|
|
161
171
|
});
|
|
162
172
|
|