@lzwme/sserver 0.0.10 → 1.0.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.
Files changed (69) hide show
  1. package/LICENSE +21 -21
  2. package/README.MD +72 -100
  3. package/bin/sserver.js +0 -0
  4. package/dist/assets/assets/localsend/style.css +2 -0
  5. package/dist/assets/assets/localsend/vendor/qr-code-styling.js +2 -0
  6. package/dist/assets/localsend/style.css +2 -0
  7. package/dist/assets/localsend/vendor/qr-code-styling.js +2 -0
  8. package/dist/cli.js +26 -4
  9. package/dist/config.d.ts +38 -1
  10. package/dist/config.js +54 -9
  11. package/dist/lib/get-cert.js +1 -1
  12. package/dist/lib/merge-config.d.ts +9 -0
  13. package/dist/lib/merge-config.js +66 -0
  14. package/dist/lib/utils.d.ts +27 -1
  15. package/dist/lib/utils.js +94 -14
  16. package/dist/localsend/audit.d.ts +36 -0
  17. package/dist/localsend/audit.js +104 -0
  18. package/dist/localsend/auth.d.ts +94 -0
  19. package/dist/localsend/auth.js +227 -0
  20. package/dist/localsend/cache.d.ts +34 -0
  21. package/dist/localsend/cache.js +269 -0
  22. package/dist/localsend/chunk.d.ts +114 -0
  23. package/dist/localsend/chunk.js +475 -0
  24. package/dist/localsend/cleaner.d.ts +19 -0
  25. package/dist/localsend/cleaner.js +80 -0
  26. package/dist/localsend/client/app.js +4131 -0
  27. package/dist/localsend/client/crypto.js +233 -0
  28. package/dist/localsend/client/favicon.png +0 -0
  29. package/dist/localsend/client/icons/icon-192.png +0 -0
  30. package/dist/localsend/client/icons/icon-512.png +0 -0
  31. package/dist/localsend/client/index.html +451 -0
  32. package/dist/localsend/client/manifest.webmanifest +33 -0
  33. package/dist/localsend/client/sw.js +128 -0
  34. package/dist/localsend/guard.d.ts +58 -0
  35. package/dist/localsend/guard.js +210 -0
  36. package/dist/localsend/index.d.ts +52 -0
  37. package/dist/localsend/index.js +1771 -0
  38. package/dist/localsend/manage.d.ts +96 -0
  39. package/dist/localsend/manage.js +304 -0
  40. package/dist/localsend/metrics.d.ts +26 -0
  41. package/dist/localsend/metrics.js +58 -0
  42. package/dist/localsend/paste.d.ts +72 -0
  43. package/dist/localsend/paste.js +125 -0
  44. package/dist/localsend/path.d.ts +33 -0
  45. package/dist/localsend/path.js +151 -0
  46. package/dist/localsend/query.d.ts +78 -0
  47. package/dist/localsend/query.js +147 -0
  48. package/dist/localsend/secret.d.ts +31 -0
  49. package/dist/localsend/secret.js +96 -0
  50. package/dist/localsend/settings.d.ts +53 -0
  51. package/dist/localsend/settings.js +285 -0
  52. package/dist/localsend/share.d.ts +35 -0
  53. package/dist/localsend/share.js +117 -0
  54. package/dist/localsend/temp.d.ts +10 -0
  55. package/dist/localsend/temp.js +47 -0
  56. package/dist/localsend/ticket.d.ts +40 -0
  57. package/dist/localsend/ticket.js +98 -0
  58. package/dist/localsend/trash.d.ts +39 -0
  59. package/dist/localsend/trash.js +261 -0
  60. package/dist/localsend/webdav.d.ts +50 -0
  61. package/dist/localsend/webdav.js +530 -0
  62. package/dist/localsend/zip.d.ts +20 -0
  63. package/dist/localsend/zip.js +186 -0
  64. package/dist/proxy/php-proxy.js +54 -21
  65. package/dist/static-server.js +10 -3
  66. package/package.json +21 -13
  67. package/dist/localsend/index.html +0 -481
  68. package/dist/localsend.d.ts +0 -2
  69. package/dist/localsend.js +0 -148
@@ -0,0 +1,4131 @@
1
+ (function () {
2
+ 'use strict';
3
+ var API = '/localsend/api';
4
+ var $ = function (id) { return document.getElementById(id); };
5
+ /**
6
+ * 会话令牌只放在请求头里。
7
+ *
8
+ * 下载、预览、打包、事件流这几类请求由 <img> / <a> / EventSource 发起,
9
+ * 带不了自定义请求头;以前是把会话拼进 URL(?session=),
10
+ * 结果「复制链接」等于把自己的会话发出去,URL 还会留在历史与日志里。
11
+ * 现在改为「先换一张短期票据,再用票据访问」,见下面的 issueTicket。
12
+ *
13
+ * 服务端配置了口令时,危险操作(删除、整理、撤销分享)需要管理员身份;
14
+ * 上传与分享需要访客以上身份,但没有配置访客口令时任何人都可以上传下载。
15
+ * 口令与访问令牌都不以明文提交:客户端用服务端公开的盐值派生出摘要,
16
+ * 服务端只比对摘要(见 crypto.js 与服务端的 secret.ts)。
17
+ * 会话令牌存在 localStorage,由服务端内存维护,服务重启后失效,需要重新登录。
18
+ */
19
+ var SESSION_STORAGE_KEY = 'localsend.session';
20
+ var TOKEN_STORAGE_KEY = 'localsend.token';
21
+ /** 登录方式:password(口令)/ token(访问令牌)。会话失效时据此提示正确的重新认证入口 */
22
+ var AUTH_METHOD_STORAGE_KEY = 'localsend.authMethod';
23
+ var sessionToken = '';
24
+ // 用户输入的访问令牌:只留在浏览器里,用于向服务端换取会话
25
+ var accessToken = '';
26
+ /** 令牌自动校验进行中:避免多个 401 同时触发重复校验 */
27
+ var tokenExchangePending = false;
28
+ /** 本次页面生命周期内是否已经自动试过保存的令牌 */
29
+ var tokenAutoTried = false;
30
+ /**
31
+ * 认证失效:接口返回 401 之后置位。
32
+ *
33
+ * 未授权不是普通错误,它意味着后面的每个请求都会失败。
34
+ * 置位之后所有请求在本地就被拦下,不再发往服务端,
35
+ * 从根上杜绝「继续请求 → 继续 401 → 打满频率限制」的死循环。
36
+ * 重新认证成功、拿到新会话后自动解除。
37
+ */
38
+ var authBlocked = false;
39
+ /** 上次探测事件流连接状态的时间戳(毫秒),用来限制探测频率 */
40
+ var sseProbeAt = 0;
41
+ /** 本次登录使用的凭据类型 */
42
+ var authMethod = '';
43
+ try {
44
+ sessionToken = localStorage.getItem(SESSION_STORAGE_KEY) || '';
45
+ accessToken = localStorage.getItem(TOKEN_STORAGE_KEY) || '';
46
+ authMethod = localStorage.getItem(AUTH_METHOD_STORAGE_KEY) || '';
47
+ } catch (e) {
48
+ // localStorage 不可用时忽略
49
+ }
50
+ // 当前身份:role 为 admin / visitor / guest / open
51
+ var sessionInfo = { role: 'open', open: true, hasAdmin: false, hasVisitor: false };
52
+ /** 最近一次拿到的用量信息(头部那行机器信息要用) */
53
+ var lastUsage = null;
54
+
55
+ /** 是否可以执行危险操作(删除、整理目录、撤销分享等) */
56
+ function isAdmin() {
57
+ return sessionInfo.role === 'admin' || sessionInfo.role === 'open';
58
+ }
59
+ /** 是否可以写入(上传、粘贴、创建分享等) */
60
+ function canWrite() {
61
+ if (sessionInfo.role !== 'guest') return true;
62
+ // 未登录(只读)身份能否上传,取决于服务端是否配置了访客口令:
63
+ // 没有访客口令时允许任何人上传下载;配置了则必须先输入口令登录
64
+ return !sessionInfo.hasVisitor;
65
+ }
66
+ /**
67
+ * 带会话头的底层请求:只负责把会话令牌放进请求头,不进 URL。
68
+ * 不做任何认证失败处理,由调用方决定怎么处理。
69
+ */
70
+ function sessionFetch(url, init) {
71
+ var opts = init || {};
72
+ var headers = opts.headers || {};
73
+ if (sessionToken) headers['X-Localsend-Session'] = sessionToken;
74
+ opts.headers = headers;
75
+ return fetch(url, opts);
76
+ }
77
+
78
+ /** 构造认证失败错误:统一流程已经处理过,调用方只需要终止当前流水线 */
79
+ function authError(msg) {
80
+ var err = new Error(msg || '需要重新认证');
81
+ err.authFailed = true;
82
+ return err;
83
+ }
84
+
85
+ /** 清掉本地会话(会话失效或退出登录时用) */
86
+ function clearSession() {
87
+ sessionToken = '';
88
+ try { localStorage.removeItem(SESSION_STORAGE_KEY); } catch (e) { /* 忽略存储失败 */ }
89
+ }
90
+
91
+ /** 记录本次使用的凭据类型:会话失效时据此提示正确的重新认证入口 */
92
+ function setAuthMethod(method) {
93
+ authMethod = method || '';
94
+ try {
95
+ if (authMethod) localStorage.setItem(AUTH_METHOD_STORAGE_KEY, authMethod);
96
+ else localStorage.removeItem(AUTH_METHOD_STORAGE_KEY);
97
+ } catch (e) { /* 忽略存储失败 */ }
98
+ }
99
+
100
+ /**
101
+ * 认证失效的统一处理。
102
+ *
103
+ * 未授权不是普通错误:它意味着后面的每个请求都会失败。
104
+ * 所以这里把整条流水线停掉——清掉死会话、断开事件流、停掉后台定时器、
105
+ * 置上短路开关——再弹出对应的重新认证入口,绝不自动重试。
106
+ *
107
+ * 弹哪个框取决于客户端是怎么进来的:
108
+ * - 用口令登录的:口令变了或会话过期了,要重新输口令
109
+ * - 用访问令牌进来的:令牌变了或会话过期了,要重新输令牌
110
+ */
111
+ function handleAuthFailure(json) {
112
+ var first = !authBlocked;
113
+ // 短路:后续请求在本地就被拦下,不再发往服务端
114
+ authBlocked = true;
115
+ // 死会话不能再带着走
116
+ clearSession();
117
+ // 会话确实没了:状态要如实反映,否则页面会以为自己还能用
118
+ sessionInfo.sessionValid = false;
119
+ // 服务端说「需要访问令牌」:说明这一步之前就没有任何可用权限,
120
+ // 身份信息(/api/session)根本拿不到,只能从 401 里补出这条线索
121
+ if (json && json.needToken) {
122
+ sessionInfo.hasToken = true;
123
+ sessionInfo.open = false;
124
+ }
125
+ // 事件流会自动重连,不断开就是持续的无效请求
126
+ closeEvents();
127
+ // 后台定时器同理:监听目录每 3 秒发一次请求
128
+ var watching = !!watchHandle;
129
+ stopWatchDir();
130
+ // 身份回到未登录,界面要如实反映,不能继续显示旧角色
131
+ sessionInfo.role = sessionInfo.open ? 'open' : 'guest';
132
+ applyRole();
133
+ if (watching) toast('会话已失效,目录监听已停止');
134
+ // 已经在重新认证流程里了,不再重复弹窗
135
+ if (!first) return;
136
+ var msg = (json && json.msg) || '';
137
+ // 之前用访问令牌进来的:先拿保存的令牌自动换一次,失败再让用户输入
138
+ if (authMethod === 'token' && accessToken && !tokenAutoTried && !tokenExchangePending) {
139
+ tokenAutoTried = true;
140
+ tokenExchangePending = true;
141
+ exchangeToken(accessToken)
142
+ .then(function () {
143
+ refreshSession().then(function (ok) {
144
+ if (ok) startApp();
145
+ });
146
+ })
147
+ .catch(function () {
148
+ openLoginModal(msg || '会话已失效,请重新验证');
149
+ })
150
+ .then(function () {
151
+ tokenExchangePending = false;
152
+ });
153
+ return;
154
+ }
155
+ openLoginModal(msg || '会话已失效,请重新验证');
156
+ }
157
+
158
+ /**
159
+ * 统一的接口请求:自动带上会话令牌(放在请求头里,不进 URL)。
160
+ *
161
+ * 401(未授权)是异常状态,不是普通响应:
162
+ * 走统一处理链(清会话、断事件流、停后台定时器、提示重新认证)之后
163
+ * 直接抛错终止本次流水线,绝不让它继续往下跑。
164
+ * 权限不足(403)时弹出登录框;其它 403(如禁止上传的类型)不打扰用户。
165
+ */
166
+ function apiFetch(url, init) {
167
+ // 认证失效后不再发请求:继续发只会全部 401,把频率限制打满
168
+ if (authBlocked) return Promise.reject(authError('需要重新认证'));
169
+ return sessionFetch(url, init).then(function (r) {
170
+ if (r.status === 401) {
171
+ return r
172
+ .clone()
173
+ .json()
174
+ .catch(function () { return null; })
175
+ .then(function (json) {
176
+ handleAuthFailure(json);
177
+ throw authError((json && json.msg) || '需要重新认证');
178
+ });
179
+ }
180
+ // 权限不足时引导登录;其它 403(如禁止上传的类型)不打扰用户
181
+ if (r.status === 403) {
182
+ r.clone()
183
+ .json()
184
+ .then(function (json) {
185
+ if (json && json.needAuth) {
186
+ // 服务端认为身份不够,说明当前身份已经变了:界面要跟着变,
187
+ // 不能继续显示旧角色,免得用户一直点着注定失败的按钮
188
+ sessionInfo.role = 'guest';
189
+ applyRole();
190
+ openLoginModal(json.msg);
191
+ }
192
+ })
193
+ .catch(function () {});
194
+ }
195
+ return r;
196
+ });
197
+ }
198
+
199
+ // ---------------------------------------------------------------------------
200
+ // 短期访问票据
201
+ //
202
+ // 下载 / 预览 / 打包 / 事件流的 URL 由浏览器标签直接发起,带不了请求头。
203
+ // 用票据替代「把会话拼进 URL」:票据只对指定文件有效、几分钟过期,
204
+ // 即使被复制出去,影响面也远小于会话令牌。
205
+ // ---------------------------------------------------------------------------
206
+
207
+ /** 换一张票据 */
208
+ function issueTicket(scope, names) {
209
+ return apiFetch(API + '/ticket', {
210
+ method: 'POST',
211
+ headers: { 'Content-Type': 'application/json' },
212
+ body: JSON.stringify({ scope: scope, names: names || [] }),
213
+ })
214
+ .then(function (r) { return r.json(); })
215
+ .then(function (json) {
216
+ if (json.code !== 0) throw new Error(json.msg || '获取访问票据失败');
217
+ return json.data;
218
+ });
219
+ }
220
+
221
+ /** 生成带票据的 URL:path 为票据令牌之后的路径片段 */
222
+ function ticketUrl(scope, names, path) {
223
+ return issueTicket(scope, names).then(function (data) {
224
+ return location.origin + API + '/t/' + encodeURIComponent(data.token) + path;
225
+ });
226
+ }
227
+
228
+ /** 下载地址(票据版) */
229
+ function downloadUrl(name) {
230
+ return ticketUrl('download', [name], '/download/' + encodeURIComponent(name));
231
+ }
232
+
233
+ /** 预览地址(票据版) */
234
+ function previewUrl(name) {
235
+ return ticketUrl('preview', [name], '/preview/' + encodeURIComponent(name));
236
+ }
237
+
238
+ /** 角色的中文名称 */
239
+ function roleName(role) {
240
+ if (role === 'admin') return '管理员';
241
+ if (role === 'visitor') return '访客';
242
+ if (role === 'guest') return '只读';
243
+ return '开放';
244
+ }
245
+
246
+ /**
247
+ * 是否必须先验证身份才能用页面。
248
+ *
249
+ * 配了访问令牌就等于「大门上锁」:没有有效会话时所有接口都是 401,
250
+ * 页面上的按钮、列表、上传入口全都只是摆设,不如直接遮住,
251
+ * 免得用户点一圈才被告知「请先验证」。
252
+ */
253
+ function needsTokenGate() {
254
+ return !sessionInfo.open && !!sessionInfo.hasToken && !sessionInfo.sessionValid;
255
+ }
256
+
257
+ /** 未验证时遮住整页,并把「取消」按钮收起来(此时取消等于把自己关在门外) */
258
+ function updateAuthGate() {
259
+ var gated = needsTokenGate();
260
+ var gate = $('authGate');
261
+ gate.classList.toggle('hidden', !gated);
262
+ gate.classList.toggle('flex', gated);
263
+ $('loginCancel').classList.toggle('hidden', gated);
264
+ }
265
+
266
+ /** 按当前身份刷新界面上的权限状态 */
267
+ function applyRole() {
268
+ var role = sessionInfo.role;
269
+ var admin = isAdmin();
270
+ var write = canWrite();
271
+ var gated = needsTokenGate();
272
+ // 只配了访问令牌时,验证通过后服务端给的角色是 open(无口令即全权),
273
+ // 但它与「谁都不用登录」的开放模式不是一回事,界面上要区分开
274
+ var tokenVerified = role === 'open' && !sessionInfo.open;
275
+ var logged = role === 'admin' || role === 'visitor' || tokenVerified;
276
+
277
+ // 身份徽章:让人一眼看出当前能做什么
278
+ var badge = $('roleBadge');
279
+ // 未登录时能否上传取决于是否配置了访客口令,徽章要如实反映
280
+ var guestWrite = role === 'guest' && write;
281
+ badge.textContent = gated
282
+ ? '未验证'
283
+ : sessionInfo.open
284
+ ? '开放模式'
285
+ : tokenVerified
286
+ ? '管理员(令牌)'
287
+ : guestWrite
288
+ ? '未登录·可上传'
289
+ : roleName(role);
290
+ if (gated || sessionInfo.open) {
291
+ badge.className = 'text-[11px] px-2 py-1 rounded-lg border border-amber-500/40 bg-amber-500/10 text-amber-300';
292
+ } else if (admin) {
293
+ badge.className = 'text-[11px] px-2 py-1 rounded-lg border border-emerald-500/40 bg-emerald-500/10 text-emerald-300';
294
+ } else if (role === 'visitor' || guestWrite) {
295
+ badge.className = 'text-[11px] px-2 py-1 rounded-lg border border-sky-500/40 bg-sky-500/10 text-sky-300';
296
+ } else {
297
+ badge.className = 'text-[11px] px-2 py-1 rounded-lg border border-slate-700 bg-slate-800/70 text-slate-400';
298
+ }
299
+ badge.classList.remove('hidden');
300
+
301
+ // 登录与退出:开放模式无需登录
302
+ $('loginBtn').style.display = logged || sessionInfo.open ? 'none' : '';
303
+ $('logoutBtn').style.display = logged ? '' : 'none';
304
+
305
+ // 按 data-need 标记控制各类操作入口
306
+ var nodes = document.querySelectorAll('[data-need]');
307
+ for (var i = 0; i < nodes.length; i++) {
308
+ var el = nodes[i];
309
+ var need = el.getAttribute('data-need');
310
+ var ok = need === 'admin' ? admin : write;
311
+ // 用内联样式控制,避免与 hidden / sm:block 等类冲突
312
+ el.style.display = ok ? '' : 'none';
313
+ }
314
+ // 权限变化会影响「未设口令」的提示,头部信息跟着刷新
315
+ updateHostInfo(lastUsage);
316
+ // 需要令牌却还没验证时,整页遮起来
317
+ updateAuthGate();
318
+ }
319
+
320
+ /**
321
+ * 拉取当前身份。
322
+ *
323
+ * 返回 false 表示需要访问令牌(此时服务端返回 401),
324
+ * 后续的数据加载与事件订阅都要等令牌验证通过再做。
325
+ */
326
+ function refreshSession() {
327
+ // 这里用底层请求而不是 apiFetch:身份探测本身要能穿过「认证失效」的短路,
328
+ // 否则就再也不知道服务端那边到底怎么了。
329
+ return sessionFetch(API + '/session')
330
+ .then(function (r) {
331
+ if (r.status === 401) {
332
+ // 会话失效:走统一处理(清会话、断事件流、停后台定时器、提示重新认证)
333
+ return r
334
+ .json()
335
+ .catch(function () { return null; })
336
+ .then(function (json) {
337
+ handleAuthFailure(json);
338
+ return null;
339
+ });
340
+ }
341
+ return r.json();
342
+ })
343
+ .then(function (json) {
344
+ if (!json) return false;
345
+ if (json.code !== 0) return true;
346
+ var prevRole = sessionInfo.role;
347
+ sessionInfo = json.data || sessionInfo;
348
+ // 会话已失效(超时、口令变更、服务重启)时清掉本地令牌,避免一直带着无效凭证。
349
+ // 以服务端给出的 sessionValid 为准:用访问令牌换来的会话角色也是 guest,
350
+ // 靠角色判断会把刚换到的会话误清掉。
351
+ if (sessionInfo.sessionValid === false && sessionToken) {
352
+ clearSession();
353
+ // 之前是口令登录的:明确提示重新登录,别让界面继续假装已登录
354
+ if (prevRole === 'admin' || prevRole === 'visitor') {
355
+ openLoginModal('会话已失效,请重新登录');
356
+ }
357
+ }
358
+ applyRole();
359
+ return true;
360
+ })
361
+ .catch(function () {
362
+ /* 拿不到身份信息时按默认权限显示 */
363
+ return !authBlocked;
364
+ });
365
+ }
366
+
367
+ /** 取回各密钥的公开盐值(客户端据此派生出摘要) */
368
+ function fetchSalts() {
369
+ return fetch(API + '/auth/salt')
370
+ .then(function (r) { return r.json(); })
371
+ .then(function (json) {
372
+ if (json.code !== 0) throw new Error(json.msg || '获取盐值失败');
373
+ return json.data || {};
374
+ });
375
+ }
376
+
377
+ /** 用公开盐值把口令/令牌派生成摘要 */
378
+ function digestOf(salts, kind, secret) {
379
+ var list = (salts && salts.secrets) || [];
380
+ for (var i = 0; i < list.length; i++) {
381
+ if (list[i].kind === kind) {
382
+ return window.LocalsendCrypto.pbkdf2Hex(secret, list[i].salt, list[i].iterations);
383
+ }
384
+ }
385
+ return '';
386
+ }
387
+
388
+ /**
389
+ * 保存服务端签发的会话令牌。
390
+ *
391
+ * method 记录这次是用口令还是访问令牌进来的:会话失效时据此提示正确的重新认证入口。
392
+ */
393
+ function applySession(data, method) {
394
+ sessionToken = String((data && data.token) || '');
395
+ try { localStorage.setItem(SESSION_STORAGE_KEY, sessionToken); } catch (e) { /* 忽略存储失败 */ }
396
+ if (data && data.role) sessionInfo.role = data.role;
397
+ if (method) setAuthMethod(method);
398
+ // 拿到有效会话:解除短路,恢复正常请求
399
+ authBlocked = false;
400
+ }
401
+
402
+ /** 当前可用的凭据类型,用于登录框提示(服务端已告知配置了哪几种) */
403
+ function loginHintText() {
404
+ if (sessionInfo.open) return '当前为开放模式,无需登录';
405
+ var parts = [];
406
+ if (sessionInfo.hasAdmin) parts.push('管理员口令');
407
+ if (sessionInfo.hasVisitor) parts.push('访客口令');
408
+ if (sessionInfo.hasToken) parts.push('访问令牌');
409
+ if (!parts.length) return '请输入口令或访问令牌';
410
+ return '请输入' + parts.join(' 或 ');
411
+ }
412
+
413
+ /** 打开登录弹窗(口令与访问令牌共用一个入口) */
414
+ function openLoginModal(msg) {
415
+ var err = $('loginError');
416
+ if (msg) {
417
+ err.textContent = msg;
418
+ err.classList.remove('hidden');
419
+ }
420
+ $('loginHint').textContent = loginHintText();
421
+ $('loginModal').classList.remove('hidden');
422
+ setTimeout(function () { $('loginPassword').focus(); }, 60);
423
+ }
424
+
425
+ /** 关闭登录弹窗 */
426
+ function closeLoginModal() {
427
+ $('loginModal').classList.add('hidden');
428
+ $('loginError').classList.add('hidden');
429
+ $('loginPassword').value = '';
430
+ }
431
+
432
+ /**
433
+ * 提交登录。
434
+ *
435
+ * 管理员口令、访客口令、访问令牌的摘要一起算、一起提交,
436
+ * 由服务端判断用户手里拿的是哪一种。
437
+ * 这样前端只需要一个输入框,用户不必先分辨「我该输哪一个」。
438
+ * 明文凭据始终留在浏览器里,网络上只有摘要。
439
+ */
440
+ function submitLogin() {
441
+ var input = $('loginPassword');
442
+ var secret = input.value;
443
+ var err = $('loginError');
444
+ if (!secret) {
445
+ err.textContent = '请输入口令或访问令牌';
446
+ err.classList.remove('hidden');
447
+ return;
448
+ }
449
+ $('loginOk').disabled = true;
450
+ fetchSalts()
451
+ .then(function (salts) {
452
+ var digests = {};
453
+ var admin = digestOf(salts, 'password', secret);
454
+ var visitor = digestOf(salts, 'visitorPassword', secret);
455
+ var token = digestOf(salts, 'token', secret);
456
+ if (admin) digests.password = admin;
457
+ if (visitor) digests.visitorPassword = visitor;
458
+ if (token) digests.token = token;
459
+ if (!admin && !visitor && !token) throw new Error('服务端未启用口令或令牌验证');
460
+ return fetch(API + '/auth/login', {
461
+ method: 'POST',
462
+ headers: { 'Content-Type': 'application/json' },
463
+ body: JSON.stringify({ digests: digests }),
464
+ });
465
+ })
466
+ .then(function (r) {
467
+ return r.json().then(function (json) {
468
+ return { status: r.status, json: json };
469
+ });
470
+ })
471
+ .then(function (out) {
472
+ if (out.status !== 200 || out.json.code !== 0) {
473
+ err.textContent = out.json.msg || '口令或访问令牌不正确';
474
+ err.classList.remove('hidden');
475
+ input.select();
476
+ return;
477
+ }
478
+ var data = out.json.data || {};
479
+ applySession(data, data.via === 'token' ? 'token' : 'password');
480
+ // 用访问令牌进来的:记住它,会话过期时可以自动换一次,不必让用户重敲
481
+ if (data.via === 'token') {
482
+ accessToken = secret;
483
+ try {
484
+ localStorage.setItem(TOKEN_STORAGE_KEY, secret);
485
+ } catch (e) {
486
+ /* 忽略存储失败 */
487
+ }
488
+ }
489
+ input.value = '';
490
+ err.classList.add('hidden');
491
+ $('loginModal').classList.add('hidden');
492
+ toast('已验证:' + roleName(data.role), 'ok');
493
+ // 重新拉取身份并刷新列表,按新角色显示或隐藏操作入口
494
+ refreshSession().then(function (ok) {
495
+ if (ok) startApp();
496
+ });
497
+ })
498
+ .catch(function (e) {
499
+ err.textContent = (e && e.message) || '登录失败,请重试';
500
+ err.classList.remove('hidden');
501
+ })
502
+ .then(function () { $('loginOk').disabled = false; });
503
+ }
504
+
505
+ /**
506
+ * 用访问令牌换取会话(保留给「记住的令牌自动重连」与「改令牌后自动换会话」)。
507
+ *
508
+ * 令牌只在浏览器里派生成摘要,明文不会离开浏览器;
509
+ * 服务端签发的会话令牌才是之后所有请求里出现的东西。
510
+ */
511
+ function exchangeToken(value) {
512
+ return fetchSalts()
513
+ .then(function (salts) {
514
+ var digest = digestOf(salts, 'token', value);
515
+ if (!digest) throw new Error('服务端未启用访问令牌');
516
+ return fetch(API + '/auth/token', {
517
+ method: 'POST',
518
+ headers: { 'Content-Type': 'application/json' },
519
+ body: JSON.stringify({ digest: digest }),
520
+ });
521
+ })
522
+ .then(function (r) {
523
+ return r.json().then(function (json) {
524
+ return { status: r.status, json: json };
525
+ });
526
+ })
527
+ .then(function (out) {
528
+ if (out.status !== 200 || out.json.code !== 0) throw new Error(out.json.msg || '访问令牌不正确');
529
+ applySession(out.json.data, 'token');
530
+ accessToken = value;
531
+ try {
532
+ localStorage.setItem(TOKEN_STORAGE_KEY, value);
533
+ } catch (e) {
534
+ /* 忽略存储失败 */
535
+ }
536
+ return out.json.data;
537
+ });
538
+ }
539
+
540
+ /** 退出登录 */
541
+ function logout() {
542
+ apiFetch(API + '/logout', { method: 'POST' })
543
+ .catch(function () { /* 退出失败也清理本地会话 */ })
544
+ .then(function () {
545
+ clearSession();
546
+ setAuthMethod('');
547
+ // 退出后回到访客身份,重新按访客口径加载
548
+ authBlocked = false;
549
+ sessionInfo.sessionValid = false;
550
+ sessionInfo.role = sessionInfo.open ? 'open' : 'guest';
551
+ // 断开事件流:会话没了,重连只会不断拿到 401
552
+ closeEvents();
553
+ applyRole();
554
+ loadFiles();
555
+ toast('已退出登录', 'ok');
556
+ });
557
+ }
558
+ // 访问地址里不再带令牌:访问令牌由用户在页面上输入,避免被网关日志留存
559
+ var pageUrl = location.origin + location.pathname;
560
+
561
+ /**
562
+ * 更新当前展示的访问地址。
563
+ *
564
+ * 地址同时驱动三处:页面上的文本、标题气泡、以及二维码内容。
565
+ * 多网卡机器上一个地址可能只有本机能打开,用户切换后二维码必须跟着变。
566
+ */
567
+ function setPageUrl(url) {
568
+ if (!url) return;
569
+ pageUrl = url;
570
+ $('pageUrl').textContent = url;
571
+ $('pageUrl').title = url;
572
+ if (pageQrCode) pageQrCode.update({ data: url });
573
+ }
574
+
575
+ /**
576
+ * 拉取候选访问地址,填充下拉框并选定默认值。
577
+ *
578
+ * 以前页面直接用 location.origin 生成二维码:从本机 localhost 打开时
579
+ * 二维码里就是 localhost,手机扫了必然打不开;而服务端只给一个地址时
580
+ * 又常常是 WSL / Docker 的网段。这里把「当前地址 + 全部候选网卡地址」
581
+ * 合起来,能用当前地址就优先用它,否则用服务端建议的那个。
582
+ */
583
+ function loadNetworkInfo() {
584
+ return fetch(API + '/network')
585
+ .then(function (r) { return r.json(); })
586
+ .then(function (json) {
587
+ if (json.code !== 0) return;
588
+ var data = json.data || {};
589
+ var list = data.addresses || [];
590
+ var host = location.hostname;
591
+ var isLoop = host === 'localhost' || host === '127.0.0.1' || host === '[::1]' || host === '::1';
592
+ var portPart = location.port ? ':' + location.port : '';
593
+ var origin = location.protocol + '//';
594
+ var candidates = [];
595
+ // 当前地址对本机一定可达:不是回环就让它排第一,避免「本来能用却被换掉」
596
+ if (!isLoop) candidates.push({ url: location.origin + location.pathname, label: host });
597
+ list.forEach(function (item) {
598
+ candidates.push({
599
+ url: origin + item.address + portPart + '/localsend',
600
+ label: item.address + (item.iface ? ' · ' + item.iface : ''),
601
+ });
602
+ });
603
+ // 同一个地址可能出现两次(当前地址恰好也在候选列表里)
604
+ var seen = {};
605
+ candidates = candidates.filter(function (c) {
606
+ if (seen[c.url]) return false;
607
+ seen[c.url] = 1;
608
+ return true;
609
+ });
610
+ if (!candidates.length) return;
611
+ var preferred = candidates[0].url;
612
+ if (isLoop && data.suggested) {
613
+ for (var i = 0; i < candidates.length; i++) {
614
+ if (candidates[i].url.indexOf('//' + data.suggested + portPart) >= 0) {
615
+ preferred = candidates[i].url;
616
+ break;
617
+ }
618
+ }
619
+ }
620
+ var sel = $('addrSelect');
621
+ sel.innerHTML = candidates
622
+ .map(function (c) {
623
+ return '<option value="' + escapeHtml(c.url) + '"' + (c.url === preferred ? ' selected' : '') + '>' + escapeHtml(c.label) + '</option>';
624
+ })
625
+ .join('');
626
+ sel.classList.toggle('hidden', candidates.length < 2);
627
+ setPageUrl(preferred);
628
+ })
629
+ .catch(function () {
630
+ /* 拿不到候选地址时保持当前地址,不影响使用 */
631
+ });
632
+ }
633
+
634
+ $('addrSelect').addEventListener('change', function (e) { setPageUrl(e.target.value); });
635
+ // 排序偏好记忆:记住用户上次选择的排序方式与升降序
636
+ var sortType = 'time';
637
+ var sortOrder = 'desc';
638
+ try {
639
+ var savedSort = JSON.parse(localStorage.getItem('localsend.sort') || 'null');
640
+ if (savedSort && (savedSort.type === 'time' || savedSort.type === 'size' || savedSort.type === 'name')) {
641
+ sortType = savedSort.type;
642
+ if (savedSort.order === 'asc' || savedSort.order === 'desc') sortOrder = savedSort.order;
643
+ }
644
+ } catch (e) {
645
+ // localStorage 不可用时忽略
646
+ }
647
+ function saveSortPref() {
648
+ try {
649
+ localStorage.setItem('localsend.sort', JSON.stringify({ type: sortType, order: sortOrder }));
650
+ } catch (e) {
651
+ // 忽略存储失败
652
+ }
653
+ }
654
+ // 搜索关键词与分页状态
655
+ //
656
+ // 筛选条件(关键词、目录、扩展名、时间窗)全部下推到服务端,
657
+ // 前端只拿到并渲染当前这一页,文件再多也不会把浏览器压垮。
658
+ var searchKeyword = '';
659
+ // 目录筛选:空字符串表示不过滤,'__root__' 表示只看根目录文件
660
+ var dirFilter = '';
661
+ /** 本次上传的目标目录(相对路径,空串表示根目录):默认跟随当前筛选目录 */
662
+ var uploadTargetDir = '';
663
+ // 扩展名筛选:空字符串表示不过滤
664
+ var extFilter = '';
665
+ // 收件箱模式:只看最近收到的文件
666
+ var inboxMode = false;
667
+ var INBOX_WINDOW = 10 * 60 * 1000; // 收件箱时间窗口(10 分钟)
668
+ var inboxNewCount = 0; // 进入收件箱后新收到的文件数
669
+ var ownUploads = {}; // 本机刚上传的文件,避免自己提示自己
670
+ var suppressNotifyUntil = 0; // 自己操作后的静默期,不提示「收到新文件」
671
+ var eventSource = null; // 文件变更事件连接
672
+ var PAGE_SIZE = 50; // 每页显示的文件数(服务端分页)
673
+ var PAGE_SIZE_OPTIONS = [20, 50, 100, 200]; // 可选的每页条数
674
+ var currentPage = 1;
675
+ var totalPages = 1;
676
+ var totalCount = 0; // 当前筛选条件下的文件总数
677
+ var allCount = 0; // 全部文件数
678
+ var modalQrCode = null;
679
+ var selected = {};
680
+ var fileItems = [];
681
+ // 每页条数记忆:记住用户上次选择的分页大小
682
+ try {
683
+ var savedPageSize = Number(localStorage.getItem('localsend.pageSize') || 0);
684
+ if (PAGE_SIZE_OPTIONS.indexOf(savedPageSize) >= 0) PAGE_SIZE = savedPageSize;
685
+ } catch (e) {
686
+ // localStorage 不可用时忽略
687
+ }
688
+ function savePageSizePref() {
689
+ try {
690
+ localStorage.setItem('localsend.pageSize', String(PAGE_SIZE));
691
+ } catch (e) {
692
+ // 忽略存储失败
693
+ }
694
+ }
695
+ // 待高亮定位的文件名(上传成功后填充)
696
+ var pendingHighlight = [];
697
+ // 当前处于高亮状态的文件名
698
+ var highlightNames = {};
699
+ // 等待出现在列表中的新文件名
700
+ var highlightQueue = [];
701
+ // 高亮轮询定时器
702
+ var highlightTimer = null;
703
+
704
+ $('pageUrl').textContent = pageUrl;
705
+ $('pageUrl').title = pageUrl;
706
+ if (typeof QRCodeStyling !== 'undefined') {
707
+ var pageQrCode = new QRCodeStyling({
708
+ width: 220, height: 220, type: 'canvas', data: pageUrl, margin: 0,
709
+ dotsOptions: { type: 'rounded', color: '#10b981' },
710
+ backgroundOptions: { color: '#ffffff' },
711
+ cornersSquareOptions: { type: 'extra-rounded', color: '#10b981' },
712
+ cornersDotOptions: { type: 'dot', color: '#10b981' },
713
+ });
714
+ pageQrCode.append($('pageQr'));
715
+ }
716
+
717
+ function fmtSize(n) {
718
+ if (n < 1024) return n + ' B';
719
+ var units = ['KB', 'MB', 'GB', 'TB'];
720
+ var i = -1;
721
+ do { n /= 1024; i += 1; } while (n >= 1024 && i < units.length - 1);
722
+ return n.toFixed(1) + ' ' + units[i];
723
+ }
724
+ function fmtTime(ms) {
725
+ var d = new Date(ms);
726
+ var p = function (x) { return String(x).padStart(2, '0'); };
727
+ return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + p(d.getHours()) + ':' + p(d.getMinutes());
728
+ }
729
+ /** 把秒数说成人话:2 天 3 小时 / 15 分钟 */
730
+ function fmtDuration(seconds) {
731
+ var s = Number(seconds) || 0;
732
+ if (s < 60) return s + ' 秒';
733
+ var m = Math.floor(s / 60);
734
+ if (m < 60) return m + ' 分钟';
735
+ var h = Math.floor(m / 60);
736
+ if (h < 24) return h + ' 小时 ' + (m % 60) + ' 分';
737
+ return Math.floor(h / 24) + ' 天 ' + (h % 24) + ' 小时';
738
+ }
739
+ function escapeHtml(s) {
740
+ return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
741
+ }
742
+ function toast(msg, type, action) {
743
+ // 认证失效期间不弹错误提示:原因统一由重新认证弹窗说明,
744
+ // 否则同一个原因会在各个接口的失败回调里反复刷屏
745
+ if (authBlocked && type === 'err') return;
746
+ var el = $('toast');
747
+ el.textContent = '';
748
+ el.className = 'fixed bottom-6 left-1/2 -translate-x-1/2 z-[60] max-w-[92vw] rounded-xl px-4 sm:px-5 py-2.5 sm:py-3 text-xs sm:text-sm shadow-xl border border-white/10 flex items-center gap-3 ' + (type === 'ok' ? 'bg-emerald-600/90' : type === 'err' ? 'bg-red-600/90' : 'bg-slate-800/90');
749
+ el.appendChild(document.createTextNode(msg));
750
+ if (action) {
751
+ var btn = document.createElement('button');
752
+ btn.className = 'px-2 py-0.5 rounded border border-white/30 hover:bg-white/15 shrink-0 font-medium';
753
+ btn.textContent = action.label;
754
+ btn.addEventListener('click', function () {
755
+ el.classList.add('hidden');
756
+ action.onClick();
757
+ });
758
+ el.appendChild(btn);
759
+ }
760
+ el.classList.remove('hidden');
761
+ clearTimeout(el._t);
762
+ el._t = setTimeout(function () { el.classList.add('hidden'); }, action ? 6000 : 2600);
763
+ }
764
+ function copyText(text) {
765
+ var done = function () { toast('已复制到剪贴板', 'ok'); };
766
+ // 降级方案:部分环境(如页面未聚焦)不允许直接写剪贴板,改用临时文本域
767
+ var fallback = function () {
768
+ var ta = document.createElement('textarea');
769
+ ta.value = text;
770
+ ta.style.position = 'fixed';
771
+ ta.style.opacity = '0';
772
+ document.body.appendChild(ta);
773
+ ta.select();
774
+ try { document.execCommand('copy'); done(); } catch (e) { toast('复制失败', 'err'); }
775
+ document.body.removeChild(ta);
776
+ };
777
+ if (navigator.clipboard && window.isSecureContext) {
778
+ return navigator.clipboard.writeText(text).then(done).catch(fallback);
779
+ }
780
+ return fallback();
781
+ }
782
+
783
+ var iconMap = {
784
+ jpg: '🖼️', jpeg: '🖼️', png: '🖼️', gif: '🖼️', webp: '🖼️', svg: '🖼️', bmp: '🖼️', ico: '🖼️',
785
+ mp4: '🎬', mov: '🎬', avi: '🎬', mkv: '🎬', webm: '🎬', flv: '🎬',
786
+ mp3: '🎵', wav: '🎵', flac: '🎵', m4a: '🎵', ogg: '🎵',
787
+ zip: '🗜️', rar: '🗜️', '7z': '🗜️', tar: '🗜️', gz: '🗜️', tgz: '🗜️',
788
+ pdf: '📕', doc: '📘', docx: '📘', xls: '📊', xlsx: '📊', ppt: '📊', pptx: '📊', csv: '📊',
789
+ txt: '📃', md: '📃', html: '🌐', htm: '🌐', js: '💻', ts: '💻', json: '🧩', css: '🎨', xml: '🧾', log: '📝'
790
+ };
791
+ function fileIcon(name) {
792
+ var ext = (name.split('.').pop() || '').toLowerCase();
793
+ return iconMap[ext] || '📄';
794
+ }
795
+
796
+ // ---------------------------------------------------------------------------
797
+ // 图片缩略图
798
+ //
799
+ // 直接用原图当列表图标会让图片多的目录加载非常吃力。这里在浏览器端把
800
+ // 图片缩到很小尺寸后缓存起来:只在元素进入可视区域时才生成,
801
+ // 生成结果存在内存里,列表重绘时直接复用。
802
+ // ---------------------------------------------------------------------------
803
+ var THUMB_MAX_SIZE = 2 * 1024 * 1024; // 超过 2MB 的图片不生成缩略图,避免整图传输
804
+ var THUMB_EDGE = 96; // 缩略图最长边像素
805
+ var thumbCache = {}; // 文件名 -> dataURL
806
+ var thumbObserver = null;
807
+
808
+ /** 是否是可以生成缩略图的位图格式(SVG 有外部引用风险,暂不处理) */
809
+ function isThumbImage(name) {
810
+ return /\.(jpg|jpeg|png|gif|webp|bmp|avif)$/i.test(name);
811
+ }
812
+
813
+ /** 生成缩略图并填入 img 元素 */
814
+ function buildThumb(name, imgEl) {
815
+ if (thumbCache[name]) {
816
+ imgEl.src = thumbCache[name];
817
+ imgEl.style.opacity = '1';
818
+ return;
819
+ }
820
+ apiFetch(API + '/preview/' + encodeURIComponent(name))
821
+ .then(function (r) {
822
+ if (!r.ok) throw new Error('HTTP ' + r.status);
823
+ return r.blob();
824
+ })
825
+ .then(function (blob) {
826
+ if (!window.createImageBitmap) throw new Error('不支持 createImageBitmap');
827
+ return createImageBitmap(blob);
828
+ })
829
+ .then(function (bmp) {
830
+ var scale = Math.min(THUMB_EDGE / bmp.width, THUMB_EDGE / bmp.height, 1);
831
+ var canvas = document.createElement('canvas');
832
+ canvas.width = Math.max(1, Math.round(bmp.width * scale));
833
+ canvas.height = Math.max(1, Math.round(bmp.height * scale));
834
+ canvas.getContext('2d').drawImage(bmp, 0, 0, canvas.width, canvas.height);
835
+ if (bmp.close) bmp.close();
836
+ var dataUrl = canvas.toDataURL('image/webp', 0.8);
837
+ thumbCache[name] = dataUrl;
838
+ imgEl.src = dataUrl;
839
+ imgEl.style.opacity = '1';
840
+ })
841
+ .catch(function () {
842
+ // 生成失败时保留原来的图标,不打扰用户
843
+ });
844
+ }
845
+
846
+ /**
847
+ * 监听缩略图占位元素,进入可视区域后再生成。
848
+ *
849
+ * 观察的是外层固定尺寸的容器,而不是 img 本身:
850
+ * img 在生成前是透明的(而非 display:none),否则不会产生交叉事件。
851
+ */
852
+ function observeThumb(el) {
853
+ var name = el.dataset.thumb;
854
+ if (!name) return;
855
+ var imgEl = el.querySelector('img');
856
+ if (!imgEl) return;
857
+ if (thumbCache[name]) {
858
+ imgEl.src = thumbCache[name];
859
+ imgEl.style.opacity = '1';
860
+ return;
861
+ }
862
+ if (!thumbObserver) {
863
+ thumbObserver = new IntersectionObserver(
864
+ function (entries) {
865
+ entries.forEach(function (entry) {
866
+ if (!entry.isIntersecting) return;
867
+ thumbObserver.unobserve(entry.target);
868
+ buildThumb(entry.target.dataset.thumb, entry.target.querySelector('img'));
869
+ });
870
+ },
871
+ { rootMargin: '200px' }
872
+ );
873
+ }
874
+ thumbObserver.observe(el);
875
+ }
876
+ /** 生成一个行内操作按钮:移动端只显示图标,桌面端显示文字 */
877
+ function btn(label, act, danger, icon) {
878
+ var cls = danger ? 'text-red-400 hover:bg-red-500/10 border-red-500/30' : 'text-slate-300 hover:bg-slate-700/70 border-slate-600/60';
879
+ return (
880
+ '<button type="button" data-act="' +
881
+ act +
882
+ '" title="' +
883
+ label +
884
+ '" aria-label="' +
885
+ label +
886
+ '" class="px-2 py-2 sm:px-2.5 sm:py-1 rounded-lg text-xs border transition ' +
887
+ cls +
888
+ '">' +
889
+ '<span class="sm:hidden" aria-hidden="true">' + icon + '</span>' +
890
+ '<span class="hidden sm:inline">' + label + '</span>' +
891
+ '</button>'
892
+ );
893
+ }
894
+
895
+ /** 组装列表查询参数(筛选条件下推到服务端) */
896
+ function buildListQuery() {
897
+ var params = new URLSearchParams();
898
+ params.set('sort', sortType);
899
+ params.set('order', sortOrder);
900
+ params.set('page', String(currentPage));
901
+ params.set('pageSize', String(PAGE_SIZE));
902
+ if (searchKeyword) params.set('q', searchKeyword);
903
+ if (dirFilter) params.set('dir', dirFilter);
904
+ if (extFilter) params.set('ext', extFilter);
905
+ // 收件箱:只返回最近十分钟内收到的文件
906
+ if (inboxMode) params.set('since', String(Date.now() - INBOX_WINDOW));
907
+ return params.toString();
908
+ }
909
+
910
+ function loadFiles() {
911
+ return apiFetch(API + '/list?' + buildListQuery())
912
+ .then(function (r) { return r.json(); })
913
+ .then(function (json) {
914
+ if (json.code !== 0) throw new Error(json.msg || '加载失败');
915
+ renderList(json.data || {});
916
+ })
917
+ .catch(function () {
918
+ // 拿不到列表时给出明确原因,避免和「没有文件」混淆
919
+ $('emptyTip').classList.remove('hidden');
920
+ $('emptyTip').textContent = '无法连接服务端,请确认设备与本机在同一局域网';
921
+ $('fileCount').textContent = '';
922
+ });
923
+ }
924
+ function updateBatchUI() {
925
+ var names = Object.keys(selected).filter(function(n) { return selected[n]; });
926
+ var count = names.length;
927
+ // 全选的范围是当前页显示的文件
928
+ var pageItems = currentPageItems();
929
+ var total = pageItems.length;
930
+ var selectedOnPage = pageItems.filter(function (f) { return selected[f.name]; }).length;
931
+ $('batchBar').classList.toggle('hidden', allCount === 0);
932
+ $('selectAll').checked = total > 0 && selectedOnPage === total;
933
+ $('selectAll').indeterminate = selectedOnPage > 0 && selectedOnPage < total;
934
+ if (count > 0) {
935
+ $('selectedCount').classList.remove('hidden');
936
+ $('selectedCount').querySelector('em').textContent = count;
937
+ $('batchShare').disabled = false;
938
+ $('batchDownload').disabled = false;
939
+ $('batchMove').disabled = false;
940
+ $('batchRename').disabled = false;
941
+ $('batchDelete').disabled = false;
942
+ } else {
943
+ $('selectedCount').classList.add('hidden');
944
+ $('batchShare').disabled = true;
945
+ $('batchDownload').disabled = true;
946
+ $('batchMove').disabled = true;
947
+ $('batchRename').disabled = true;
948
+ $('batchDelete').disabled = true;
949
+ }
950
+ }
951
+ /** 更新分页控件状态 */
952
+ function updatePager() {
953
+ var pager = $('pager');
954
+ var show = totalPages > 1;
955
+ pager.classList.toggle('hidden', !show);
956
+ if (!show) {
957
+ $('pageInfo').textContent = '';
958
+ return;
959
+ }
960
+ $('pageInfo').textContent = '第 ' + currentPage + '/' + totalPages + ' 页 · 共 ' + totalCount + ' 条';
961
+ $('firstPage').disabled = currentPage <= 1;
962
+ $('prevPage').disabled = currentPage <= 1;
963
+ $('nextPage').disabled = currentPage >= totalPages;
964
+ $('lastPage').disabled = currentPage >= totalPages;
965
+ }
966
+
967
+ /** 当前页显示的文件(用于全选范围) */
968
+ function currentPageItems() {
969
+ return fileItems;
970
+ }
971
+
972
+ // ---------------------------------------------------------------------------
973
+ // 文件整理(重命名 / 移动 / 批量重命名)
974
+ //
975
+ // 整理结果直接体现在服务端的真实目录结构上,
976
+ // 前端只负责收集参数,并把服务端返回的新名字同步回列表。
977
+ // ---------------------------------------------------------------------------
978
+ /** 当前正在重命名的文件 */
979
+ var renameTarget = '';
980
+ /** 当前正在移动的文件列表 */
981
+ var moveTargets = [];
982
+ /** 当前正在批量重命名的文件列表 */
983
+ var batchTargets = [];
984
+ /** 服务端返回的目录与扩展名筛选项 */
985
+ var facetDirs = [];
986
+ var facetExts = [];
987
+
988
+ /** 打开重命名弹窗 */
989
+ function openRenameDialog(name) {
990
+ renameTarget = name;
991
+ var dir = dirOf(name);
992
+ $('renameInput').value = dir ? name.slice(dir.length + 1) : name;
993
+ $('renameDirHint').textContent = '当前位置:' + (dir ? dir + '/' : '根目录');
994
+ $('renameModal').classList.remove('hidden');
995
+ setTimeout(function () {
996
+ $('renameInput').focus();
997
+ $('renameInput').select();
998
+ }, 60);
999
+ }
1000
+
1001
+ /**
1002
+ * 把用户输入的目标名拼成相对存储目录的路径。
1003
+ *
1004
+ * 只填文件名 → 留在当前目录改名;
1005
+ * 以 / 开头 → 相对根目录;
1006
+ * 含 / → 相对根目录的多级路径。
1007
+ */
1008
+ function buildRenameTarget(from, input) {
1009
+ var value = input.trim();
1010
+ if (value.charAt(0) === '/') return value.slice(1);
1011
+ if (value.indexOf('/') >= 0) return value;
1012
+ var dir = dirOf(from);
1013
+ return dir ? dir + '/' + value : value;
1014
+ }
1015
+
1016
+ /** 关闭重命名弹窗 */
1017
+ function closeRenameDialog() {
1018
+ $('renameModal').classList.add('hidden');
1019
+ renameTarget = '';
1020
+ }
1021
+
1022
+ /** 提交重命名 */
1023
+ function submitRename() {
1024
+ var from = renameTarget;
1025
+ var input = $('renameInput').value.trim();
1026
+ if (!from) return;
1027
+ if (!input) {
1028
+ toast('请填写新的名称', 'err');
1029
+ return;
1030
+ }
1031
+ var to = buildRenameTarget(from, input);
1032
+ // 自己改的文件不再触发「收到新文件」提示
1033
+ suppressNotifyUntil = Date.now() + 2000;
1034
+ apiFetch(API + '/rename', {
1035
+ method: 'POST',
1036
+ headers: { 'Content-Type': 'application/json' },
1037
+ body: JSON.stringify({ from: from, to: to }),
1038
+ })
1039
+ .then(function (r) { return r.json(); })
1040
+ .then(function (json) {
1041
+ if (json.code !== 0) {
1042
+ toast(json.msg || '重命名失败', 'err');
1043
+ return;
1044
+ }
1045
+ // 选中状态跟着文件的新名字走
1046
+ if (selected[from]) {
1047
+ delete selected[from];
1048
+ selected[json.data.to] = true;
1049
+ }
1050
+ // 自己改的名不再提示「收到新文件」
1051
+ ownUploads[json.data.to] = Date.now();
1052
+ closeRenameDialog();
1053
+ toast('已重命名为 ' + json.data.to, 'ok');
1054
+ refreshAll();
1055
+ })
1056
+ .catch(function () { toast('重命名失败', 'err'); });
1057
+ }
1058
+
1059
+ /** 打开移动弹窗 */
1060
+ function openMoveDialog(names) {
1061
+ moveTargets = names.slice();
1062
+ $('moveCount').textContent = '(' + names.length + ' 个文件)';
1063
+ $('moveDirInput').value = '';
1064
+ // 目录列表来自服务端,能看到所有已存在的目录
1065
+ var html = '<button class="w-full text-left px-3 py-2 text-xs text-slate-300 hover:bg-slate-800 transition" data-dir="">根目录</button>';
1066
+ facetDirs.forEach(function (d) {
1067
+ html += '<button class="w-full text-left px-3 py-2 text-xs text-slate-300 hover:bg-slate-800 transition" data-dir="' + escapeHtml(d.path) + '">' + escapeHtml(d.path) + '</button>';
1068
+ });
1069
+ $('moveDirList').innerHTML = html;
1070
+ $('moveModal').classList.remove('hidden');
1071
+ }
1072
+
1073
+ /** 关闭移动弹窗 */
1074
+ function closeMoveDialog() {
1075
+ $('moveModal').classList.add('hidden');
1076
+ moveTargets = [];
1077
+ }
1078
+
1079
+ /** 提交移动 */
1080
+ function submitMove() {
1081
+ var names = moveTargets.slice();
1082
+ if (!names.length) return;
1083
+ var dir = $('moveDirInput').value.trim();
1084
+ suppressNotifyUntil = Date.now() + 2000;
1085
+ apiFetch(API + '/move', {
1086
+ method: 'POST',
1087
+ headers: { 'Content-Type': 'application/json' },
1088
+ body: JSON.stringify({ names: names, dir: dir }),
1089
+ })
1090
+ .then(function (r) { return r.json(); })
1091
+ .then(function (json) {
1092
+ if (json.code !== 0) {
1093
+ toast(json.msg || '移动失败', 'err');
1094
+ return;
1095
+ }
1096
+ var moved = (json.data && json.data.moved) || [];
1097
+ var failed = (json.data && json.data.failed) || [];
1098
+ // 移动后选中状态同步到新路径
1099
+ moved.forEach(function (m) {
1100
+ if (selected[m.from]) {
1101
+ delete selected[m.from];
1102
+ selected[m.to] = true;
1103
+ }
1104
+ // 自己移动的文件不再提示「收到新文件」
1105
+ ownUploads[m.to] = Date.now();
1106
+ });
1107
+ closeMoveDialog();
1108
+ if (failed.length) {
1109
+ toast('已移动 ' + moved.length + ' 个,' + failed.length + ' 个失败', 'err');
1110
+ } else {
1111
+ toast('已移动 ' + moved.length + ' 个文件', 'ok');
1112
+ }
1113
+ refreshAll();
1114
+ })
1115
+ .catch(function () { toast('移动失败', 'err'); });
1116
+ }
1117
+
1118
+ /** 收集批量重命名规则 */
1119
+ function collectRule() {
1120
+ var mode = $('batchRuleMode').value;
1121
+ var rule = { mode: mode };
1122
+ if (mode === 'prefix') rule.prefix = $('rulePrefix') ? $('rulePrefix').value : '';
1123
+ else if (mode === 'suffix') rule.suffix = $('ruleSuffix') ? $('ruleSuffix').value : '';
1124
+ else if (mode === 'replace') {
1125
+ rule.find = $('ruleFind') ? $('ruleFind').value : '';
1126
+ rule.replace = $('ruleReplace') ? $('ruleReplace').value : '';
1127
+ } else if (mode === 'sequence') {
1128
+ rule.start = Number($('ruleStart') ? $('ruleStart').value : 1) || 1;
1129
+ rule.padding = Number($('rulePadding') ? $('rulePadding').value : 0) || 0;
1130
+ rule.template = $('ruleTemplate') ? $('ruleTemplate').value : '{n}';
1131
+ }
1132
+ var ext = $('ruleExt');
1133
+ if (ext && ext.value) rule.ext = ext.value;
1134
+ return rule;
1135
+ }
1136
+
1137
+ /**
1138
+ * 本地预览重命名结果(与服务端规则保持一致)。
1139
+ * 只用于给用户看效果,真正的重命名仍由服务端执行。
1140
+ */
1141
+ function previewRename(base, rule, index) {
1142
+ if (rule.mode === 'prefix') return (rule.prefix || '') + base;
1143
+ if (rule.mode === 'suffix') return base + (rule.suffix || '');
1144
+ if (rule.mode === 'replace') {
1145
+ if (!rule.find) return base;
1146
+ return base.split(rule.find).join(rule.replace || '');
1147
+ }
1148
+ var start = rule.start || 1;
1149
+ var num = rule.padding ? String(start + index).padStart(rule.padding, '0') : String(start + index);
1150
+ return (rule.template || '{n}').replace('{n}', num).replace('{name}', base);
1151
+ }
1152
+
1153
+ /** 更新批量重命名的预览提示 */
1154
+ function updateRulePreview() {
1155
+ var rule = collectRule();
1156
+ var sample = batchTargets[0];
1157
+ var el = $('batchRulePreview');
1158
+ if (!el) return;
1159
+ if (!sample) {
1160
+ el.textContent = '';
1161
+ return;
1162
+ }
1163
+ var fileName = sample.slice(sample.lastIndexOf('/') + 1);
1164
+ var dot = fileName.lastIndexOf('.');
1165
+ var base = dot > 0 ? fileName.slice(0, dot) : fileName;
1166
+ var ext = dot > 0 ? fileName.slice(dot) : '';
1167
+ var next = previewRename(base, rule, 0) + ext;
1168
+ el.textContent = '示例:' + fileName + ' → ' + next + (batchTargets.length > 1 ? '(共 ' + batchTargets.length + ' 个文件)' : '');
1169
+ }
1170
+
1171
+ /** 按当前模式渲染规则参数 */
1172
+ function renderRuleParams() {
1173
+ var mode = $('batchRuleMode').value;
1174
+ var inputCls = 'bg-slate-800 border border-slate-700 rounded-lg px-3 py-2 text-sm outline-none focus:border-emerald-500/60';
1175
+ var html = '';
1176
+ if (mode === 'prefix') {
1177
+ html += '<input id="rulePrefix" type="text" placeholder="前缀,如 备份-" class="' + inputCls + '" />';
1178
+ } else if (mode === 'suffix') {
1179
+ html += '<input id="ruleSuffix" type="text" placeholder="后缀,如 -副本" class="' + inputCls + '" />';
1180
+ } else if (mode === 'replace') {
1181
+ html += '<input id="ruleFind" type="text" placeholder="查找,如 2024" class="' + inputCls + '" />';
1182
+ html += '<input id="ruleReplace" type="text" placeholder="替换为,如 2025" class="' + inputCls + '" />';
1183
+ } else if (mode === 'sequence') {
1184
+ html += '<div class="flex gap-2">';
1185
+ html += '<input id="ruleStart" type="number" min="0" value="1" placeholder="起始序号" class="' + inputCls + ' flex-1" />';
1186
+ html += '<input id="rulePadding" type="number" min="0" max="10" value="2" placeholder="补零位数" class="' + inputCls + ' flex-1" />';
1187
+ html += '</div>';
1188
+ html += '<input id="ruleTemplate" type="text" value="{n}" placeholder="模板,{n} 为序号、{name} 为原名" class="' + inputCls + '" />';
1189
+ }
1190
+ // 扩展名过滤:只处理某一类文件时可以限定范围
1191
+ html += '<select id="ruleExt" class="bg-slate-800 border border-slate-700 rounded-lg px-3 py-2 text-sm outline-none">';
1192
+ html += '<option value="">全部类型</option>';
1193
+ facetExts.forEach(function (e) {
1194
+ html += '<option value="' + escapeHtml(e.ext) + '">.' + escapeHtml(e.ext) + '(' + e.count + ')</option>';
1195
+ });
1196
+ html += '</select>';
1197
+ $('batchRuleParams').innerHTML = html;
1198
+ updateRulePreview();
1199
+ }
1200
+
1201
+ /** 打开批量重命名弹窗 */
1202
+ function openBatchRenameDialog(names) {
1203
+ batchTargets = names.slice();
1204
+ $('batchRenameCount').textContent = '(' + names.length + ' 个文件)';
1205
+ renderRuleParams();
1206
+ $('batchRenameModal').classList.remove('hidden');
1207
+ }
1208
+
1209
+ /** 关闭批量重命名弹窗 */
1210
+ function closeBatchRenameDialog() {
1211
+ $('batchRenameModal').classList.add('hidden');
1212
+ batchTargets = [];
1213
+ }
1214
+
1215
+ /** 提交批量重命名 */
1216
+ function submitBatchRename() {
1217
+ var names = batchTargets.slice();
1218
+ if (!names.length) return;
1219
+ var rule = collectRule();
1220
+ suppressNotifyUntil = Date.now() + 2000;
1221
+ apiFetch(API + '/rename-batch', {
1222
+ method: 'POST',
1223
+ headers: { 'Content-Type': 'application/json' },
1224
+ body: JSON.stringify({ names: names, rule: rule }),
1225
+ })
1226
+ .then(function (r) { return r.json(); })
1227
+ .then(function (json) {
1228
+ if (json.code !== 0) {
1229
+ toast(json.msg || '批量重命名失败', 'err');
1230
+ return;
1231
+ }
1232
+ var renamed = (json.data && json.data.renamed) || [];
1233
+ var failed = (json.data && json.data.failed) || [];
1234
+ var skipped = (json.data && json.data.skipped) || [];
1235
+ // 重命名后选中状态同步到新名字
1236
+ renamed.forEach(function (m) {
1237
+ if (selected[m.from]) {
1238
+ delete selected[m.from];
1239
+ selected[m.to] = true;
1240
+ }
1241
+ // 自己改的名字不再提示「收到新文件」
1242
+ ownUploads[m.to] = Date.now();
1243
+ });
1244
+ closeBatchRenameDialog();
1245
+ var tip = '已重命名 ' + renamed.length + ' 个文件';
1246
+ if (skipped.length) tip += ',' + skipped.length + ' 个未变化';
1247
+ if (failed.length) tip += ',' + failed.length + ' 个失败';
1248
+ toast(tip, failed.length ? 'err' : 'ok');
1249
+ refreshAll();
1250
+ })
1251
+ .catch(function () { toast('批量重命名失败', 'err'); });
1252
+ }
1253
+
1254
+ // ---------------------------------------------------------------------------
1255
+ // 本地目录自动上传
1256
+ //
1257
+ // 选中一个本地目录后定时扫描,目录里新增或修改的文件会自动上传到服务端。
1258
+ // 依赖 File System Access API(Chrome / Edge 等),不支持的浏览器会给出提示。
1259
+ // ---------------------------------------------------------------------------
1260
+ var watchHandle = null; // 被监听的目录句柄
1261
+ var watchTimer = null; // 扫描定时器
1262
+ var watchSeen = {}; // 已上传文件的标识:名称:大小:修改时间
1263
+ var WATCH_INTERVAL = 3000; // 扫描间隔(毫秒)
1264
+
1265
+ /** 更新监听状态提示 */
1266
+ function updateWatchStatus() {
1267
+ var el = $('watchStatus');
1268
+ if (!el) return;
1269
+ if (!watchHandle) {
1270
+ el.classList.add('hidden');
1271
+ el.classList.remove('flex');
1272
+ el.textContent = '';
1273
+ $('watchDirBtn').textContent = '📡 监听目录';
1274
+ return;
1275
+ }
1276
+ el.classList.remove('hidden');
1277
+ el.classList.add('flex');
1278
+ el.innerHTML = '<span>📡 正在监听「' + escapeHtml(watchHandle.name) + '」</span>' +
1279
+ '<button id="watchStopBtn" class="px-1.5 py-0.5 rounded border border-slate-700 hover:bg-slate-700 transition">停止</button>';
1280
+ $('watchDirBtn').textContent = '📡 换个目录';
1281
+ $('watchStopBtn').addEventListener('click', stopWatchDir);
1282
+ }
1283
+
1284
+ /** 停止监听 */
1285
+ function stopWatchDir() {
1286
+ if (watchTimer) clearInterval(watchTimer);
1287
+ watchTimer = null;
1288
+ watchHandle = null;
1289
+ watchSeen = {};
1290
+ updateWatchStatus();
1291
+ toast('已停止监听本地目录');
1292
+ }
1293
+
1294
+ /** 扫描一次目录,把新增文件加入上传队列 */
1295
+ async function scanWatchDir() {
1296
+ if (!watchHandle) return;
1297
+ var handle = watchHandle;
1298
+ try {
1299
+ var jobs = [];
1300
+ for await (var entry of handle.values()) {
1301
+ if (entry.kind !== 'file') continue;
1302
+ jobs.push(
1303
+ entry
1304
+ .getFile()
1305
+ .then(function (file) {
1306
+ // 用「名称:大小:修改时间」判断是否已经传过
1307
+ var key = entry.name + ':' + file.size + ':' + file.lastModified;
1308
+ if (watchSeen[key]) return;
1309
+ watchSeen[key] = true;
1310
+ enqueueUpload(file, entry.name);
1311
+ })
1312
+ .catch(function () {
1313
+ // 单个文件读取失败不影响其它文件
1314
+ })
1315
+ );
1316
+ }
1317
+ await Promise.all(jobs);
1318
+ pumpQueue();
1319
+ } catch (e) {
1320
+ // 目录权限失效等情况忽略,等待下一次扫描
1321
+ }
1322
+ }
1323
+
1324
+ /** 选择目录并开始监听 */
1325
+ function startWatchDir() {
1326
+ if (!window.showDirectoryPicker) {
1327
+ toast('当前浏览器不支持目录监听,请使用 Chrome / Edge 桌面版', 'err');
1328
+ return;
1329
+ }
1330
+ if (!window.isSecureContext) {
1331
+ toast('目录监听需要 https 或 localhost 环境', 'err');
1332
+ return;
1333
+ }
1334
+ window
1335
+ .showDirectoryPicker({ mode: 'read' })
1336
+ .then(function (handle) {
1337
+ watchHandle = handle;
1338
+ watchSeen = {};
1339
+ if (watchTimer) clearInterval(watchTimer);
1340
+ watchTimer = setInterval(scanWatchDir, WATCH_INTERVAL);
1341
+ updateWatchStatus();
1342
+ scanWatchDir();
1343
+ toast('已开始监听「' + handle.name + '」,新增文件会自动上传');
1344
+ })
1345
+ .catch(function (err) {
1346
+ // 用户取消选择时无需提示
1347
+ if (err && err.name === 'AbortError') return;
1348
+ toast('无法监听该目录', 'err');
1349
+ });
1350
+ }
1351
+
1352
+ /** 取文件所在目录(相对路径,无目录时返回空串) */
1353
+ function dirOf(name) {
1354
+ var i = name.lastIndexOf('/');
1355
+ return i < 0 ? '' : name.slice(0, i);
1356
+ }
1357
+
1358
+ // ---------------------------------------------------------------------------
1359
+ // 收件箱与实时通知
1360
+ //
1361
+ // 服务端通过 SSE 推送文件变更,页面收到后立即刷新列表并提示,
1362
+ // 这样手机端放着一台「接文件」的机器时,不用手动刷新就知道来新文件了。
1363
+ // ---------------------------------------------------------------------------
1364
+
1365
+ /** 刷新收件箱按钮上的未读计数 */
1366
+ function updateInboxBadge() {
1367
+ var el = $('inboxCount');
1368
+ if (!el) return;
1369
+ if (inboxNewCount > 0) {
1370
+ el.classList.remove('hidden');
1371
+ el.textContent = inboxNewCount;
1372
+ } else {
1373
+ el.classList.add('hidden');
1374
+ el.textContent = '';
1375
+ }
1376
+ $('inboxBtn').classList.toggle('border-emerald-500/60', inboxMode);
1377
+ $('inboxBtn').classList.toggle('text-emerald-400', inboxMode);
1378
+ }
1379
+
1380
+ /** 系统级通知(用户授权后才发送) */
1381
+ function notifySystem(names) {
1382
+ if (!('Notification' in window) || Notification.permission !== 'granted') return;
1383
+ try {
1384
+ var body = names.slice(0, 3).join('、') + (names.length > 3 ? ' 等 ' + names.length + ' 个文件' : '');
1385
+ var notice = new Notification('收到新文件', { body: body, icon: '/localsend/favicon.png', tag: 'localsend-inbox' });
1386
+ notice.onclick = function () {
1387
+ window.focus();
1388
+ notice.close();
1389
+ };
1390
+ } catch (e) {
1391
+ // 通知失败不影响主流程
1392
+ }
1393
+ }
1394
+
1395
+ /** 待合并的变更事件(一轮上传会推送很多次,合并后再刷新) */
1396
+ var incomingBuffer = [];
1397
+ var incomingTimer = null;
1398
+ var INCOMING_DEBOUNCE = 350;
1399
+
1400
+ /**
1401
+ * 处理服务端推送的文件变更。
1402
+ *
1403
+ * 一次上传几十个文件时,服务端会按批推送多条事件;
1404
+ * 如果每条都立刻刷新列表 + 筛选 + 用量,浏览器会连着发几十轮请求。
1405
+ * 这里做 350ms 合并:同一窗口内的变更只触发一次刷新与一次提示。
1406
+ */
1407
+ function handleIncoming(names) {
1408
+ if (names && names.length) incomingBuffer = incomingBuffer.concat(names);
1409
+ if (incomingTimer) return;
1410
+ incomingTimer = setTimeout(flushIncoming, INCOMING_DEBOUNCE);
1411
+ }
1412
+
1413
+ /** 合并窗口结束:去重、刷新、提示 */
1414
+ function flushIncoming() {
1415
+ incomingTimer = null;
1416
+ var names = incomingBuffer;
1417
+ incomingBuffer = [];
1418
+ if (!names.length) return;
1419
+ var now = Date.now();
1420
+ // 自己刚做的整理操作(重命名、移动等)也会触发变更推送,
1421
+ // 这段时间内不再提示「收到新文件」,避免把操作结果当成别人的文件
1422
+ if (now < suppressNotifyUntil) {
1423
+ refreshAll();
1424
+ return;
1425
+ }
1426
+ // 去重后过滤掉本机刚上传的文件,避免自己提示自己
1427
+ var fresh = [];
1428
+ names.forEach(function (n) {
1429
+ if (fresh.indexOf(n) >= 0) return;
1430
+ var at = ownUploads[n];
1431
+ if (at && now - at < 10000) {
1432
+ delete ownUploads[n];
1433
+ return;
1434
+ }
1435
+ fresh.push(n);
1436
+ });
1437
+ refreshAll();
1438
+ if (!fresh.length) return;
1439
+ inboxNewCount += fresh.length;
1440
+ updateInboxBadge();
1441
+ var text = fresh.length === 1 ? '收到新文件:' + fresh[0] : '收到 ' + fresh.length + ' 个新文件:' + fresh.slice(0, 2).join('、');
1442
+ toast(text, 'ok');
1443
+ notifySystem(fresh);
1444
+ }
1445
+
1446
+ /** 事件流连接代号:异步换票期间可能已经重新连接,旧回调要作废 */
1447
+ var eventsGeneration = 0;
1448
+
1449
+ /** 订阅服务端文件变更事件 */
1450
+ function connectEvents() {
1451
+ if (!window.EventSource) return;
1452
+ // 认证失效期间不再订阅:连上去只会不断拿到 401
1453
+ if (authBlocked) return;
1454
+ // 已有连接时先断开,避免重复订阅
1455
+ closeEvents();
1456
+ var generation = ++eventsGeneration;
1457
+ // EventSource 带不了请求头,用短期票据代替把会话写进 URL
1458
+ ticketUrl('events', [], '/events')
1459
+ .then(function (url) {
1460
+ // 换票期间可能已经断线重连或退出登录,旧请求直接作废
1461
+ if (generation !== eventsGeneration || authBlocked) return;
1462
+ try {
1463
+ eventSource = new EventSource(url);
1464
+ } catch (e) {
1465
+ return;
1466
+ }
1467
+ eventSource.addEventListener('changed', function (e) {
1468
+ var payload = null;
1469
+ try {
1470
+ payload = JSON.parse(e.data);
1471
+ } catch (err) {
1472
+ return;
1473
+ }
1474
+ handleIncoming((payload && payload.names) || []);
1475
+ });
1476
+ /**
1477
+ * 连接断开时浏览器会按 retry 间隔自动重连。
1478
+ *
1479
+ * 票据到期或连接被拒时浏览器会彻底放弃(readyState = CLOSED),
1480
+ * 这时才重新换票并重建连接;仍在重连中(CONNECTING)就交给浏览器,
1481
+ * 避免每次抖动都多发一次请求。
1482
+ *
1483
+ * 如果是因为会话失效导致的拒绝,先探测一次会话状态,
1484
+ * 确认失效就进入统一的重新认证流程(清会话、停后台任务、提示登录)。
1485
+ */
1486
+ eventSource.onerror = function () {
1487
+ if (authBlocked) {
1488
+ closeEvents();
1489
+ return;
1490
+ }
1491
+ if (eventSource && eventSource.readyState !== 2) return;
1492
+ var now = Date.now();
1493
+ // 限制重建频率:断线可能连续触发多次
1494
+ if (now - sseProbeAt < 5000) return;
1495
+ sseProbeAt = now;
1496
+ refreshSession().then(function (ok) {
1497
+ if (ok) connectEvents();
1498
+ });
1499
+ };
1500
+ })
1501
+ .catch(function () {
1502
+ // 换票失败(比如服务端刚重启):稍后再试,不打扰用户
1503
+ if (authBlocked) return;
1504
+ setTimeout(function () {
1505
+ if (!authBlocked && generation === eventsGeneration) connectEvents();
1506
+ }, 5000);
1507
+ });
1508
+ }
1509
+
1510
+ /**
1511
+ * 断开事件流。
1512
+ *
1513
+ * 会话失效时必须主动断开:EventSource 会自动重连,
1514
+ * 未授权的重连很快就会把接口频率限制打满,连正常请求都会被牵连。
1515
+ */
1516
+ function closeEvents() {
1517
+ // 让仍在换票过程中的连接尝试作废
1518
+ eventsGeneration += 1;
1519
+ if (!eventSource) return;
1520
+ try {
1521
+ eventSource.close();
1522
+ } catch (e) {
1523
+ // 忽略关闭异常
1524
+ }
1525
+ eventSource = null;
1526
+ }
1527
+
1528
+ /** 刷新目录筛选下拉选项(数据来自服务端,前端不再需要全量列表) */
1529
+ function updateDirOptions(dirs, rootCount) {
1530
+ var sel = $('dirSelect');
1531
+ if (!sel) return;
1532
+ var html = '<option value="">全部目录</option>';
1533
+ if (rootCount) html += '<option value="__root__">根目录(' + rootCount + ')</option>';
1534
+ dirs.forEach(function (d) {
1535
+ html += '<option value="' + escapeHtml(d.path) + '">' + escapeHtml(d.path) + '(' + d.count + ')</option>';
1536
+ });
1537
+ sel.innerHTML = html;
1538
+ // 目录已不存在(被删除或移动)时回到「全部目录」
1539
+ var exists = dirs.some(function (d) { return d.path === dirFilter; });
1540
+ if (dirFilter && dirFilter !== '__root__' && !exists) dirFilter = '';
1541
+ sel.value = dirFilter;
1542
+ // 上传目标的可选项与目录筛选同源
1543
+ updateUploadDirOptions();
1544
+ }
1545
+
1546
+ /**
1547
+ * 刷新「上传到」下拉。
1548
+ *
1549
+ * 上传目标默认跟随当前筛选目录,也可以单独改:
1550
+ * 在「归档/2026」视图里上传,文件就落在这个目录,不必传完再移动一次。
1551
+ */
1552
+ function updateUploadDirOptions() {
1553
+ var sel = $('uploadDirSelect');
1554
+ if (!sel) return;
1555
+ var html = '<option value="">根目录</option>';
1556
+ facetDirs.forEach(function (d) {
1557
+ html += '<option value="' + escapeHtml(d.path) + '">' + escapeHtml(d.path) + '</option>';
1558
+ });
1559
+ // 当前目标是新出现的目录时也补一个选项,避免下拉选不中
1560
+ var known = !uploadTargetDir || facetDirs.some(function (d) { return d.path === uploadTargetDir; });
1561
+ if (!known) html += '<option value="' + escapeHtml(uploadTargetDir) + '">' + escapeHtml(uploadTargetDir) + '</option>';
1562
+ sel.innerHTML = html;
1563
+ sel.value = uploadTargetDir;
1564
+ }
1565
+
1566
+ /** 切换目录筛选:上传目标跟着走 */
1567
+ function setDirFilter(value) {
1568
+ dirFilter = value;
1569
+ currentPage = 1;
1570
+ uploadTargetDir = dirFilter && dirFilter !== '__root__' ? dirFilter : '';
1571
+ updateUploadDirOptions();
1572
+ }
1573
+
1574
+ /** 刷新扩展名筛选下拉选项 */
1575
+ function updateExtOptions(exts) {
1576
+ var sel = $('extSelect');
1577
+ if (!sel) return;
1578
+ var html = '<option value="">全部类型</option>';
1579
+ exts.forEach(function (e) {
1580
+ html += '<option value="' + escapeHtml(e.ext) + '">.' + escapeHtml(e.ext) + '(' + e.count + ')</option>';
1581
+ });
1582
+ sel.innerHTML = html;
1583
+ // 该类型已不存在时回到「全部类型」
1584
+ var exists = exts.some(function (e) { return e.ext === extFilter; });
1585
+ if (extFilter && !exists) extFilter = '';
1586
+ sel.value = extFilter;
1587
+ }
1588
+
1589
+ /** 拉取筛选选项(目录 / 扩展名) */
1590
+ function loadFacets() {
1591
+ return apiFetch(API + '/facets')
1592
+ .then(function (r) { return r.json(); })
1593
+ .then(function (json) {
1594
+ if (json.code !== 0) return;
1595
+ var data = json.data || {};
1596
+ facetDirs = data.dirs || [];
1597
+ facetExts = data.exts || [];
1598
+ updateDirOptions(facetDirs, data.rootCount || 0);
1599
+ updateExtOptions(facetExts);
1600
+ })
1601
+ .catch(function () {
1602
+ // 筛选选项拉取失败不影响主流程,静默忽略
1603
+ });
1604
+ }
1605
+
1606
+ /** 拉取存储用量并刷新进度条 */
1607
+ function loadUsage() {
1608
+ return apiFetch(API + '/usage')
1609
+ .then(function (r) { return r.json(); })
1610
+ .then(function (json) {
1611
+ if (json.code !== 0) return;
1612
+ var d = json.data || {};
1613
+ lastUsage = d;
1614
+ var used = Number(d.used) || 0;
1615
+ var limit = Number(d.limit) || 0;
1616
+ var trash = Number(d.trash) || 0;
1617
+ var bar = $('usageBar');
1618
+ if (!bar) return;
1619
+ bar.classList.remove('hidden');
1620
+ $('usageText').textContent = limit
1621
+ ? '已用 ' + fmtSize(used) + ' / ' + fmtSize(limit) + '(剩余 ' + fmtSize(Math.max(0, limit - used)) + ')'
1622
+ : '已用 ' + fmtSize(used) + ' · 未设容量上限';
1623
+ $('usageTrash').textContent = trash ? '回收站 ' + fmtSize(trash) : '';
1624
+ var fill = $('usageFill');
1625
+ if (!limit) {
1626
+ fill.style.width = '0%';
1627
+ return;
1628
+ }
1629
+ var pct = Math.min(100, Math.max(0, Math.round((used / limit) * 100)));
1630
+ fill.style.width = pct + '%';
1631
+ fill.className = 'h-full transition-all ' + (pct >= 90 ? 'bg-red-500' : pct >= 70 ? 'bg-amber-500' : 'bg-emerald-500');
1632
+ updateHostInfo(d);
1633
+ })
1634
+ .catch(function () {
1635
+ /* 用量拿不到不影响主流程 */
1636
+ });
1637
+ }
1638
+
1639
+ /**
1640
+ * 刷新头部那行「这台机器在做什么」。
1641
+ *
1642
+ * 首次进入的疑问往往是:文件存哪、能放多久、谁能看到。
1643
+ * 这里用一行把关键信息说清楚,避免用户去翻配置。
1644
+ */
1645
+ function updateHostInfo(usage) {
1646
+ var el = $('hostInfo');
1647
+ if (!el) return;
1648
+ var parts = [];
1649
+ if (usage && usage.dir) parts.push('存储:' + usage.dir);
1650
+ if (usage && usage.trashDays) parts.push('回收站保留 ' + usage.trashDays + ' 天');
1651
+ if (usage && usage.autoCleanDays) parts.push('超过 ' + usage.autoCleanDays + ' 天自动清理');
1652
+ if (usage && usage.maxSize) parts.push('单文件上限 ' + fmtSize(usage.maxSize));
1653
+ if (sessionInfo.open) parts.push('未设口令:同网段设备可直接访问');
1654
+ el.textContent = parts.join(' · ');
1655
+ }
1656
+
1657
+ /** 文件变动后同时刷新列表、筛选选项与用量 */
1658
+ function refreshAll() {
1659
+ loadFiles();
1660
+ loadFacets();
1661
+ loadUsage();
1662
+ }
1663
+
1664
+ function renderList(data) {
1665
+ var items = (data && data.items) || [];
1666
+ fileItems = items;
1667
+ // 分页信息由服务端给出,页码可能被收敛(如删完最后一页)
1668
+ totalPages = Math.max(1, Number(data && data.totalPages) || 1);
1669
+ currentPage = Math.max(1, Number(data && data.page) || 1);
1670
+ totalCount = Number(data && data.total) || 0;
1671
+ allCount = Number(data && data.allTotal) || 0;
1672
+
1673
+ var wrap = $('fileList');
1674
+ // 重绘前解除旧的缩略图监听,避免观察者持有已移除的节点
1675
+ if (thumbObserver) {
1676
+ Array.prototype.forEach.call(wrap.querySelectorAll('[data-thumb]'), function (el) { thumbObserver.unobserve(el); });
1677
+ }
1678
+ wrap.innerHTML = '';
1679
+ var isEmpty = allCount === 0;
1680
+ var hasFilter = !!(searchKeyword || dirFilter || extFilter || inboxMode);
1681
+ // 首次使用(目录里一个文件都没有、也没加筛选)时给三步引导,
1682
+ // 这时候「空列表」本身不说明该干什么
1683
+ var showFirstRun = isEmpty && !hasFilter;
1684
+ $('firstRun').classList.toggle('hidden', !showFirstRun);
1685
+ $('emptyTip').classList.toggle('hidden', !isEmpty || showFirstRun);
1686
+ if (!isEmpty && items.length === 0) {
1687
+ $('emptyTip').classList.remove('hidden');
1688
+ $('emptyTip').textContent = searchKeyword
1689
+ ? '没有匹配「' + searchKeyword + '」的文件'
1690
+ : inboxMode ? '收件箱里还没有新文件(最近 ' + Math.round(INBOX_WINDOW / 60000) + ' 分钟)' : '没有匹配当前筛选条件的文件';
1691
+ } else {
1692
+ $('emptyTip').textContent = '暂无文件,上传第一个文件开始传输吧';
1693
+ }
1694
+ $('fileCount').textContent = (searchKeyword || dirFilter || extFilter || inboxMode)
1695
+ ? '(' + totalCount + '/' + allCount + ')'
1696
+ : '(' + allCount + ')';
1697
+ updateBatchUI();
1698
+ updatePager();
1699
+ items.forEach(function (f) {
1700
+ var div = document.createElement('div');
1701
+ div.className = 'flex items-center gap-2 sm:gap-3 px-3 sm:px-4 py-2.5 sm:py-3 hover:bg-slate-800/60 transition flex-wrap' + (selected[f.name] ? ' bg-slate-800/40' : '');
1702
+ div.dataset.name = f.name;
1703
+ if (highlightNames[f.name]) div.classList.add('file-new-flash');
1704
+ // 子目录文件:主标题显示文件名,前面带可点击的目录标记
1705
+ var dir = dirOf(f.name);
1706
+ var base = dir ? f.name.slice(dir.length + 1) : f.name;
1707
+ div.innerHTML =
1708
+ '<label class="flex items-center shrink-0 cursor-pointer"><input type="checkbox" class="file-check accent-emerald-500 w-3.5 h-3.5" data-name="' + escapeHtml(f.name) + '"' + (selected[f.name] ? ' checked' : '') + '></label>' +
1709
+ (isThumbImage(f.name) && f.size <= THUMB_MAX_SIZE
1710
+ ? '<span data-thumb="' + escapeHtml(f.name) + '" class="relative w-10 h-10 sm:w-12 sm:h-12 shrink-0 flex items-center justify-center">' +
1711
+ '<span class="text-xl sm:text-2xl">' + fileIcon(f.name) + '</span>' +
1712
+ '<img alt="" class="absolute inset-0 w-full h-full rounded-lg object-cover bg-slate-800 opacity-0 transition-opacity" />' +
1713
+ '</span>'
1714
+ : '<span class="text-xl sm:text-2xl shrink-0">' + fileIcon(f.name) + '</span>') +
1715
+ '<div class="min-w-0 flex-1">' +
1716
+ '<div class="text-sm truncate text-slate-200" title="' + escapeHtml(f.name) + '">' +
1717
+ (dir ? '<span class="text-slate-500 hover:text-emerald-400 cursor-pointer" data-dir="' + escapeHtml(dir) + '" title="只看该目录">' + escapeHtml(dir) + '/</span> ' : '') +
1718
+ escapeHtml(base) +
1719
+ '</div>' +
1720
+ '<div class="text-xs text-slate-500 mt-0.5">' + fmtSize(f.size) + ' · ' + fmtTime(f.mtime) + '</div>' +
1721
+ '</div>' +
1722
+ '<div class="flex items-center gap-1 sm:gap-1.5 shrink-0 justify-end w-full sm:w-auto">' +
1723
+ btn('预览', 'preview', false, '👁') + btn('下载', 'download', false, '⬇️') +
1724
+ // 桌面端保留完整按钮;移动端收进「更多」,避免一行挤 6-9 个图标
1725
+ '<span class="hidden sm:flex items-center gap-1 sm:gap-1.5">' +
1726
+ (canWrite() ? btn('分享', 'share', false, '🔗') : '') +
1727
+ (canSystemShare() ? btn('系统分享', 'syshare', false, '📤') : '') +
1728
+ // 扫码与分享同源:都是生成免登录的分享链接,不再暴露带凭据的直链
1729
+ (canWrite() ? btn('扫码分享', 'qr', false, '📱') : '') +
1730
+ // 整理与删除属于危险操作,只有管理员能看到
1731
+ (isAdmin() ? btn('重命名', 'rename', false, '✏️') + btn('移动', 'move', false, '📂') + btn('删除', 'delete', true, '🗑') : '') +
1732
+ '</span>' +
1733
+ '<button type="button" data-act="more" title="更多操作" aria-label="更多操作" aria-haspopup="menu" class="sm:hidden px-2.5 py-2 rounded-lg text-xs border border-slate-600/60 text-slate-300">⋯</button>' +
1734
+ '</div>';
1735
+ Array.prototype.forEach.call(div.querySelectorAll('button'), function (b) { b.dataset.name = f.name; });
1736
+ wrap.appendChild(div);
1737
+ // 图片缩略图:进入可视区域后再生成
1738
+ var thumbEl = div.querySelector('[data-thumb]');
1739
+ if (thumbEl) observeThumb(thumbEl);
1740
+ });
1741
+
1742
+ // 上传后定位并高亮新出现的文件
1743
+ if (pendingHighlight.length) {
1744
+ var names = pendingHighlight;
1745
+ pendingHighlight = [];
1746
+ var found = names.filter(function (n) { return items.some(function (f) { return f.name === n; }); });
1747
+ if (found.length) {
1748
+ found.forEach(function (n) { highlightNames[n] = true; });
1749
+ // 直接给已渲染的行加上高亮样式,并滚动定位到第一个
1750
+ var rows = wrap.querySelectorAll(':scope > div');
1751
+ var target = null;
1752
+ for (var i = 0; i < rows.length; i++) {
1753
+ if (found.indexOf(rows[i].dataset.name) >= 0) {
1754
+ rows[i].classList.add('file-new-flash');
1755
+ if (!target) target = rows[i];
1756
+ }
1757
+ }
1758
+ if (target) {
1759
+ target.scrollIntoView({ behavior: 'smooth', block: 'center' });
1760
+ }
1761
+ // 3 秒后淡出高亮
1762
+ setTimeout(function () {
1763
+ Object.keys(highlightNames).forEach(function (n) { delete highlightNames[n]; });
1764
+ wrap.querySelectorAll(':scope > div.file-new-flash').forEach(function (el) {
1765
+ el.classList.remove('file-new-flash');
1766
+ });
1767
+ }, 3000);
1768
+ }
1769
+ }
1770
+ }
1771
+
1772
+ /**
1773
+ * 递归展开拖拽进来的目录条目。
1774
+ *
1775
+ * 浏览器拖拽文件夹时只会给出目录条目本身,需要逐层读取子项,
1776
+ * 最终返回 [{ file, rel }] 列表,rel 为带目录前缀的相对路径。
1777
+ */
1778
+ function readEntry(entry, prefix) {
1779
+ return new Promise(function (resolve) {
1780
+ if (entry.isFile) {
1781
+ entry.file(
1782
+ function (f) { resolve([{ file: f, rel: prefix + f.name }]); },
1783
+ function () { resolve([]); }
1784
+ );
1785
+ return;
1786
+ }
1787
+ if (!entry.isDirectory) {
1788
+ resolve([]);
1789
+ return;
1790
+ }
1791
+ var reader = entry.createReader();
1792
+ var pending = [];
1793
+ var readBatch = function () {
1794
+ reader.readEntries(
1795
+ function (list) {
1796
+ // 每次最多返回 100 项,读到空数组才算读完
1797
+ if (!list.length) {
1798
+ Promise.all(pending).then(function (parts) {
1799
+ var out = [];
1800
+ parts.forEach(function (arr) { out = out.concat(arr); });
1801
+ resolve(out);
1802
+ });
1803
+ return;
1804
+ }
1805
+ list.forEach(function (child) { pending.push(readEntry(child, prefix + entry.name + '/')); });
1806
+ readBatch();
1807
+ },
1808
+ function () { resolve([]); }
1809
+ );
1810
+ };
1811
+ readBatch();
1812
+ });
1813
+ }
1814
+
1815
+ /**
1816
+ * 加入上传队列。
1817
+ *
1818
+ * 上传文件夹时浏览器会给出 webkitRelativePath(形如「目录/子目录/文件.txt」),
1819
+ * 这里把它作为 multipart 的 filename 一起发送,服务端据此还原目录结构。
1820
+ */
1821
+ function uploadFiles(fileList) {
1822
+ Array.prototype.forEach.call(fileList, function (f) {
1823
+ var rel = f.webkitRelativePath || f.name;
1824
+ enqueueUpload(f, rel);
1825
+ });
1826
+ pumpQueue();
1827
+ }
1828
+
1829
+ // ---------------------------------------------------------------------------
1830
+ // 上传并发队列
1831
+ //
1832
+ // 服务端对单 IP 的并发上传数有上限(默认 3),一次选中几十个文件时
1833
+ // 若同时发起所有请求,超出的会被直接拒绝(429)。
1834
+ // 这里用队列把并发控制在安全范围内,并对被限流的请求自动退避重试。
1835
+ // ---------------------------------------------------------------------------
1836
+ var UPLOAD_CONCURRENCY = 3; // 与服务端 maxConcurrent 默认值保持一致
1837
+ var MAX_RETRY = 3; // 单个文件最多重试次数
1838
+ var CHUNK_THRESHOLD = 8 * 1024 * 1024; // 超过 8MB 走分片并发上传
1839
+ var CHUNK_SIZE = 4 * 1024 * 1024; // 分片大小 4MB
1840
+ var CHUNK_CONCURRENCY = 3; // 并发分片数(与服务端并发上限一致)
1841
+
1842
+ // 续传记录:文件指纹 -> uploadId。断线、刷新页面、服务重启后据此接上。
1843
+ var UPLOAD_IDS_KEY = 'localsend.uploads';
1844
+ var UPLOAD_IDS_MAX = 20; // 最多记住 20 个未完成任务,避免 localStorage 无限增长
1845
+
1846
+ /** 文件指纹:名称 + 大小 + 修改时间。同名但内容变了的文件不会被误续传 */
1847
+ function fileKeyOf(rel, file) {
1848
+ return rel + ':' + file.size + ':' + (file.lastModified || 0);
1849
+ }
1850
+
1851
+ function readUploadIds() {
1852
+ try {
1853
+ var map = JSON.parse(localStorage.getItem(UPLOAD_IDS_KEY) || '{}');
1854
+ return map && typeof map === 'object' ? map : {};
1855
+ } catch (e) {
1856
+ return {};
1857
+ }
1858
+ }
1859
+
1860
+ /** 取该文件上次的任务 ID */
1861
+ function getUploadId(fileKey) {
1862
+ return readUploadIds()[fileKey] || '';
1863
+ }
1864
+
1865
+ /** 记录/清除续传任务(id 为空表示清除) */
1866
+ function saveUploadId(fileKey, id) {
1867
+ var map = readUploadIds();
1868
+ if (id) map[fileKey] = id;
1869
+ else delete map[fileKey];
1870
+ var keys = Object.keys(map);
1871
+ while (keys.length > UPLOAD_IDS_MAX) delete map[keys.shift()];
1872
+ try {
1873
+ localStorage.setItem(UPLOAD_IDS_KEY, JSON.stringify(map));
1874
+ } catch (e) {
1875
+ // 存储不可用时忽略:只是失去跨刷新的续传能力
1876
+ }
1877
+ }
1878
+ var uploadQueue = []; // 待上传的文件
1879
+ var uploadActive = 0; // 当前进行中的上传数
1880
+ var activeItems = []; // 进行中的任务(每项带 cancel 方法,供「全部取消」调用)
1881
+ var uploadDone = 0; // 已完成(含失败)的数量
1882
+ var uploadFailed = 0; // 失败数量
1883
+ var uploadCanceled = 0; // 用户主动取消的数量
1884
+ var uploadTotal = 0; // 本批次总数
1885
+ var listReloadTimer = null;
1886
+
1887
+ /** 延迟刷新列表,避免每个文件上传完都请求一次 */
1888
+ function scheduleListReload() {
1889
+ if (listReloadTimer) return;
1890
+ listReloadTimer = setTimeout(function () {
1891
+ listReloadTimer = null;
1892
+ refreshAll();
1893
+ }, 600);
1894
+ }
1895
+
1896
+ /**
1897
+ * 等待新文件出现在列表中,然后定位高亮。
1898
+ *
1899
+ * 服务端写入后需要重新扫描目录,列表可能慢一步到达;
1900
+ * 这里反复刷新列表直到新文件出现,再触发一次渲染让高亮生效。
1901
+ * 多个文件同时上传时统一累积到同一队列,避免互相干扰。
1902
+ */
1903
+ function waitForHighlight(names) {
1904
+ names.forEach(function (n) {
1905
+ if (highlightQueue.indexOf(n) < 0) highlightQueue.push(n);
1906
+ });
1907
+ if (highlightTimer) return;
1908
+ highlightTimer = setTimeout(tryHighlight, 250);
1909
+ }
1910
+
1911
+ function tryHighlight() {
1912
+ highlightTimer = null;
1913
+ if (!highlightQueue.length) return;
1914
+ loadFiles().then(function () {
1915
+ var found = highlightQueue.filter(function (n) {
1916
+ return fileItems.some(function (f) { return f.name === n; });
1917
+ });
1918
+ if (!found.length) {
1919
+ // 文件还没出现在列表中,稍后再试
1920
+ highlightTimer = setTimeout(tryHighlight, 300);
1921
+ return;
1922
+ }
1923
+ // 找到后加入待高亮集合,再次渲染让高亮样式生效
1924
+ pendingHighlight = pendingHighlight.concat(found);
1925
+ highlightQueue = highlightQueue.filter(function (n) { return found.indexOf(n) < 0; });
1926
+ loadFiles();
1927
+ });
1928
+ }
1929
+
1930
+ function updateQueueSummary() {
1931
+ var el = $('uploadSummary');
1932
+ if (!el) return;
1933
+ if (!uploadTotal) {
1934
+ el.classList.add('hidden');
1935
+ return;
1936
+ }
1937
+ el.classList.remove('hidden');
1938
+ var pending = uploadQueue.length;
1939
+ var running = uploadActive;
1940
+ el.innerHTML =
1941
+ '<span class="text-slate-400">本批次</span>' +
1942
+ '<span class="text-emerald-400 font-mono">' + (uploadDone + running) + '/' + uploadTotal + '</span>' +
1943
+ '<span class="text-slate-400">已完成</span>' +
1944
+ (running ? '<span class="text-sky-400 font-mono">' + running + '</span><span class="text-slate-400">传输中</span>' : '') +
1945
+ (pending ? '<span class="text-slate-400 font-mono">' + pending + '</span><span class="text-slate-400">排队中</span>' : '') +
1946
+ (uploadCanceled ? '<span class="text-slate-400 font-mono">' + uploadCanceled + '</span><span class="text-slate-400">已取消</span>' : '') +
1947
+ (uploadFailed ? '<span class="text-red-400 font-mono">' + uploadFailed + '</span><span class="text-slate-400">失败</span>' : '') +
1948
+ (running || pending
1949
+ ? '<button data-cancel-all class="ml-auto px-2 py-0.5 rounded border border-red-500/40 text-red-400 hover:bg-red-500/10 transition shrink-0">全部取消</button>'
1950
+ : '');
1951
+ var cancelAll = el.querySelector('[data-cancel-all]');
1952
+ if (cancelAll) cancelAll.addEventListener('click', cancelAllUploads);
1953
+ }
1954
+
1955
+ /** 取消本批次所有还没传完的文件 */
1956
+ function cancelAllUploads() {
1957
+ var pendingCount = uploadQueue.length;
1958
+ uploadQueue.length = 0;
1959
+ uploadTotal = Math.max(0, uploadTotal - pendingCount);
1960
+ var running = activeItems.slice();
1961
+ running.forEach(function (item) {
1962
+ if (item.cancel) item.cancel();
1963
+ });
1964
+ // 没有进行中的任务时不会有回调来收尾,这里手动清空批次状态
1965
+ if (!running.length) {
1966
+ uploadTotal = 0;
1967
+ uploadDone = 0;
1968
+ uploadFailed = 0;
1969
+ uploadCanceled = 0;
1970
+ updateQueueSummary();
1971
+ }
1972
+ toast('已取消未完成的上传');
1973
+ }
1974
+
1975
+ /**
1976
+ * 加入上传队列。
1977
+ *
1978
+ * alreadyResolved 为 true 表示 rel 已经是最终相对路径(重试时用),
1979
+ * 否则按当前「上传到」的目录补上前缀。
1980
+ */
1981
+ function enqueueUpload(file, rel, alreadyResolved) {
1982
+ var name = rel || file.name;
1983
+ if (!alreadyResolved && uploadTargetDir) name = uploadTargetDir + '/' + name;
1984
+ uploadQueue.push({ file: file, rel: name });
1985
+ uploadTotal += 1;
1986
+ updateQueueSummary();
1987
+ }
1988
+
1989
+ /** 从队列中取出下一个文件开始上传 */
1990
+ function pumpQueue() {
1991
+ while (uploadActive < UPLOAD_CONCURRENCY && uploadQueue.length) {
1992
+ var item = uploadQueue.shift();
1993
+ uploadActive += 1;
1994
+ uploadOne(item, 0, function (ok, canceled) {
1995
+ uploadActive -= 1;
1996
+ uploadDone += 1;
1997
+ if (canceled) uploadCanceled += 1;
1998
+ else if (!ok) uploadFailed += 1;
1999
+ updateQueueSummary();
2000
+ if (uploadDone >= uploadTotal) {
2001
+ // 本批次结束
2002
+ uploadQueue = [];
2003
+ uploadTotal = 0;
2004
+ uploadDone = 0;
2005
+ uploadFailed = 0;
2006
+ uploadCanceled = 0;
2007
+ setTimeout(function () {
2008
+ updateQueueSummary();
2009
+ refreshAll();
2010
+ }, 300);
2011
+ } else {
2012
+ pumpQueue();
2013
+ }
2014
+ });
2015
+ }
2016
+ updateQueueSummary();
2017
+ }
2018
+
2019
+ /**
2020
+ * 大文件分片并发上传(支持断点续传)。
2021
+ *
2022
+ * 单条 HTTP 流在弱网下容易成为瓶颈,把文件切片后并发上传可以让多条流同时传输,
2023
+ * 局域网内大文件的速度提升明显。
2024
+ *
2025
+ * 续传:用「文件名:大小:修改时间」作为文件指纹,把拿到的 uploadId 记在
2026
+ * localStorage 里。断线、刷新页面、甚至服务重启之后,带着指纹和 uploadId
2027
+ * 重新 init,服务端会返回已上传的分片,只补传缺的那些。
2028
+ */
2029
+ function uploadByChunks(item, ui) {
2030
+ var file = item.file;
2031
+ var rel = item.rel || file.name;
2032
+ var startTime = Date.now();
2033
+ var uploadId = '';
2034
+ var fileKey = fileKeyOf(rel, file);
2035
+
2036
+ /** 上传单个分片,遇到并发限流时退避重试 */
2037
+ function sendChunk(index, chunkSize) {
2038
+ var start = index * chunkSize;
2039
+ var blob = file.slice(start, Math.min(start + chunkSize, file.size));
2040
+ var fd = new FormData();
2041
+ fd.append('chunk', blob, 'chunk-' + index);
2042
+ var attempt = 0;
2043
+ function once() {
2044
+ return apiFetch(API + '/chunk/upload?uploadId=' + encodeURIComponent(uploadId) + '&index=' + index, { method: 'POST', body: fd })
2045
+ .then(function (r) {
2046
+ if (r.status === 429 && attempt < MAX_RETRY) {
2047
+ attempt += 1;
2048
+ return new Promise(function (resolve) { setTimeout(resolve, 600 * Math.pow(2, attempt - 1)); }).then(once);
2049
+ }
2050
+ return r.json();
2051
+ })
2052
+ .then(function (j) {
2053
+ if (!j || j.code !== 0) throw new Error((j && j.msg) || '分片上传失败');
2054
+ return j;
2055
+ });
2056
+ }
2057
+ return once();
2058
+ }
2059
+
2060
+ apiFetch(API + '/chunk/init', {
2061
+ method: 'POST',
2062
+ headers: { 'Content-Type': 'application/json' },
2063
+ body: JSON.stringify({
2064
+ name: rel,
2065
+ size: file.size,
2066
+ chunkSize: CHUNK_SIZE,
2067
+ fileKey: fileKey,
2068
+ // 上次的任务:服务端会核对名称与大小,匹配才复用
2069
+ uploadId: getUploadId(fileKey) || undefined,
2070
+ }),
2071
+ })
2072
+ .then(function (r) { return r.json(); })
2073
+ .then(function (j) {
2074
+ if (!j || j.code !== 0) throw new Error((j && j.msg) || '初始化分片失败');
2075
+ uploadId = j.data.uploadId;
2076
+ saveUploadId(fileKey, uploadId);
2077
+ var total = j.data.total;
2078
+ var chunkSize = j.data.chunkSize;
2079
+ // 服务端已经收到哪些分片:续传时跳过它们
2080
+ var received = Array.isArray(j.data.received) ? j.data.received : [];
2081
+ var pending = [];
2082
+ for (var k = 0; k < total; k++) {
2083
+ if (received.indexOf(k) < 0) pending.push(k);
2084
+ }
2085
+ var sent = received.length;
2086
+ var stopped = false;
2087
+ var next = 0;
2088
+ var workers = Math.min(CHUNK_CONCURRENCY, Math.max(1, pending.length));
2089
+ var active = workers; // 仍在工作的分片任务数
2090
+
2091
+ /** 分片上传的取消入口:停止派发新分片,并清掉服务端暂存 */
2092
+ item.chunkCancel = function () {
2093
+ if (stopped) return;
2094
+ stopped = true;
2095
+ // 任务即将被清理,指纹记录不再指向有效任务
2096
+ saveUploadId(fileKey, '');
2097
+ if (uploadId) {
2098
+ apiFetch(API + '/chunk/cancel?uploadId=' + encodeURIComponent(uploadId), { method: 'DELETE' }).catch(function () {});
2099
+ }
2100
+ toast('已取消上传:' + rel);
2101
+ ui.finish(false, '已取消', true);
2102
+ };
2103
+
2104
+ /** 刷新百分比、速度与状态文案 */
2105
+ function updateProgress() {
2106
+ var pct = total ? Math.round((sent / total) * 100) : 0;
2107
+ ui.pctEl.textContent = pct + '%';
2108
+ ui.barEl.style.width = pct + '%';
2109
+ var elapsed = (Date.now() - startTime) / 1000;
2110
+ if (elapsed > 0) ui.speedEl.textContent = fmtSize((sent * chunkSize) / elapsed) + '/s';
2111
+ ui.statusEl.textContent = '分片上传中(' + sent + '/' + total + ')';
2112
+ }
2113
+
2114
+ if (sent > 0) {
2115
+ ui.statusEl.textContent = '继续上传(已传 ' + sent + '/' + total + ')';
2116
+ updateProgress();
2117
+ toast('继续上传:' + rel + '(已完成 ' + sent + '/' + total + ' 个分片)', 'ok');
2118
+ } else {
2119
+ ui.statusEl.textContent = '分片上传中(0/' + total + ')';
2120
+ }
2121
+
2122
+ /** 合并分片为正式文件 */
2123
+ function merge() {
2124
+ apiFetch(API + '/chunk/merge?uploadId=' + encodeURIComponent(uploadId), { method: 'POST' })
2125
+ .then(function (r) { return r.json(); })
2126
+ .then(function (mj) {
2127
+ if (!mj || mj.code !== 0) throw new Error((mj && mj.msg) || '分片合并失败');
2128
+ var saved = mj.data && mj.data.name ? mj.data.name : rel;
2129
+ var renamed = saved !== rel;
2130
+ // 任务已消费,指纹记录可以清掉了
2131
+ saveUploadId(fileKey, '');
2132
+ ownUploads[saved] = Date.now();
2133
+ toast(renamed ? '上传完成:' + rel + ' → ' + saved + '(同名已自动改名)' : '上传完成:' + rel, 'ok');
2134
+ waitForHighlight([saved]);
2135
+ ui.finish(true);
2136
+ })
2137
+ .catch(function (err) {
2138
+ ui.finish(false, err.message || '分片合并失败');
2139
+ });
2140
+ }
2141
+
2142
+ function worker() {
2143
+ if (stopped) return;
2144
+ if (next >= pending.length) {
2145
+ // 所有分片都领完了,等最后一个任务结束再合并
2146
+ active -= 1;
2147
+ if (active === 0) merge();
2148
+ return;
2149
+ }
2150
+ var index = pending[next++];
2151
+ sendChunk(index, chunkSize)
2152
+ .then(function () {
2153
+ sent += 1;
2154
+ updateProgress();
2155
+ worker();
2156
+ })
2157
+ .catch(function (err) {
2158
+ stopped = true;
2159
+ ui.statusEl.textContent = '分片上传失败';
2160
+ // 清理服务端暂存的分片,避免残留占用磁盘
2161
+ if (uploadId) {
2162
+ apiFetch(API + '/chunk/cancel?uploadId=' + encodeURIComponent(uploadId), { method: 'DELETE' }).catch(function () {});
2163
+ }
2164
+ toast('上传失败:' + rel, 'err');
2165
+ ui.finish(false, err.message || '分片上传失败');
2166
+ });
2167
+ }
2168
+
2169
+ for (var i = 0; i < workers; i++) worker();
2170
+ })
2171
+ .catch(function (err) {
2172
+ ui.statusEl.textContent = '分片上传失败';
2173
+ toast('上传失败:' + rel, 'err');
2174
+ ui.finish(false, err.message || '分片上传失败');
2175
+ });
2176
+ }
2177
+
2178
+ /**
2179
+ * 传输测速:分别测量上传与下载速度。
2180
+ *
2181
+ * 上传方向把一段数据发给服务端并丢弃,下载方向从服务端拉一段固定数据,
2182
+ * 两者都按实际耗时换算成 MB/s,用来判断当前局域网链路质量。
2183
+ */
2184
+ function runSpeedTest() {
2185
+ var MB = 8;
2186
+ toast('正在测速…');
2187
+ var dlStart = Date.now();
2188
+ apiFetch(API + '/speed?size=' + MB)
2189
+ .then(function (r) {
2190
+ if (!r.ok) throw new Error('HTTP ' + r.status);
2191
+ return r.arrayBuffer();
2192
+ })
2193
+ .then(function (buf) {
2194
+ var dlMs = Math.max(1, Date.now() - dlStart);
2195
+ var dlSpeed = buf.byteLength / 1024 / 1024 / (dlMs / 1000);
2196
+ var blob = new Blob([new Uint8Array(MB * 1024 * 1024)]);
2197
+ var upStart = Date.now();
2198
+ return apiFetch(API + '/speed', { method: 'POST', body: blob })
2199
+ .then(function (r) { return r.json(); })
2200
+ .then(function (j) {
2201
+ var upMs = Math.max(1, Date.now() - upStart);
2202
+ var upSpeed = (j.data && j.data.bytes ? j.data.bytes / 1024 / 1024 : MB) / (upMs / 1000);
2203
+ toast('测速完成:上传 ' + upSpeed.toFixed(1) + ' MB/s · 下载 ' + dlSpeed.toFixed(1) + ' MB/s', 'ok');
2204
+ });
2205
+ })
2206
+ .catch(function () {
2207
+ toast('测速失败,请稍后再试', 'err');
2208
+ });
2209
+ }
2210
+
2211
+ function uploadOne(item, retryCount, onDone) {
2212
+ var file = item.file;
2213
+ var rel = item.rel || file.name;
2214
+ var fd;
2215
+ try {
2216
+ fd = new FormData();
2217
+ // 第三个参数指定 multipart 里的 filename,服务端据此保留目录结构
2218
+ fd.append('files', file, rel);
2219
+ } catch (err) {
2220
+ // 构造请求失败时必须正常收尾,否则队列的活跃计数不会释放,后续上传全部卡住
2221
+ toast('上传失败:' + rel, 'err');
2222
+ onDone(false);
2223
+ return;
2224
+ }
2225
+ var row = document.createElement('div');
2226
+ row.className = 'bg-slate-800/70 border border-slate-700 rounded-xl px-4 py-3';
2227
+ row.innerHTML =
2228
+ '<div class="flex items-center justify-between gap-3 mb-2">' +
2229
+ '<span class="text-xs truncate text-slate-300" title="' + escapeHtml(rel) + '">' + escapeHtml(rel) + '</span>' +
2230
+ '<span class="flex items-center gap-2 shrink-0">' +
2231
+ '<span class="text-xs text-emerald-400 font-mono" data-pct>0%</span>' +
2232
+ '<button type="button" data-cancel class="text-[10px] px-1.5 py-0.5 rounded border border-slate-600 text-slate-400 hover:text-red-400 hover:border-red-500/40 transition">取消</button>' +
2233
+ '</span>' +
2234
+ '</div>' +
2235
+ '<div class="h-1.5 bg-slate-700 rounded-full overflow-hidden">' +
2236
+ '<div class="h-full bg-emerald-500 transition-all duration-200" style="width:0%"></div>' +
2237
+ '</div>' +
2238
+ '<div class="flex justify-between mt-1.5 text-[10px] text-slate-500"><span data-status>等待上传…</span><span data-speed class="font-mono"></span></div>' +
2239
+ // 失败/取消后才出现:重试与关闭
2240
+ '<div class="hidden mt-2 items-center gap-2" data-actions>' +
2241
+ '<button type="button" data-retry class="text-[10px] px-2 py-1 rounded border border-emerald-500/40 text-emerald-400 hover:bg-emerald-500/10 transition">重试</button>' +
2242
+ '<button type="button" data-dismiss class="text-[10px] px-2 py-1 rounded border border-slate-600 text-slate-400 hover:bg-slate-700 transition">关闭</button>' +
2243
+ '</div>';
2244
+ $('uploadList').appendChild(row);
2245
+ var pctEl = row.querySelector('[data-pct]');
2246
+ var barEl = row.querySelector('.h-full');
2247
+ var statusEl = row.querySelector('[data-status]');
2248
+ var speedEl = row.querySelector('[data-speed]');
2249
+ var actionsEl = row.querySelector('[data-actions]');
2250
+ var cancelBtn = row.querySelector('[data-cancel]');
2251
+ var xhr = null;
2252
+ var finished = false;
2253
+ var canceled = false;
2254
+
2255
+ /** 从「进行中」列表摘掉自己(失败重试时会重新加入) */
2256
+ function detach() {
2257
+ item.cancel = null;
2258
+ item.chunkCancel = null;
2259
+ var idx = activeItems.indexOf(item);
2260
+ if (idx >= 0) activeItems.splice(idx, 1);
2261
+ }
2262
+
2263
+ /** 收尾:ok=成功,isCanceled=用户主动取消(不计入失败) */
2264
+ function finish(ok, msg, isCanceled) {
2265
+ if (finished) return;
2266
+ finished = true;
2267
+ detach();
2268
+ if (ok) barEl.style.width = '100%';
2269
+ barEl.className = 'h-full ' + (ok ? 'bg-emerald-500' : isCanceled ? 'bg-slate-500' : 'bg-red-500');
2270
+ statusEl.textContent = ok ? '上传完成' : msg || (isCanceled ? '已取消' : '上传失败');
2271
+ cancelBtn.classList.add('hidden');
2272
+ if (ok) {
2273
+ pctEl.textContent = '100%';
2274
+ setTimeout(function () { row.remove(); }, 1500);
2275
+ } else {
2276
+ // 失败 / 取消的行常驻,用户可重试或手动关闭(以前 6 秒就自动消失,看不到原因)
2277
+ actionsEl.classList.remove('hidden');
2278
+ actionsEl.classList.add('flex');
2279
+ }
2280
+ scheduleListReload();
2281
+ onDone(ok, !!isCanceled);
2282
+ }
2283
+
2284
+ /** 取消这次上传 */
2285
+ function cancelUpload() {
2286
+ if (finished || canceled) return;
2287
+ canceled = true;
2288
+ statusEl.textContent = '已取消';
2289
+ // 分片上传自己负责停止派发并清理服务端暂存
2290
+ if (item.chunkCancel) {
2291
+ item.chunkCancel();
2292
+ return;
2293
+ }
2294
+ try {
2295
+ if (xhr) xhr.abort();
2296
+ } catch (e) {
2297
+ // 忽略取消失败:下面的 finish 仍会收尾
2298
+ }
2299
+ finish(false, '已取消', true);
2300
+ }
2301
+
2302
+ /** 限流/网络错误后的退避重试:保持活跃计数,避免队列重新调度同一任务 */
2303
+ function retryLater(delay, label) {
2304
+ statusEl.textContent = label;
2305
+ barEl.className = 'h-full bg-amber-500';
2306
+ setTimeout(function () {
2307
+ if (canceled) return;
2308
+ // 让本次调用的闭包失效,避免和新的调用重复收尾
2309
+ finished = true;
2310
+ detach();
2311
+ row.remove();
2312
+ uploadOne(item, retryCount + 1, onDone);
2313
+ }, delay);
2314
+ }
2315
+
2316
+ item.cancel = cancelUpload;
2317
+ activeItems.push(item);
2318
+ cancelBtn.addEventListener('click', cancelUpload);
2319
+ row.querySelector('[data-retry]').addEventListener('click', function () {
2320
+ row.remove();
2321
+ // rel 已经是最终路径(含目标目录),重试不要再补前缀
2322
+ enqueueUpload(file, rel, true);
2323
+ pumpQueue();
2324
+ });
2325
+ row.querySelector('[data-dismiss]').addEventListener('click', function () { row.remove(); });
2326
+
2327
+ // 大文件改走分片并发上传,速度更快
2328
+ if (file.size >= CHUNK_THRESHOLD) {
2329
+ uploadByChunks(item, { pctEl: pctEl, barEl: barEl, statusEl: statusEl, speedEl: speedEl, finish: finish });
2330
+ return;
2331
+ }
2332
+ xhr = new XMLHttpRequest();
2333
+ // 目标目录由「上传到」决定;文件名里的子目录(上传文件夹)会拼在它后面
2334
+ var uploadUrl = API + '/upload';
2335
+ if (uploadTargetDir) uploadUrl += '?dir=' + encodeURIComponent(uploadTargetDir);
2336
+ xhr.open('POST', uploadUrl);
2337
+ // 上传需要访客以上权限,会话令牌随请求头带上
2338
+ if (sessionToken) xhr.setRequestHeader('X-Localsend-Session', sessionToken);
2339
+ var lastLoaded = 0;
2340
+ var lastTime = Date.now();
2341
+ xhr.upload.onprogress = function (e) {
2342
+ if (!e.lengthComputable) return;
2343
+ var pct = Math.round(e.loaded / e.total * 100);
2344
+ pctEl.textContent = pct + '%';
2345
+ barEl.style.width = pct + '%';
2346
+ var now = Date.now();
2347
+ var dt = (now - lastTime) / 1000;
2348
+ if (dt > 0.3) {
2349
+ speedEl.textContent = fmtSize((e.loaded - lastLoaded) / dt) + '/s';
2350
+ lastLoaded = e.loaded;
2351
+ lastTime = now;
2352
+ }
2353
+ };
2354
+ xhr.onabort = function () { finish(false, '已取消', true); };
2355
+ xhr.onload = function () {
2356
+ var json = null;
2357
+ try { json = JSON.parse(xhr.responseText); } catch (e) { json = null; }
2358
+ if (xhr.status === 200 && json && json.code === 0) {
2359
+ // 服务端可能在同名时追加 _1 后缀,以返回的实际文件名为准
2360
+ var results = (json.data && json.data.results) || [];
2361
+ var saved = results.length ? results[0].name : rel;
2362
+ var renamed = saved !== rel;
2363
+ // 记录为本机上传,后续变更推送里不再重复提示
2364
+ ownUploads[saved] = Date.now();
2365
+ toast(renamed ? '上传完成:' + rel + ' → ' + saved + '(同名已自动改名)' : '上传完成:' + rel, 'ok');
2366
+ // 等待新文件出现在列表中,然后定位高亮
2367
+ waitForHighlight([saved]);
2368
+ finish(true);
2369
+ return;
2370
+ }
2371
+ var msg = (json && json.msg) || '上传失败';
2372
+ // 429 表示触发了并发/频率限制,退避后重试
2373
+ if (xhr.status === 429 && retryCount < MAX_RETRY) {
2374
+ retryLater(800 * Math.pow(2, retryCount), msg + ',重试中…');
2375
+ return;
2376
+ }
2377
+ toast(msg + ':' + rel, 'err');
2378
+ finish(false, msg);
2379
+ };
2380
+ xhr.onerror = function () {
2381
+ if (retryCount < MAX_RETRY) {
2382
+ retryLater(800 * Math.pow(2, retryCount), '网络错误,重试中…');
2383
+ return;
2384
+ }
2385
+ statusEl.textContent = '网络错误';
2386
+ toast('上传失败:' + rel, 'err');
2387
+ finish(false, '网络错误');
2388
+ };
2389
+ xhr.send(fd);
2390
+ }
2391
+
2392
+ // 下载策略:文件大于 BLOB_LIMIT 时直接交给浏览器原生下载(流式写盘,不占用浏览器内存,
2393
+ // 避免大文件把内存撑爆导致下载失败);小文件用 XHR 读成 blob,以便显示实时进度与速度
2394
+ var BLOB_LIMIT = 50 * 1024 * 1024; // 50MB
2395
+
2396
+ function fileSizeOf(name) {
2397
+ for (var i = 0; i < fileItems.length; i++) {
2398
+ if (fileItems[i].name === name) return fileItems[i].size || 0;
2399
+ }
2400
+ return 0;
2401
+ }
2402
+
2403
+ /** 用隐藏链接触发浏览器下载 */
2404
+ function triggerDownload(url, name) {
2405
+ var a = document.createElement('a');
2406
+ a.href = url;
2407
+ if (name) a.download = name;
2408
+ a.style.display = 'none';
2409
+ document.body.appendChild(a);
2410
+ a.click();
2411
+ setTimeout(function () { a.remove(); }, 0);
2412
+ }
2413
+
2414
+ // 原生下载:由浏览器直接下载 URL,不经过 XHR,内存占用恒定
2415
+ function nativeDownload(name) {
2416
+ downloadUrl(name)
2417
+ .then(function (url) {
2418
+ triggerDownload(url, name);
2419
+ })
2420
+ .catch(function (e) { toast((e && e.message) || '下载失败', 'err'); });
2421
+ }
2422
+
2423
+ // 小文件下载:XHR + blob,可显示进度
2424
+ function xhrDownload(name, onDone) {
2425
+ downloadUrl(name)
2426
+ .then(function (url) {
2427
+ var xhr = new XMLHttpRequest();
2428
+ xhr.open('GET', url);
2429
+ xhr.responseType = 'blob';
2430
+ var lastLoaded = 0;
2431
+ var lastTime = Date.now();
2432
+ xhr.onprogress = function (e) {
2433
+ if (!e.lengthComputable || !e.total) return;
2434
+ var pct = Math.round(e.loaded / e.total * 100);
2435
+ var now = Date.now();
2436
+ var dt = (now - lastTime) / 1000;
2437
+ if (dt > 0.3) {
2438
+ var speed = fmtSize((e.loaded - lastLoaded) / dt) + '/s';
2439
+ lastLoaded = e.loaded;
2440
+ lastTime = now;
2441
+ toast('下载中 ' + name + ' ' + pct + '% · ' + speed);
2442
+ }
2443
+ };
2444
+ xhr.onload = function () {
2445
+ if (xhr.status !== 200) {
2446
+ toast('下载失败:' + name, 'err');
2447
+ if (onDone) onDone(false);
2448
+ return;
2449
+ }
2450
+ var blob = xhr.response;
2451
+ var objectUrl = URL.createObjectURL(blob);
2452
+ triggerDownload(objectUrl, name);
2453
+ setTimeout(function () { URL.revokeObjectURL(objectUrl); }, 5000);
2454
+ toast('下载完成:' + name, 'ok');
2455
+ if (onDone) onDone(true);
2456
+ };
2457
+ xhr.onerror = function () {
2458
+ toast('下载失败:' + name, 'err');
2459
+ if (onDone) onDone(false);
2460
+ };
2461
+ xhr.send();
2462
+ })
2463
+ .catch(function (e) {
2464
+ toast((e && e.message) || '下载失败', 'err');
2465
+ if (onDone) onDone(false);
2466
+ });
2467
+ }
2468
+
2469
+ function downloadFile(name) {
2470
+ var size = fileSizeOf(name);
2471
+ // 支持 File System Access API 时,优先流式写入磁盘:内存恒定且能显示进度
2472
+ if (size > BLOB_LIMIT && canStreamToDisk()) {
2473
+ streamToDisk(name, size);
2474
+ return;
2475
+ }
2476
+ if (size > BLOB_LIMIT) {
2477
+ nativeDownload(name);
2478
+ toast('已转交浏览器下载:' + name + '(' + fmtSize(size) + ')', 'ok');
2479
+ return;
2480
+ }
2481
+ xhrDownload(name);
2482
+ }
2483
+
2484
+ /** 浏览器是否支持 File System Access API */
2485
+ function canStreamToDisk() {
2486
+ return typeof window.showSaveFilePicker === 'function' && window.isSecureContext !== false;
2487
+ }
2488
+
2489
+ /**
2490
+ * 大文件流式下载:让用户选择保存位置,边下边写盘。
2491
+ *
2492
+ * 全程使用 ReadableStream 直写磁盘,不在内存里缓存整个文件,
2493
+ * 因此内存占用恒定;同时可以实时反馈进度与速度。
2494
+ */
2495
+ function streamToDisk(name, size) {
2496
+ var progress = null;
2497
+ try {
2498
+ progress = showProgress('正在下载 ' + name);
2499
+ } catch (e) {
2500
+ progress = null;
2501
+ }
2502
+ var controller = new AbortController();
2503
+ if (progress) progress.cancel = function () { controller.abort(); };
2504
+
2505
+ // 先让用户选择保存位置。
2506
+ // 这里必须在点击事件的同一个调用栈里发起(否则浏览器会判定失去用户手势),
2507
+ // 因此「换票据」放在拿到文件句柄之后再做。
2508
+ var picker = window.showSaveFilePicker({
2509
+ suggestedName: name,
2510
+ // 允许用户选择任意目录,避免默认下载目录被清理
2511
+ id: 'localsend-download',
2512
+ });
2513
+ Promise.resolve(picker)
2514
+ .then(function (handle) {
2515
+ return handle.createWritable().then(function (writer) {
2516
+ return downloadUrl(name).then(function (url) {
2517
+ return fetch(url, { signal: controller.signal }).then(function (res) {
2518
+ if (!res.ok) throw new Error('HTTP ' + res.status);
2519
+ var total = Number(res.headers.get('content-length')) || size || 0;
2520
+ var received = 0;
2521
+ var lastTime = Date.now();
2522
+ var lastLoaded = 0;
2523
+ var reader = res.body.getReader();
2524
+ function pump() {
2525
+ return reader.read().then(function (result) {
2526
+ if (result.done) return writer.close();
2527
+ received += result.value.length;
2528
+ return writer.write(result.value).then(function () {
2529
+ if (progress) {
2530
+ var now = Date.now();
2531
+ var dt = (now - lastTime) / 1000;
2532
+ var speed = dt > 0 ? (received - lastLoaded) / dt : 0;
2533
+ if (dt > 0.3) {
2534
+ lastLoaded = received;
2535
+ lastTime = now;
2536
+ progress.update(received, total, speed);
2537
+ }
2538
+ }
2539
+ return pump();
2540
+ });
2541
+ });
2542
+ }
2543
+ return pump();
2544
+ });
2545
+ });
2546
+ });
2547
+ })
2548
+ .then(function () {
2549
+ if (progress) progress.done('下载完成:' + name, 'ok');
2550
+ })
2551
+ .catch(function (err) {
2552
+ if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
2553
+ if (progress) progress.close();
2554
+ return;
2555
+ }
2556
+ // 直存失败时回退到浏览器原生下载
2557
+ if (progress) progress.close();
2558
+ nativeDownload(name);
2559
+ toast('直存失败,已转为浏览器下载:' + name, 'err');
2560
+ });
2561
+ }
2562
+
2563
+ /**
2564
+ * 显示一个常驻的下载进度浮层,返回控制对象。
2565
+ */
2566
+ function showProgress(title) {
2567
+ var box = document.createElement('div');
2568
+ box.className = 'fixed bottom-6 left-1/2 -translate-x-1/2 z-[70] w-[min(92vw,420px)] bg-slate-900/95 border border-slate-700 rounded-2xl px-4 py-3 shadow-2xl';
2569
+ box.innerHTML =
2570
+ '<div class="flex items-center justify-between gap-3 mb-2">' +
2571
+ '<span class="text-xs text-slate-200 truncate" data-title></span>' +
2572
+ '<button class="text-[11px] text-slate-400 hover:text-red-400 shrink-0" data-cancel>取消</button>' +
2573
+ '</div>' +
2574
+ '<div class="h-1.5 bg-slate-700 rounded-full overflow-hidden">' +
2575
+ '<div class="h-full bg-emerald-500 transition-all duration-200" style="width:0%"></div>' +
2576
+ '</div>' +
2577
+ '<div class="flex justify-between mt-1.5 text-[10px] text-slate-500">' +
2578
+ '<span data-pct>0%</span><span data-speed class="font-mono"></span>' +
2579
+ '</div>';
2580
+ box.querySelector('[data-title]').textContent = title;
2581
+ document.body.appendChild(box);
2582
+ var bar = box.querySelector('.h-full');
2583
+ var pctEl = box.querySelector('[data-pct]');
2584
+ var speedEl = box.querySelector('[data-speed]');
2585
+ var cancelBtn = box.querySelector('[data-cancel]');
2586
+ cancelBtn.addEventListener('click', function () {
2587
+ if (progress.cancel) progress.cancel();
2588
+ progress.close();
2589
+ });
2590
+ return {
2591
+ update: function (received, total, speed) {
2592
+ var pct = total ? Math.round(received / total * 100) : 0;
2593
+ bar.style.width = pct + '%';
2594
+ pctEl.textContent = pct + '% · ' + fmtSize(received) + (total ? ' / ' + fmtSize(total) : '');
2595
+ speedEl.textContent = fmtSize(speed) + '/s';
2596
+ },
2597
+ done: function (msg, type) {
2598
+ bar.style.width = '100%';
2599
+ bar.className = 'h-full bg-emerald-500';
2600
+ progress.close();
2601
+ toast(msg, type);
2602
+ },
2603
+ close: function () { box.remove(); },
2604
+ };
2605
+ }
2606
+
2607
+ /**
2608
+ * 批量下载:把选中的文件打包成 zip 下载。
2609
+ *
2610
+ * 打包在服务端流式完成,浏览器只接收一个 zip 流,内存占用恒定,
2611
+ * 不会因为文件多或文件大而失败。
2612
+ */
2613
+ function downloadZip(names) {
2614
+ var stamp = new Date();
2615
+ var p = function (x) { return String(x).padStart(2, '0'); };
2616
+ var fname = 'localsend-' + stamp.getFullYear() + p(stamp.getMonth() + 1) + p(stamp.getDate()) + '-' + p(stamp.getHours()) + p(stamp.getMinutes()) + '.zip';
2617
+ ticketUrl('zip', names, '/zip?names=' + encodeURIComponent(names.join(',')))
2618
+ .then(function (url) {
2619
+ triggerDownload(url, fname);
2620
+ toast('正在打包下载 ' + names.length + ' 个文件…', 'ok');
2621
+ })
2622
+ .catch(function (e) { toast((e && e.message) || '打包下载失败', 'err'); });
2623
+ }
2624
+
2625
+ var imgExts = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif', 'heic'];
2626
+ var textExts = ['txt', 'md', 'json', 'js', 'ts', 'html', 'css', 'xml', 'log', 'csv', 'yml', 'yaml', 'ini', 'conf', 'sh', 'py', 'java', 'c', 'cpp', 'go', 'rs'];
2627
+ var videoExts = ['mp4', 'webm', 'mov', 'mkv', 'avi', 'm4v'];
2628
+ var audioExts = ['mp3', 'wav', 'flac', 'm4a', 'ogg', 'aac'];
2629
+ /** 文本预览的最大字符数,超过则截断 */
2630
+ var TEXT_PREVIEW_LIMIT = 200000;
2631
+ /** 内联预览的文件大小上限(字节),超过则改为新窗口打开 */
2632
+ var INLINE_PREVIEW_MAX = 100 * 1024 * 1024;
2633
+
2634
+ /**
2635
+ * 预览文件。
2636
+ *
2637
+ * 图片、PDF、音视频直接在弹窗内联播放,文本以内联方式展示,
2638
+ * 其它类型回退为新窗口打开。
2639
+ */
2640
+ function previewFile(name) {
2641
+ var ext = (name.split('.').pop() || '').toLowerCase();
2642
+ var size = fileSizeOf(name);
2643
+
2644
+ previewUrl(name)
2645
+ .then(function (url) {
2646
+ // 超出内联预览上限时直接新窗口打开,避免浏览器卡死
2647
+ if (size > INLINE_PREVIEW_MAX) {
2648
+ window.open(url, '_blank');
2649
+ toast('文件较大(' + fmtSize(size) + '),已在新窗口打开', 'ok');
2650
+ return;
2651
+ }
2652
+
2653
+ if (imgExts.indexOf(ext) >= 0) {
2654
+ showMediaPreview(name, url, '<img src="' + url + '" alt="' + escapeHtml(name) + '" class="max-w-full max-h-[65vh] mx-auto rounded-lg" />');
2655
+ return;
2656
+ }
2657
+ if (ext === 'pdf') {
2658
+ showMediaPreview(name, url, '<iframe src="' + url + '" class="w-full h-[65vh] rounded-lg border border-slate-800 bg-slate-950"></iframe>');
2659
+ return;
2660
+ }
2661
+ if (videoExts.indexOf(ext) >= 0) {
2662
+ showMediaPreview(name, url, '<video src="' + url + '" controls class="max-w-full max-h-[65vh] mx-auto rounded-lg bg-slate-950"></video>');
2663
+ return;
2664
+ }
2665
+ if (audioExts.indexOf(ext) >= 0) {
2666
+ showMediaPreview(name, url, '<audio src="' + url + '" controls class="w-full"></audio>');
2667
+ return;
2668
+ }
2669
+ if (textExts.indexOf(ext) >= 0) {
2670
+ fetch(url)
2671
+ .then(function (r) { return r.text(); })
2672
+ .then(function (t) {
2673
+ $('previewModal').classList.remove('hidden');
2674
+ $('previewTitle').textContent = name;
2675
+ $('previewOpen').href = url;
2676
+ $('previewBody').classList.add('hidden');
2677
+ $('previewBody').innerHTML = '';
2678
+ var pre = $('previewContent');
2679
+ pre.classList.remove('hidden');
2680
+ var truncated = t.length > TEXT_PREVIEW_LIMIT;
2681
+ pre.textContent = truncated ? t.slice(0, TEXT_PREVIEW_LIMIT) + '\n\n... (内容过长已截断,共 ' + t.length + ' 字符)' : t;
2682
+ // 复制的是完整内容,截断只影响展示
2683
+ setPreviewCopy(t);
2684
+ })
2685
+ .catch(function () { toast('预览失败', 'err'); });
2686
+ return;
2687
+ }
2688
+ // 其它类型:尝试在弹窗内联,不行就新窗口打开
2689
+ window.open(url, '_blank');
2690
+ })
2691
+ .catch(function (e) { toast((e && e.message) || '预览失败', 'err'); });
2692
+ }
2693
+
2694
+ /** 当前预览的文本内容,供「复制内容」按钮使用 */
2695
+ var previewText = '';
2696
+
2697
+ /**
2698
+ * 设置预览弹窗里的复制按钮。
2699
+ *
2700
+ * 只有文本预览才有内容可复制,图片 / PDF / 音视频预览时传入空串隐藏按钮。
2701
+ */
2702
+ function setPreviewCopy(text) {
2703
+ previewText = text || '';
2704
+ var btn = $('previewCopy');
2705
+ if (!btn) return;
2706
+ if (previewText) btn.classList.remove('hidden');
2707
+ else btn.classList.add('hidden');
2708
+ }
2709
+
2710
+ /** 以媒体方式展示预览内容 */
2711
+ function showMediaPreview(name, url, html) {
2712
+ $('previewModal').classList.remove('hidden');
2713
+ $('previewTitle').textContent = name;
2714
+ $('previewOpen').href = url;
2715
+ $('previewContent').classList.add('hidden');
2716
+ $('previewContent').textContent = '';
2717
+ setPreviewCopy('');
2718
+ var body = $('previewBody');
2719
+ body.classList.remove('hidden');
2720
+ body.innerHTML = html;
2721
+ }
2722
+
2723
+ /**
2724
+ * 创建一个分享链接(带时效,拿到链接的人无需登录即可访问)。
2725
+ *
2726
+ * 列表里的「复制」「扫码」都走这里。
2727
+ * 直接复制下载直链会把访问凭据一起带出去(以前还会带上会话令牌),
2728
+ * 分享链接才是「发给别人」的正确方式:可撤销、会过期、不影响自己的登录状态。
2729
+ */
2730
+ function createShare(names) {
2731
+ return apiFetch(API + '/share', {
2732
+ method: 'POST',
2733
+ headers: { 'Content-Type': 'application/json' },
2734
+ body: JSON.stringify({ names: names }),
2735
+ })
2736
+ .then(function (r) { return r.json(); })
2737
+ .then(function (json) {
2738
+ if (json.code !== 0) throw new Error(json.msg || '分享失败');
2739
+ refreshShareCount();
2740
+ return { url: location.origin + json.data.url, names: json.data.names, expiresAt: json.data.expiresAt };
2741
+ });
2742
+ }
2743
+
2744
+ /** 生成分享链接并复制到剪贴板 */
2745
+ function shareFiles(names, label) {
2746
+ if (!names || !names.length) return Promise.resolve();
2747
+ return createShare(names)
2748
+ .then(function (share) {
2749
+ copyText(share.url);
2750
+ var tip = label || (share.names.length > 1 ? share.names.length + ' 个文件' : share.names[0]);
2751
+ toast('分享链接已复制(' + tip + ',24 小时内有效)', 'ok');
2752
+ })
2753
+ .catch(function (e) { toast((e && e.message) || '分享失败', 'err'); });
2754
+ }
2755
+
2756
+ /** 生成分享链接并以二维码展示(手机扫码直接打开) */
2757
+ function shareQr(names) {
2758
+ if (!names || !names.length) return Promise.resolve();
2759
+ return createShare(names)
2760
+ .then(function (share) { showQr(share.url, '扫码打开分享:' + share.names.join('、')); })
2761
+ .catch(function (e) { toast((e && e.message) || '分享失败', 'err'); });
2762
+ }
2763
+
2764
+ // ---------------------------------------------------------------------------
2765
+ // 剪贴板分享
2766
+ //
2767
+ // 分享原本只能分享「已经存在于存储目录里的文件」,
2768
+ // 想分享一段文字或一张截图得先手动存成文件。
2769
+ // 这里把剪贴板内容直接落盘成普通文件,再复用现成的分享接口生成链接。
2770
+ // ---------------------------------------------------------------------------
2771
+
2772
+ /** 打开文本分享弹窗(可带初始文本) */
2773
+ function openTextModal(text) {
2774
+ $('textInput').value = text || '';
2775
+ // 与上传保持一致的落点:当前视图所在目录
2776
+ $('pasteDir').value = uploadTargetDir;
2777
+ $('textModal').classList.remove('hidden');
2778
+ setTimeout(function () { $('textInput').focus(); }, 60);
2779
+ }
2780
+
2781
+ /** 关闭文本分享弹窗 */
2782
+ function closeTextModal() {
2783
+ $('textModal').classList.add('hidden');
2784
+ }
2785
+
2786
+ /**
2787
+ * 把剪贴板内容落盘。
2788
+ *
2789
+ * kind 为 text 时 content 是文本本身,为 image 时是图片的 data URL。
2790
+ */
2791
+ function pasteToFile(payload, label) {
2792
+ // 自己粘贴的内容不再触发「收到新文件」提示
2793
+ suppressNotifyUntil = Date.now() + 2000;
2794
+ apiFetch(API + '/paste', {
2795
+ method: 'POST',
2796
+ headers: { 'Content-Type': 'application/json' },
2797
+ body: JSON.stringify(payload),
2798
+ })
2799
+ .then(function (r) { return r.json(); })
2800
+ .then(function (json) {
2801
+ if (json.code !== 0) { toast(json.msg || '保存失败', 'err'); return; }
2802
+ // 落盘后立刻生成分享链接,省去再选一次文件
2803
+ var tip = label ? label + '(' + json.data.name + ')' : json.data.name;
2804
+ if (json.data.reused) tip = '内容相同,已复用「' + json.data.name + '」';
2805
+ shareFiles([json.data.name], tip);
2806
+ })
2807
+ .catch(function () { toast('保存失败', 'err'); });
2808
+ }
2809
+
2810
+ /** 分享剪贴板里的图片(截图) */
2811
+ function shareClipboardImage(file) {
2812
+ if (!file) return;
2813
+ var reader = new FileReader();
2814
+ reader.onload = function () {
2815
+ var dataUrl = String(reader.result || '');
2816
+ if (!dataUrl) { toast('图片读取失败', 'err'); return; }
2817
+ pasteToFile({ kind: 'image', content: dataUrl }, '截图');
2818
+ };
2819
+ reader.onerror = function () { toast('图片读取失败', 'err'); };
2820
+ reader.readAsDataURL(file);
2821
+ }
2822
+
2823
+ /** 从系统剪贴板读取内容(需要安全上下文与用户授权) */
2824
+ function readClipboard() {
2825
+ if (!navigator.clipboard || !navigator.clipboard.read) {
2826
+ toast('当前环境无法直接读取剪贴板,请改用 Ctrl+V 粘贴', 'err');
2827
+ return;
2828
+ }
2829
+ navigator.clipboard.read()
2830
+ .then(function (items) {
2831
+ // 优先取剪贴板里的图片
2832
+ for (var i = 0; i < items.length; i++) {
2833
+ if (items[i].types.indexOf('image/png') >= 0) {
2834
+ return items[i].getType('image/png').then(function (blob) {
2835
+ shareClipboardImage(blob);
2836
+ });
2837
+ }
2838
+ }
2839
+ if (navigator.clipboard.readText) {
2840
+ return navigator.clipboard.readText().then(function (text) {
2841
+ if (text && text.trim()) openTextModal(text);
2842
+ else toast('剪贴板是空的', 'err');
2843
+ });
2844
+ }
2845
+ return null;
2846
+ })
2847
+ .catch(function () { toast('无法读取剪贴板,请改用 Ctrl+V 粘贴', 'err'); });
2848
+ }
2849
+
2850
+ /** 提交文本分享 */
2851
+ function submitTextShare() {
2852
+ var content = $('textInput').value;
2853
+ if (!content || !content.trim()) {
2854
+ toast('请输入要分享的内容', 'err');
2855
+ return;
2856
+ }
2857
+ var strategy = $('pasteStrategy').value;
2858
+ var payload = { kind: 'text', content: content, strategy: strategy };
2859
+ if (strategy === 'custom') {
2860
+ var name = $('pasteName').value.trim();
2861
+ if (!name) {
2862
+ toast('请填写自定义文件名', 'err');
2863
+ return;
2864
+ }
2865
+ payload.name = name;
2866
+ }
2867
+ var dir = $('pasteDir').value.trim();
2868
+ if (dir) payload.dir = dir;
2869
+ closeTextModal();
2870
+ pasteToFile(payload, '文本');
2871
+ }
2872
+
2873
+ // ---------------------------------------------------------------------------
2874
+ // 分享管理
2875
+ //
2876
+ // 分享链接一旦发出去就很难收回,之前只能创建不能管理,
2877
+ // 这里把已创建的链接列出来,支持复制、看二维码与撤销。
2878
+ // ---------------------------------------------------------------------------
2879
+
2880
+ /** 刷新分享数量角标 */
2881
+ function refreshShareCount() {
2882
+ apiFetch(API + '/share')
2883
+ .then(function (r) { return r.json(); })
2884
+ .then(function (json) {
2885
+ if (json.code !== 0) return;
2886
+ var list = json.data || [];
2887
+ $('shareCount').textContent = list.length;
2888
+ $('shareCount').classList.toggle('hidden', list.length === 0);
2889
+ })
2890
+ .catch(function () { /* 角标失败不影响主流程 */ });
2891
+ }
2892
+
2893
+ /** 打开分享管理弹窗 */
2894
+ function openShareModal() {
2895
+ $('shareModal').classList.remove('hidden');
2896
+ loadShareList();
2897
+ }
2898
+
2899
+ /** 拉取并渲染分享列表 */
2900
+ function loadShareList() {
2901
+ apiFetch(API + '/share')
2902
+ .then(function (r) { return r.json(); })
2903
+ .then(function (json) {
2904
+ if (json.code !== 0) { toast(json.msg || '加载失败', 'err'); return; }
2905
+ var list = json.data || [];
2906
+ var wrap = $('shareList');
2907
+ wrap.innerHTML = '';
2908
+ if (!list.length) {
2909
+ wrap.innerHTML = '<div class="px-3 py-8 text-center text-xs text-slate-500">还没有分享链接</div>';
2910
+ return;
2911
+ }
2912
+ list.forEach(function (item) {
2913
+ var url = location.origin + item.url;
2914
+ var left = Math.max(0, Math.round((item.expiresAt - Date.now()) / 60000));
2915
+ var expireText = left > 60 ? Math.round(left / 60) + ' 小时后' : left + ' 分钟后';
2916
+ var row = document.createElement('div');
2917
+ row.className = 'px-3 py-2 flex items-center gap-2 flex-wrap';
2918
+ row.innerHTML =
2919
+ '<div class="min-w-0 flex-1">' +
2920
+ '<div class="text-xs text-slate-200 truncate" title="' + escapeHtml(item.names.join('、')) + '">' + escapeHtml(item.names.join('、')) + '</div>' +
2921
+ '<div class="text-[11px] text-slate-500 mt-0.5">' + expireText + '失效 · 已访问 ' + item.hits + ' 次</div>' +
2922
+ '</div>' +
2923
+ '<div class="flex items-center gap-1 shrink-0">' +
2924
+ '<button data-act="copy" class="px-2 py-1 rounded text-[11px] text-emerald-400 hover:bg-emerald-500/10 border border-emerald-500/30 transition">复制</button>' +
2925
+ '<button data-act="qr" class="px-2 py-1 rounded text-[11px] text-slate-300 hover:bg-slate-700 border border-slate-600/60 transition">二维码</button>' +
2926
+ // 撤销分享属于危险操作,只有管理员可用
2927
+ (isAdmin() ? '<button data-act="revoke" class="px-2 py-1 rounded text-[11px] text-red-400 hover:bg-red-500/10 border border-red-500/30 transition">撤销</button>' : '') +
2928
+ '</div>';
2929
+ row.dataset.token = item.token;
2930
+ row.dataset.url = url;
2931
+ wrap.appendChild(row);
2932
+ });
2933
+ })
2934
+ .catch(function () { toast('加载分享列表失败', 'err'); });
2935
+ }
2936
+
2937
+ /** 撤销一个分享链接 */
2938
+ function revokeShare(token) {
2939
+ apiFetch(API + '/share/' + encodeURIComponent(token), { method: 'DELETE' })
2940
+ .then(function (r) { return r.json(); })
2941
+ .then(function (json) {
2942
+ if (json.code !== 0) { toast(json.msg || '撤销失败', 'err'); return; }
2943
+ toast('分享链接已撤销', 'ok');
2944
+ loadShareList();
2945
+ refreshShareCount();
2946
+ })
2947
+ .catch(function () { toast('撤销失败', 'err'); });
2948
+ }
2949
+
2950
+ function showQr(text, label) {
2951
+ $('qrModal').classList.remove('hidden');
2952
+ $('modalText').textContent = label || text;
2953
+ if (modalQrCode) {
2954
+ modalQrCode.update({ data: text });
2955
+ } else {
2956
+ $('modalQr').innerHTML = '';
2957
+ modalQrCode = new QRCodeStyling({
2958
+ width: 240, height: 240, type: 'canvas', data: text, margin: 0,
2959
+ dotsOptions: { type: 'rounded', color: '#10b981' },
2960
+ backgroundOptions: { color: '#ffffff' },
2961
+ cornersSquareOptions: { type: 'extra-rounded', color: '#10b981' },
2962
+ cornersDotOptions: { type: 'dot', color: '#10b981' },
2963
+ });
2964
+ modalQrCode.append($('modalQr'));
2965
+ }
2966
+ }
2967
+ /**
2968
+ * 浏览器是否支持系统分享。
2969
+ *
2970
+ * Web Share API 只在安全上下文(HTTPS 或 localhost)可用,
2971
+ * 局域网通过 IP + HTTP 访问时通常不可用,此时不显示按钮。
2972
+ */
2973
+ function canSystemShare() {
2974
+ if (typeof navigator.share !== 'function') return false;
2975
+ if (window.isSecureContext === false) return false;
2976
+ // 通过 IP 访问的局域网场景多半不是安全上下文
2977
+ var host = location.hostname;
2978
+ var isLocal = host === 'localhost' || host === '127.0.0.1' || host === '[::1]' || host === '::1';
2979
+ return isLocal || window.isSecureContext === true;
2980
+ }
2981
+
2982
+ /**
2983
+ * 调用系统分享(Web Share API)。
2984
+ *
2985
+ * 手机端可以把文件直接发到微信、AirDrop 等系统应用,
2986
+ * 比复制链接更顺手。浏览器不支持时回退为生成分享链接。
2987
+ */
2988
+ function systemShare(name) {
2989
+ if (typeof navigator.share !== 'function') {
2990
+ shareFiles([name]);
2991
+ return;
2992
+ }
2993
+ downloadUrl(name)
2994
+ .then(function (url) {
2995
+ // 能拿到文件本体时一并分享文件本身(移动端体验最好)
2996
+ return fetch(url)
2997
+ .then(function (r) {
2998
+ if (!r.ok) throw new Error('HTTP ' + r.status);
2999
+ return r.blob();
3000
+ })
3001
+ .then(function (blob) {
3002
+ var file = new File([blob], name, { type: blob.type || 'application/octet-stream' });
3003
+ return navigator.share({ files: [file], title: name, text: name });
3004
+ })
3005
+ .catch(function (err) {
3006
+ // 用户取消分享不算错误;其它错误回退为分享链接
3007
+ if (err && err.name === 'AbortError') return undefined;
3008
+ return createShare([name]).then(function (share) {
3009
+ return navigator.share({ title: name, text: name + '\n' + share.url }).catch(function () {});
3010
+ });
3011
+ });
3012
+ })
3013
+ .catch(function (e) { toast((e && e.message) || '系统分享失败', 'err'); });
3014
+ }
3015
+
3016
+ /** 当前操作菜单指向的文件 */
3017
+ var fileMenuTarget = '';
3018
+
3019
+ /**
3020
+ * 打开移动端操作菜单。
3021
+ *
3022
+ * 手机上每行挤 6-9 个图标既难点也难认,这里只保留「预览 / 下载」,
3023
+ * 其余动作收进底部菜单,按当前身份决定能出现哪些。
3024
+ */
3025
+ function openFileMenu(name) {
3026
+ fileMenuTarget = name;
3027
+ $('fileMenuTitle').textContent = name;
3028
+ var actions = [
3029
+ { act: 'preview', label: '预览', icon: '👁' },
3030
+ { act: 'download', label: '下载', icon: '⬇️' },
3031
+ ];
3032
+ if (canWrite()) {
3033
+ actions.push({ act: 'share', label: '复制分享链接', icon: '🔗' });
3034
+ actions.push({ act: 'qr', label: '扫码分享', icon: '📱' });
3035
+ }
3036
+ if (canSystemShare()) actions.push({ act: 'syshare', label: '系统分享', icon: '📤' });
3037
+ if (isAdmin()) {
3038
+ actions.push({ act: 'rename', label: '重命名', icon: '✏️' });
3039
+ actions.push({ act: 'move', label: '移动到目录', icon: '📂' });
3040
+ actions.push({ act: 'delete', label: '删除', icon: '🗑', danger: true });
3041
+ }
3042
+ $('fileMenuList').innerHTML = actions
3043
+ .map(function (a) {
3044
+ var cls = a.danger ? 'border-red-500/30 text-red-400' : 'border-slate-700 text-slate-200';
3045
+ return (
3046
+ '<button type="button" data-act="' +
3047
+ a.act +
3048
+ '" class="flex items-center gap-2 px-3 py-3 rounded-xl bg-slate-800/70 border ' +
3049
+ cls +
3050
+ ' text-sm">' +
3051
+ '<span aria-hidden="true">' +
3052
+ a.icon +
3053
+ '</span><span>' +
3054
+ a.label +
3055
+ '</span></button>'
3056
+ );
3057
+ })
3058
+ .join('');
3059
+ $('fileMenu').classList.remove('hidden');
3060
+ $('fileMenu').classList.add('flex');
3061
+ }
3062
+
3063
+ /** 关闭移动端操作菜单 */
3064
+ function closeFileMenu() {
3065
+ $('fileMenu').classList.add('hidden');
3066
+ $('fileMenu').classList.remove('flex');
3067
+ fileMenuTarget = '';
3068
+ }
3069
+
3070
+ /** 执行一个文件操作(行内按钮与移动端菜单共用同一套实现) */
3071
+ function runFileAction(act, name) {
3072
+ if (!name) return;
3073
+ if (act === 'download') downloadFile(name);
3074
+ else if (act === 'preview') previewFile(name);
3075
+ else if (act === 'share') shareFiles([name]);
3076
+ else if (act === 'syshare') systemShare(name);
3077
+ else if (act === 'qr') shareQr([name]);
3078
+ else if (act === 'rename') openRenameDialog(name);
3079
+ else if (act === 'move') openMoveDialog([name]);
3080
+ else if (act === 'delete') deleteFile(name);
3081
+ else if (act === 'more') openFileMenu(name);
3082
+ }
3083
+
3084
+ function deleteFile(name) {
3085
+ if (!window.confirm('确定删除文件:' + name + ' ?(删除后可在回收站还原)')) return;
3086
+ apiFetch(API + '/delete/' + encodeURIComponent(name), { method: 'DELETE' })
3087
+ .then(function (r) { return r.json(); })
3088
+ .then(function (json) {
3089
+ if (json.code !== 0) { toast(json.msg || '删除失败', 'err'); return; }
3090
+ // 文件已不存在,从选中列表里移除,避免后续批量操作报错
3091
+ delete selected[name];
3092
+ refreshAll();
3093
+ refreshTrashCount();
3094
+ // 提供撤销入口,误删可立即还原
3095
+ var entryId = json.data && json.data.id;
3096
+ if (entryId) {
3097
+ toast('已删除:' + name, 'ok', {
3098
+ label: '撤销',
3099
+ onClick: function () {
3100
+ restoreTrashEntry(entryId, function (ok, msg) {
3101
+ if (ok) toast('已还原:' + msg, 'ok');
3102
+ else toast(msg || '还原失败', 'err');
3103
+ });
3104
+ },
3105
+ });
3106
+ } else {
3107
+ toast('已删除:' + name, 'ok');
3108
+ }
3109
+ })
3110
+ .catch(function () { toast('删除失败', 'err'); });
3111
+ }
3112
+
3113
+ /** 还原回收站中的某个条目 */
3114
+ function restoreTrashEntry(id, cb) {
3115
+ apiFetch(API + '/trash/' + encodeURIComponent(id) + '/restore', { method: 'POST' })
3116
+ .then(function (r) { return r.json(); })
3117
+ .then(function (json) {
3118
+ if (json.code !== 0) { if (cb) cb(false, json.msg || '还原失败'); return; }
3119
+ refreshAll();
3120
+ refreshTrashCount();
3121
+ if (cb) cb(true, json.data.name);
3122
+ })
3123
+ .catch(function () { if (cb) cb(false, '还原失败'); });
3124
+ }
3125
+
3126
+ /** 刷新回收站条目数量 */
3127
+ function refreshTrashCount() {
3128
+ apiFetch(API + '/trash')
3129
+ .then(function (r) { return r.json(); })
3130
+ .then(function (json) {
3131
+ var n = (json.data || []).length;
3132
+ var el = $('trashCount');
3133
+ if (n > 0) {
3134
+ el.textContent = n;
3135
+ el.classList.remove('hidden');
3136
+ } else {
3137
+ el.classList.add('hidden');
3138
+ }
3139
+ })
3140
+ .catch(function () { /* 忽略计数刷新失败 */ });
3141
+ }
3142
+
3143
+ /** 打开回收站面板 */
3144
+ function openTrash() {
3145
+ $('trashModal').classList.remove('hidden');
3146
+ loadTrashList();
3147
+ }
3148
+
3149
+ function loadTrashList() {
3150
+ var wrap = $('trashList');
3151
+ wrap.innerHTML = '<div class="text-xs text-slate-500 p-4 text-center">加载中…</div>';
3152
+ apiFetch(API + '/trash')
3153
+ .then(function (r) { return r.json(); })
3154
+ .then(function (json) {
3155
+ var list = json.data || [];
3156
+ $('trashModalCount').textContent = '(' + list.length + ')';
3157
+ wrap.innerHTML = '';
3158
+ if (!list.length) {
3159
+ wrap.innerHTML = '<div class="text-xs text-slate-500 p-6 text-center">回收站是空的</div>';
3160
+ return;
3161
+ }
3162
+ list.forEach(function (item) {
3163
+ var div = document.createElement('div');
3164
+ div.className = 'flex items-center gap-3 px-3 py-2.5';
3165
+ div.innerHTML =
3166
+ '<span class="text-lg shrink-0">🗑</span>' +
3167
+ '<div class="min-w-0 flex-1">' +
3168
+ '<div class="text-xs truncate text-slate-200" title="' + escapeHtml(item.name) + '">' + escapeHtml(item.name) + '</div>' +
3169
+ '<div class="text-[10px] text-slate-500 mt-0.5">' + fmtSize(item.size || 0) + ' · 删除于 ' + fmtTime(item.deletedAt) + '</div>' +
3170
+ '</div>' +
3171
+ '<div class="flex items-center gap-1 shrink-0">' +
3172
+ // 还原与彻底删除属于危险操作,只有管理员可用
3173
+ (isAdmin()
3174
+ ? '<button data-act="restore" class="px-2 py-1 rounded text-xs text-emerald-400 hover:bg-emerald-500/10 border border-emerald-500/30 transition shrink-0">还原</button>' +
3175
+ '<button data-act="purge" class="px-2 py-1 rounded text-xs text-red-400 hover:bg-red-500/10 border border-red-500/30 transition shrink-0">彻底删除</button>'
3176
+ : '<span class="text-[11px] text-slate-500">只读</span>') +
3177
+ '</div>';
3178
+ var restoreBtn = div.querySelector('[data-act="restore"]');
3179
+ var purgeBtn = div.querySelector('[data-act="purge"]');
3180
+ if (restoreBtn) restoreBtn.addEventListener('click', function () {
3181
+ restoreTrashEntry(item.id, function (ok, msg) {
3182
+ if (ok) { toast('已还原:' + msg, 'ok'); loadTrashList(); }
3183
+ else toast(msg || '还原失败', 'err');
3184
+ });
3185
+ });
3186
+ if (purgeBtn) purgeBtn.addEventListener('click', function () {
3187
+ apiFetch(API + '/trash/' + encodeURIComponent(item.id), { method: 'DELETE' })
3188
+ .then(function (r) { return r.json(); })
3189
+ .then(function (j) {
3190
+ if (j.code !== 0) { toast(j.msg || '删除失败', 'err'); return; }
3191
+ toast('已彻底删除:' + item.name, 'ok');
3192
+ loadTrashList();
3193
+ refreshTrashCount();
3194
+ })
3195
+ .catch(function () { toast('删除失败', 'err'); });
3196
+ });
3197
+ wrap.appendChild(div);
3198
+ });
3199
+ })
3200
+ .catch(function () {
3201
+ wrap.innerHTML = '<div class="text-xs text-red-400 p-4 text-center">回收站加载失败</div>';
3202
+ });
3203
+ }
3204
+
3205
+ // 事件绑定
3206
+ $('dropZone').addEventListener('click', function () { $('fileInput').click(); });
3207
+ // 移动端悬浮上传按钮
3208
+ $('fabUpload').addEventListener('click', function () { $('fileInput').click(); });
3209
+ $('dropZone').addEventListener('dragover', function (e) { e.preventDefault(); $('dropZone').classList.add('border-emerald-400'); });
3210
+ $('dropZone').addEventListener('dragleave', function () { $('dropZone').classList.remove('border-emerald-400'); });
3211
+ $('dropZone').addEventListener('drop', function (e) {
3212
+ e.preventDefault();
3213
+ $('dropZone').classList.remove('border-emerald-400');
3214
+ var dt = e.dataTransfer;
3215
+ if (!dt) return;
3216
+ // 拖入文件夹时浏览器只给出目录条目,需要递归展开后再上传
3217
+ var entries = [];
3218
+ if (dt.items) {
3219
+ Array.prototype.forEach.call(dt.items, function (it) {
3220
+ if (it.webkitGetAsEntry) {
3221
+ var en = it.webkitGetAsEntry();
3222
+ if (en) entries.push(en);
3223
+ }
3224
+ });
3225
+ }
3226
+ var hasDir = entries.some(function (en) { return en.isDirectory; });
3227
+ if (hasDir) {
3228
+ Promise.all(entries.map(function (en) { return readEntry(en, ''); })).then(function (parts) {
3229
+ var list = [];
3230
+ parts.forEach(function (arr) { list = list.concat(arr); });
3231
+ if (!list.length) {
3232
+ toast('拖入的文件夹里没有文件', 'err');
3233
+ return;
3234
+ }
3235
+ list.forEach(function (it) { enqueueUpload(it.file, it.rel); });
3236
+ pumpQueue();
3237
+ toast('正在上传文件夹,共 ' + list.length + ' 个文件');
3238
+ });
3239
+ return;
3240
+ }
3241
+ if (dt.files && dt.files.length) uploadFiles(dt.files);
3242
+ });
3243
+ $('fileInput').addEventListener('change', function (e) { uploadFiles(e.target.files); e.target.value = ''; });
3244
+ // 上传文件夹:保留原有目录结构
3245
+ $('pickDirBtn').addEventListener('click', function () { $('dirInput').click(); });
3246
+ // 监听本地目录,新增文件自动上传
3247
+ $('watchDirBtn').addEventListener('click', startWatchDir);
3248
+ $('dirInput').addEventListener('change', function (e) {
3249
+ var files = e.target.files;
3250
+ if (files && files.length) {
3251
+ uploadFiles(files);
3252
+ toast('正在上传文件夹,共 ' + files.length + ' 个文件');
3253
+ }
3254
+ e.target.value = '';
3255
+ });
3256
+ // 传输测速
3257
+ $('speedBtn').addEventListener('click', runSpeedTest);
3258
+ // 收件箱:只看最近收到的文件
3259
+ $('inboxBtn').addEventListener('click', function () { inboxMode = !inboxMode;
3260
+ if (inboxMode) {
3261
+ inboxNewCount = 0;
3262
+ // 开启收件箱时顺带申请通知权限(用户主动点击,符合浏览器的授权要求)
3263
+ if ('Notification' in window && Notification.permission === 'default') {
3264
+ Notification.requestPermission().catch(function () {});
3265
+ }
3266
+ }
3267
+ currentPage = 1;
3268
+ updateInboxBadge();
3269
+ loadFiles();
3270
+ toast(inboxMode ? '已切换到收件箱(只看最近 ' + Math.round(INBOX_WINDOW / 60000) + ' 分钟收到的文件)' : '已退出收件箱');
3271
+ });
3272
+ // 按目录筛选(同时把上传目标切到该目录)
3273
+ $('dirSelect').addEventListener('change', function (e) {
3274
+ setDirFilter(e.target.value);
3275
+ loadFiles();
3276
+ });
3277
+ // 手动指定上传目标目录
3278
+ $('uploadDirSelect').addEventListener('change', function (e) {
3279
+ uploadTargetDir = e.target.value;
3280
+ toast('上传目标:' + (uploadTargetDir || '根目录'));
3281
+ });
3282
+ // 按扩展名筛选
3283
+ $('extSelect').addEventListener('change', function (e) {
3284
+ extFilter = e.target.value;
3285
+ currentPage = 1;
3286
+ loadFiles();
3287
+ });
3288
+ $('pageUrl').addEventListener('click', function () { window.open(pageUrl, '_blank'); });
3289
+ $('pageQrCard').addEventListener('click', function (e) {
3290
+ if (e.target.closest('button')) return; // 不拦截 openPageBtn
3291
+ showQr(pageUrl, '手机扫码访问页面');
3292
+ });
3293
+ $('sortSelect').addEventListener('change', function (e) {
3294
+ sortType = e.target.value;
3295
+ saveSortPref();
3296
+ currentPage = 1;
3297
+ loadFiles();
3298
+ });
3299
+ $('orderBtn').addEventListener('click', function () {
3300
+ sortOrder = sortOrder === 'desc' ? 'asc' : 'desc';
3301
+ $('orderBtn').textContent = sortOrder === 'desc' ? '↓ 降序' : '↑ 升序';
3302
+ saveSortPref();
3303
+ currentPage = 1;
3304
+ loadFiles();
3305
+ });
3306
+ // 搜索过滤:输入即过滤,条件下推到服务端
3307
+ var searchTimer = null;
3308
+ $('searchInput').addEventListener('input', function (e) {
3309
+ var value = e.target.value;
3310
+ if (searchTimer) clearTimeout(searchTimer);
3311
+ searchTimer = setTimeout(function () {
3312
+ searchKeyword = value.trim();
3313
+ currentPage = 1;
3314
+ loadFiles();
3315
+ }, 250);
3316
+ });
3317
+ // 分页
3318
+ function gotoPage(page) {
3319
+ var target = Math.min(Math.max(1, page), totalPages);
3320
+ if (target === currentPage) return;
3321
+ currentPage = target;
3322
+ loadFiles();
3323
+ window.scrollTo({ top: 0, behavior: 'smooth' });
3324
+ }
3325
+ $('firstPage').addEventListener('click', function () { gotoPage(1); });
3326
+ $('prevPage').addEventListener('click', function () { gotoPage(currentPage - 1); });
3327
+ $('nextPage').addEventListener('click', function () { gotoPage(currentPage + 1); });
3328
+ $('lastPage').addEventListener('click', function () { gotoPage(totalPages); });
3329
+ // 每页条数
3330
+ $('pageSizeSelect').addEventListener('change', function (e) {
3331
+ var size = Number(e.target.value);
3332
+ if (!size) return;
3333
+ PAGE_SIZE = size;
3334
+ savePageSizePref();
3335
+ currentPage = 1;
3336
+ loadFiles();
3337
+ });
3338
+ // 跳转到指定页码
3339
+ function jumpToPage() {
3340
+ var input = $('jumpInput');
3341
+ var page = Number(input.value);
3342
+ if (!page || page < 1) {
3343
+ toast('请输入有效的页码', 'err');
3344
+ return;
3345
+ }
3346
+ if (page > totalPages) {
3347
+ toast('最多只有 ' + totalPages + ' 页', 'err');
3348
+ return;
3349
+ }
3350
+ input.value = '';
3351
+ gotoPage(page);
3352
+ }
3353
+ $('jumpBtn').addEventListener('click', jumpToPage);
3354
+ $('jumpInput').addEventListener('keydown', function (e) {
3355
+ if (e.key === 'Enter') jumpToPage();
3356
+ });
3357
+ $('closeModal').addEventListener('click', function () { $('qrModal').classList.add('hidden'); });
3358
+ $('qrModal').addEventListener('click', function (e) { if (e.target === $('qrModal')) $('qrModal').classList.add('hidden'); });
3359
+
3360
+ // 重命名弹窗
3361
+ $('renameCancel').addEventListener('click', closeRenameDialog);
3362
+ $('renameOk').addEventListener('click', submitRename);
3363
+ $('renameModal').addEventListener('click', function (e) { if (e.target === $('renameModal')) closeRenameDialog(); });
3364
+ $('renameInput').addEventListener('keydown', function (e) {
3365
+ if (e.key === 'Enter') submitRename();
3366
+ });
3367
+
3368
+ // 移动弹窗
3369
+ $('moveCancel').addEventListener('click', closeMoveDialog);
3370
+ $('moveOk').addEventListener('click', submitMove);
3371
+ $('moveModal').addEventListener('click', function (e) { if (e.target === $('moveModal')) closeMoveDialog(); });
3372
+ $('moveDirList').addEventListener('click', function (e) {
3373
+ var btn = e.target.closest('button[data-dir]');
3374
+ if (!btn) return;
3375
+ // 根目录用空字符串表示
3376
+ $('moveDirInput').value = btn.dataset.dir || '';
3377
+ });
3378
+
3379
+ // 批量重命名弹窗
3380
+ $('batchRenameCancel').addEventListener('click', closeBatchRenameDialog);
3381
+ $('batchRenameOk').addEventListener('click', submitBatchRename);
3382
+ $('batchRenameModal').addEventListener('click', function (e) { if (e.target === $('batchRenameModal')) closeBatchRenameDialog(); });
3383
+ $('batchRuleMode').addEventListener('change', renderRuleParams);
3384
+ $('batchRuleParams').addEventListener('input', updateRulePreview);
3385
+ $('batchRuleParams').addEventListener('change', updateRulePreview);
3386
+
3387
+ // 粘贴内容分享
3388
+ $('pasteBtn').addEventListener('click', function () { openTextModal(''); });
3389
+ $('textCancel').addEventListener('click', closeTextModal);
3390
+ $('textOk').addEventListener('click', submitTextShare);
3391
+ $('textModal').addEventListener('click', function (e) { if (e.target === $('textModal')) closeTextModal(); });
3392
+ $('clipboardReadBtn').addEventListener('click', readClipboard);
3393
+ // 选择自定义命名时才显示文件名输入框
3394
+ $('pasteStrategy').addEventListener('change', function (e) {
3395
+ $('pasteName').classList.toggle('hidden', e.target.value !== 'custom');
3396
+ });
3397
+ // 在文本框里粘贴图片时按图片分享,普通文本走默认粘贴行为
3398
+ $('textInput').addEventListener('paste', function (e) {
3399
+ var dt = e.clipboardData || e.dataTransfer;
3400
+ if (!dt || !dt.items) return;
3401
+ for (var i = 0; i < dt.items.length; i++) {
3402
+ var item = dt.items[i];
3403
+ if (item.kind === 'file' && item.type && item.type.indexOf('image/') === 0) {
3404
+ var file = item.getAsFile();
3405
+ if (file) {
3406
+ e.preventDefault();
3407
+ closeTextModal();
3408
+ shareClipboardImage(file);
3409
+ return;
3410
+ }
3411
+ }
3412
+ }
3413
+ });
3414
+
3415
+ // 分享管理
3416
+ $('shareManageBtn').addEventListener('click', openShareModal);
3417
+ $('shareClose').addEventListener('click', function () { $('shareModal').classList.add('hidden'); });
3418
+ $('shareModal').addEventListener('click', function (e) { if (e.target === $('shareModal')) $('shareModal').classList.add('hidden'); });
3419
+ $('shareRefresh').addEventListener('click', loadShareList);
3420
+ $('shareList').addEventListener('click', function (e) {
3421
+ var btn = e.target.closest('button[data-act]');
3422
+ if (!btn) return;
3423
+ var row = btn.closest('div[data-token]');
3424
+ if (!row) return;
3425
+ if (btn.dataset.act === 'copy') copyText(row.dataset.url);
3426
+ else if (btn.dataset.act === 'qr') showQr(row.dataset.url, '扫码打开分享:' + (row.dataset.url || ''));
3427
+ else if (btn.dataset.act === 'revoke') revokeShare(row.dataset.token);
3428
+ });
3429
+
3430
+ // ---------------------------------------------------------------------------
3431
+ // 设置面板
3432
+ //
3433
+ // 管理员可在网页端直接改口令、令牌与各项限制,改完立即生效。
3434
+ // 数值项按更易懂的单位显示(字节换算成 MB、毫秒换算成小时),
3435
+ // 提交时再换算回服务端使用的原始单位。
3436
+ // ---------------------------------------------------------------------------
3437
+
3438
+ /** 设置项的分组与展示单位 */
3439
+ var SETTINGS_GROUPS = [
3440
+ { title: '访问控制', keys: ['token', 'password', 'visitorPassword', 'sessionTtl'] },
3441
+ { title: '传输限制', keys: ['maxSize', 'maxTotalSize', 'maxConcurrent', 'rateLimit'] },
3442
+ { title: '文件维护', keys: ['trashDays', 'autoCleanDays', 'autoCleanMaxSize', 'blockExtensions'] },
3443
+ ];
3444
+
3445
+ /** 各设置项在界面上的单位换算 */
3446
+ var SETTINGS_UNITS = {
3447
+ maxSize: { factor: 1024 * 1024, label: 'MB' },
3448
+ maxTotalSize: { factor: 1024 * 1024, label: 'MB' },
3449
+ autoCleanMaxSize: { factor: 1024 * 1024, label: 'MB' },
3450
+ sessionTtl: { factor: 3600 * 1000, label: '小时' },
3451
+ };
3452
+
3453
+ /** 设置面板当前的取值快照 */
3454
+ var settingsState = { items: [], restartRequired: [], file: '' };
3455
+
3456
+ /** 取某个设置项 */
3457
+ function settingItem(key) {
3458
+ for (var i = 0; i < settingsState.items.length; i++) {
3459
+ if (settingsState.items[i].key === key) return settingsState.items[i];
3460
+ }
3461
+ return null;
3462
+ }
3463
+
3464
+ /** 渲染单个设置项 */
3465
+ function renderSetting(item) {
3466
+ var head =
3467
+ '<div class="flex items-center justify-between gap-2">' +
3468
+ '<div class="text-slate-200 font-medium">' + escapeHtml(item.label) +
3469
+ (item.set ? '<span class="ml-1 text-[10px] text-emerald-400">已启用</span>' : '<span class="ml-1 text-[10px] text-slate-500">未启用</span>') +
3470
+ (item.source === 'runtime' ? '<span class="ml-1 text-[10px] text-sky-400">运行时</span>' : '') +
3471
+ '</div>' +
3472
+ (item.source === 'runtime'
3473
+ ? '<button data-reset="' + item.key + '" class="text-[11px] text-slate-400 hover:text-emerald-400 px-2 py-1 rounded border border-slate-700 transition shrink-0">恢复默认</button>'
3474
+ : '') +
3475
+ '</div>';
3476
+
3477
+ var input = '';
3478
+ if (item.kind === 'secret') {
3479
+ // 敏感项不显示原文,只提示当前状态;留空表示不修改
3480
+ input =
3481
+ '<input data-key="' + item.key + '" type="password" placeholder="' + (item.set ? '已设置(' + escapeHtml(item.masked || '') + '),留空表示不修改' : '留空表示不修改') + '" ' +
3482
+ 'autocomplete="new-password" spellcheck="false" class="mt-2 w-full bg-slate-800 border border-slate-700 rounded-lg px-3 py-2 text-xs outline-none focus:border-emerald-500/60" />' +
3483
+ (item.set
3484
+ ? '<button data-clear="' + item.key + '" class="mt-1 text-[11px] text-red-400 hover:text-red-300 px-2 py-1 rounded border border-red-500/30 transition">清除(停用该项)</button>'
3485
+ : '');
3486
+ } else if (item.kind === 'rate') {
3487
+ var rate = item.value || { windowMs: 60000, max: 120 };
3488
+ input =
3489
+ '<div class="mt-2 flex items-center gap-2 flex-wrap">' +
3490
+ '<input data-key="rateLimit.windowMs" type="number" min="1" value="' + Math.round((rate.windowMs || 60000) / 1000) + '" ' +
3491
+ 'class="w-20 bg-slate-800 border border-slate-700 rounded-lg px-2 py-1.5 text-xs outline-none focus:border-emerald-500/60" />' +
3492
+ '<span class="text-[11px] text-slate-500">秒内最多</span>' +
3493
+ '<input data-key="rateLimit.max" type="number" min="0" value="' + Number(rate.max ?? 120) + '" ' +
3494
+ 'class="w-20 bg-slate-800 border border-slate-700 rounded-lg px-2 py-1.5 text-xs outline-none focus:border-emerald-500/60" />' +
3495
+ '<span class="text-[11px] text-slate-500">次请求(0 表示不限制)</span>' +
3496
+ '</div>';
3497
+ } else if (item.kind === 'numberList') {
3498
+ input =
3499
+ '<input data-key="' + item.key + '" type="text" value="' + escapeHtml((item.value || []).join(', ')) + '" ' +
3500
+ 'placeholder="如 .php, .sh" spellcheck="false" class="mt-2 w-full bg-slate-800 border border-slate-700 rounded-lg px-3 py-2 text-xs outline-none focus:border-emerald-500/60" />';
3501
+ } else {
3502
+ var unit = SETTINGS_UNITS[item.key];
3503
+ var shown = Number(item.value ?? 0);
3504
+ if (unit) shown = Math.round((shown / unit.factor) * 100) / 100;
3505
+ input =
3506
+ '<div class="mt-2 flex items-center gap-2">' +
3507
+ '<input data-key="' + item.key + '" type="number" min="0" value="' + shown + '" ' +
3508
+ 'class="w-28 bg-slate-800 border border-slate-700 rounded-lg px-2 py-1.5 text-xs outline-none focus:border-emerald-500/60" />' +
3509
+ (unit ? '<span class="text-[11px] text-slate-500">' + unit.label + '</span>' : '') +
3510
+ (item.unit && !unit ? '<span class="text-[11px] text-slate-500">' + escapeHtml(item.unit) + '</span>' : '') +
3511
+ '</div>';
3512
+ }
3513
+
3514
+ return '<div class="bg-slate-800/40 border border-slate-800 rounded-xl p-3">' + head + input +
3515
+ '<div class="text-[11px] text-slate-500 mt-1.5">' + escapeHtml(item.desc) + '</div></div>';
3516
+ }
3517
+
3518
+ /** 当前页面是否从回环地址打开(本机浏览器) */
3519
+ function isLoopbackClient() {
3520
+ var host = location.hostname;
3521
+ return host === 'localhost' || host === '127.0.0.1' || host === '[::1]' || host === '::1';
3522
+ }
3523
+
3524
+ /**
3525
+ * HTTP 访问时说明哪些能力不可用。
3526
+ *
3527
+ * 局域网 IP + http 属于非安全上下文,Service Worker(安装到桌面)、
3528
+ * 剪贴板读写、目录监听、系统分享与通知都会被浏览器禁用。
3529
+ * 这是浏览器的安全限制,不解释的话用户只会认为「功能坏了」;
3530
+ * 关掉之后记在本地,不再反复打扰。
3531
+ */
3532
+ function showInsecureTip() {
3533
+ if (window.isSecureContext) return;
3534
+ try {
3535
+ if (localStorage.getItem('localsend.insecureTipDismissed') === '1') return;
3536
+ } catch (e) {
3537
+ // 存储不可用时仍然展示
3538
+ }
3539
+ var tip = $('insecureTip');
3540
+ if (!tip) return;
3541
+ tip.classList.remove('hidden');
3542
+ tip.classList.add('flex');
3543
+ }
3544
+
3545
+ // ---------------------------------------------------------------------------
3546
+ // 诊断面板(仅管理员):运行状态 + 最近操作记录
3547
+ // ---------------------------------------------------------------------------
3548
+
3549
+ /** 审计动作的中文名 */
3550
+ var AUDIT_LABELS = {
3551
+ 'file.delete': '删除文件',
3552
+ 'file.delete-batch': '批量删除',
3553
+ 'file.rename': '重命名',
3554
+ 'file.move': '移动',
3555
+ 'file.rename-batch': '批量重命名',
3556
+ 'file.upload': '上传',
3557
+ 'file.cleanup-temp': '清理残留',
3558
+ 'trash.restore': '回收站还原',
3559
+ 'trash.delete': '彻底删除',
3560
+ 'trash.empty': '清空回收站',
3561
+ 'share.create': '创建分享',
3562
+ 'share.revoke': '撤销分享',
3563
+ 'settings.update': '修改设置',
3564
+ 'settings.reset': '恢复默认',
3565
+ 'auth.login': '登录',
3566
+ 'auth.fail': '登录失败',
3567
+ 'dav.upload': 'WebDAV 上传',
3568
+ 'dav.delete': 'WebDAV 删除',
3569
+ 'dav.mkdir': 'WebDAV 新建目录',
3570
+ 'dav.move': 'WebDAV 移动',
3571
+ 'dav.copy': 'WebDAV 复制',
3572
+ };
3573
+
3574
+ /** 打开诊断面板 */
3575
+ function openDiag() {
3576
+ $('diagModal').classList.remove('hidden');
3577
+ loadDiag();
3578
+ }
3579
+
3580
+ /** 拉取指标与审计记录 */
3581
+ function loadDiag() {
3582
+ var statsBox = $('diagStats');
3583
+ statsBox.innerHTML = '<div class="text-slate-500">加载中…</div>';
3584
+ apiFetch(API + '/stats')
3585
+ .then(function (r) { return r.json(); })
3586
+ .then(function (json) {
3587
+ if (json.code !== 0) throw new Error(json.msg || '读取失败');
3588
+ renderDiagStats(json.data || {});
3589
+ })
3590
+ .catch(function (e) {
3591
+ statsBox.innerHTML = '<div class="text-red-400">' + escapeHtml((e && e.message) || '读取失败') + '</div>';
3592
+ });
3593
+
3594
+ apiFetch(API + '/audit?limit=60')
3595
+ .then(function (r) { return r.json(); })
3596
+ .then(function (json) {
3597
+ if (json.code !== 0) throw new Error(json.msg || '读取失败');
3598
+ renderDiagAudit(json.data || {});
3599
+ })
3600
+ .catch(function (e) {
3601
+ $('diagAudit').innerHTML = '<div class="text-red-400">' + escapeHtml((e && e.message) || '读取失败') + '</div>';
3602
+ });
3603
+ }
3604
+
3605
+ /** 诊断面板里的一张指标卡 */
3606
+ function diagCard(label, value, hint) {
3607
+ return (
3608
+ '<div class="bg-slate-800/60 border border-slate-700 rounded-xl px-3 py-2">' +
3609
+ '<div class="text-[10px] text-slate-500">' + escapeHtml(label) + '</div>' +
3610
+ '<div class="text-slate-200 font-mono text-sm mt-0.5 break-all">' + escapeHtml(String(value)) + '</div>' +
3611
+ (hint ? '<div class="text-[10px] text-slate-500 mt-0.5">' + escapeHtml(hint) + '</div>' : '') +
3612
+ '</div>'
3613
+ );
3614
+ }
3615
+
3616
+ /** 渲染运行指标 */
3617
+ function renderDiagStats(d) {
3618
+ var c = d.counters || {};
3619
+ var merge = (d.timers || {})['merge.ms'];
3620
+ var cache = d.cache || {};
3621
+ var cacheTotal = (cache.hits || 0) + (cache.misses || 0);
3622
+ var hitRate = cacheTotal ? Math.round(((cache.hits || 0) / cacheTotal) * 100) : 0;
3623
+ $('diagStats').innerHTML = [
3624
+ diagCard('运行时长', fmtDuration(d.uptime)),
3625
+ diagCard('内存占用', fmtSize(d.memory || 0)),
3626
+ diagCard('文件 / 已用', (d.files || 0) + ' 个 · ' + fmtSize(d.used || 0)),
3627
+ diagCard('已上传 / 失败', (c['upload.file'] || 0) + ' / ' + (c['upload.error'] || 0)),
3628
+ diagCard('被限流次数', c['http.429'] || 0, '偏大说明被刷或限流偏紧'),
3629
+ diagCard('合并耗时', merge ? 'P95 ' + merge.p95 + ' ms' : '-', merge ? 'P50 ' + merge.p50 + ' ms · ' + merge.count + ' 次' : '暂无合并'),
3630
+ diagCard('缓存命中率', hitRate + '%', '命中 ' + (cache.hits || 0) + ' · 未命中 ' + (cache.misses || 0)),
3631
+ diagCard('事件流连接', d.events || 0),
3632
+ diagCard('票据 / 分享', (d.tickets || 0) + ' / ' + (d.shares || 0)),
3633
+ ].join('');
3634
+ }
3635
+
3636
+ /** 渲染最近操作记录 */
3637
+ function renderDiagAudit(d) {
3638
+ var items = d.items || [];
3639
+ $('diagAuditFile').textContent = d.file ? '审计文件:' + d.file : '';
3640
+ if (!items.length) {
3641
+ $('diagAudit').innerHTML = '<div class="text-slate-500">暂无记录(删除、整理、分享、改设置才会记录)</div>';
3642
+ return;
3643
+ }
3644
+ $('diagAudit').innerHTML = items
3645
+ .map(function (item) {
3646
+ var time = fmtTime(item.ts);
3647
+ var label = AUDIT_LABELS[item.action] || item.action;
3648
+ // 破坏性动作与登录失败标红,方便一眼扫到
3649
+ var danger = item.action.indexOf('delete') >= 0 || item.action === 'trash.empty' || item.action === 'auth.fail';
3650
+ return (
3651
+ '<div class="flex gap-2 items-baseline ' + (danger ? 'text-red-300' : 'text-slate-300') + '">' +
3652
+ '<span class="text-slate-500 shrink-0">' + escapeHtml(time) + '</span>' +
3653
+ '<span class="shrink-0">' + escapeHtml(label) + '</span>' +
3654
+ '<span class="text-slate-500 shrink-0">' + escapeHtml(item.role || '') + '</span>' +
3655
+ '<span class="text-slate-500 shrink-0">' + escapeHtml(item.ip || '') + '</span>' +
3656
+ '<span class="truncate" title="' + escapeHtml(item.target || '') + '">' + escapeHtml(item.target || '') + '</span>' +
3657
+ '</div>'
3658
+ );
3659
+ })
3660
+ .join('');
3661
+ }
3662
+
3663
+ /** 打开设置面板 */
3664
+ function openSettings() {
3665
+ apiFetch(API + '/settings')
3666
+ .then(function (r) { return r.json(); })
3667
+ .then(function (json) {
3668
+ if (json.code !== 0) { toast(json.msg || '读取设置失败', 'err'); return; }
3669
+ settingsState = json.data || settingsState;
3670
+ var body = $('settingsBody');
3671
+ var html = '';
3672
+ SETTINGS_GROUPS.forEach(function (group) {
3673
+ var items = group.keys.map(settingItem).filter(Boolean);
3674
+ if (!items.length) return;
3675
+ html += '<div><div class="text-[11px] text-slate-400 mb-1.5">' + group.title + '</div><div class="space-y-2">' +
3676
+ items.map(renderSetting).join('') + '</div></div>';
3677
+ });
3678
+ // 这两项与路由注册、存储路径有关,只能改配置文件后重启
3679
+ if (settingsState.restartRequired && settingsState.restartRequired.length) {
3680
+ html += '<div><div class="text-[11px] text-slate-400 mb-1.5">需重启服务才能生效</div><div class="space-y-2">' +
3681
+ settingsState.restartRequired.map(function (item) {
3682
+ return '<div class="bg-slate-800/40 border border-slate-800 rounded-xl p-3">' +
3683
+ '<div class="flex items-center justify-between gap-2"><div class="text-slate-200 font-medium">' + escapeHtml(item.label) + '</div>' +
3684
+ '<span class="text-[10px] text-amber-400">仅配置文件可改</span></div>' +
3685
+ '<div class="text-[11px] text-slate-500 mt-1.5 font-mono break-all">' + escapeHtml(String(item.value)) + '</div></div>';
3686
+ }).join('') + '</div></div>';
3687
+ }
3688
+ if (settingsState.file) {
3689
+ html += '<div class="text-[11px] text-slate-500">运行时设置保存在:<span class="font-mono break-all">' +
3690
+ escapeHtml(settingsState.file) + '</span></div>';
3691
+ }
3692
+ body.innerHTML = html;
3693
+ // 开放模式下服务端只接受本机发起的写入:非本机时提前说明,不让用户白填一遍
3694
+ // 按钮保持可点:禁用状态下点它毫无反馈,用户只会以为「保存坏了」,
3695
+ // 由 saveSettings 的统一守卫弹出明确原因
3696
+ var remoteOpen = !!sessionInfo.open && !isLoopbackClient();
3697
+ $('settingsLocalHint').classList.toggle('hidden', !remoteOpen);
3698
+ $('settingsSave').classList.toggle('opacity-60', remoteOpen);
3699
+ $('settingsSave').title = remoteOpen ? '开放模式下只能在运行服务的本机修改设置' : '';
3700
+ $('settingsModal').classList.remove('hidden');
3701
+ })
3702
+ .catch(function () { toast('读取设置失败', 'err'); });
3703
+ }
3704
+
3705
+ /** 收集面板里改动过的项 */
3706
+ function collectSettingChanges() {
3707
+ var changes = {};
3708
+ var rate = null;
3709
+ var rateTouched = false;
3710
+ var nodes = $('settingsBody').querySelectorAll('[data-key]');
3711
+ for (var i = 0; i < nodes.length; i++) {
3712
+ var el = nodes[i];
3713
+ var key = el.dataset.key;
3714
+ // 频率限制的两个字段要一起提交:服务端对缺失字段会用默认值补齐,
3715
+ // 只提交其中一个会把另一个悄悄打回默认值
3716
+ if (key === 'rateLimit.windowMs' || key === 'rateLimit.max') {
3717
+ if (!rate) rate = {};
3718
+ if (el.dataset.touched === '1') rateTouched = true;
3719
+ var rateNum = Number(el.value);
3720
+ if (el.value === '' || !isFinite(rateNum)) continue;
3721
+ if (key === 'rateLimit.windowMs') rate.windowMs = rateNum * 1000;
3722
+ else rate.max = rateNum;
3723
+ continue;
3724
+ }
3725
+ // 只提交用户动过的输入框
3726
+ if (el.dataset.touched !== '1') continue;
3727
+ var raw = el.value;
3728
+ if (el.type === 'password' && !raw) continue; // 敏感项留空表示不修改
3729
+ if (el.type === 'number') {
3730
+ // 输入框按更易读的单位展示(MB / 小时),提交前换回服务端使用的原始单位(字节 / 毫秒)
3731
+ var shown = Number(raw);
3732
+ if (raw === '' || !isFinite(shown)) continue; // 清空表示不修改,避免写入 0
3733
+ var factor = SETTINGS_UNITS[key] ? SETTINGS_UNITS[key].factor : 1;
3734
+ changes[key] = Math.round(shown * factor);
3735
+ continue;
3736
+ }
3737
+ changes[key] = raw;
3738
+ }
3739
+ if (rate && rateTouched && rate.windowMs !== undefined && rate.max !== undefined) changes.rateLimit = rate;
3740
+ return changes;
3741
+ }
3742
+
3743
+ /** 保存设置 */
3744
+ function saveSettings() {
3745
+ // 开放模式 + 非本机:服务端会拒绝,这里先给出明确原因
3746
+ if (sessionInfo.open && !isLoopbackClient()) {
3747
+ toast('尚未设置口令:请在本机改用 127.0.0.1 打开本页,或在配置文件里设置 password', 'err');
3748
+ return;
3749
+ }
3750
+ var changes = collectSettingChanges();
3751
+ if (!Object.keys(changes).length) {
3752
+ toast('没有需要保存的修改', 'err');
3753
+ return;
3754
+ }
3755
+ var payload = { changes: changes };
3756
+ // 当前管理员口令:明文只留在浏览器里,提交的是它的摘要
3757
+ var currentPwd = $('settingsCurrentPwd').value;
3758
+ if ('password' in changes || 'visitorPassword' in changes) {
3759
+ if (!currentPwd) {
3760
+ toast('修改口令需要填写当前管理员口令', 'err');
3761
+ return;
3762
+ }
3763
+ }
3764
+ // 先把要提交的摘要算出来(需要服务端公开的盐值)
3765
+ var prepare = function () {
3766
+ if (!('password' in changes) && !('visitorPassword' in changes)) return Promise.resolve();
3767
+ return fetchSalts()
3768
+ .then(function (salts) {
3769
+ payload.currentPasswordDigest = digestOf(salts, 'password', currentPwd);
3770
+ if (!payload.currentPasswordDigest) throw new Error('服务端未启用管理员口令');
3771
+ });
3772
+ };
3773
+ prepare()
3774
+ .then(function () {
3775
+ return apiFetch(API + '/settings', {
3776
+ method: 'POST',
3777
+ headers: { 'Content-Type': 'application/json' },
3778
+ body: JSON.stringify(payload),
3779
+ });
3780
+ })
3781
+ .then(function (r) { return r.json(); })
3782
+ .then(function (json) {
3783
+ if (json.code !== 0) { toast(json.msg || '保存失败', 'err'); return; }
3784
+ toast('设置已保存并生效', 'ok');
3785
+ $('settingsCurrentPwd').value = '';
3786
+ // 令牌变了:用新令牌换一个会话,否则旧会话会失效
3787
+ if ('token' in changes) {
3788
+ var newToken = String(changes.token || '');
3789
+ accessToken = newToken;
3790
+ try { localStorage.setItem(TOKEN_STORAGE_KEY, newToken); } catch (e) { /* 忽略存储失败 */ }
3791
+ toast(newToken ? '访问令牌已更新,旧令牌随即失效' : '访问令牌已停用,访问不再需要令牌', 'ok');
3792
+ if (newToken) {
3793
+ exchangeToken(newToken).catch(function () {
3794
+ openLoginModal('请重新输入口令或访问令牌');
3795
+ });
3796
+ }
3797
+ }
3798
+ openSettings();
3799
+ })
3800
+ .catch(function (e) {
3801
+ toast((e && e.message) || '保存失败', 'err');
3802
+ });
3803
+ }
3804
+
3805
+ /** 恢复某一项的默认值 */
3806
+ function resetSetting(key) {
3807
+ if (sessionInfo.open && !isLoopbackClient()) {
3808
+ toast('尚未设置口令,请在本机浏览器修改设置', 'err');
3809
+ return;
3810
+ }
3811
+ apiFetch(API + '/settings/' + encodeURIComponent(key), { method: 'DELETE' })
3812
+ .then(function (r) { return r.json(); })
3813
+ .then(function (json) {
3814
+ if (json.code !== 0) { toast(json.msg || '恢复失败', 'err'); return; }
3815
+ toast('已恢复默认设置', 'ok');
3816
+ openSettings();
3817
+ })
3818
+ .catch(function () { toast('恢复失败', 'err'); });
3819
+ }
3820
+
3821
+ /** 事件绑定
3822
+ * 登录与退出
3823
+ */
3824
+ $('loginBtn').addEventListener('click', function () { openLoginModal(''); });
3825
+ // 遮罩上的入口:验证前页头被遮住,只能从这里打开登录框
3826
+ $('authGateBtn').addEventListener('click', function () { openLoginModal(''); });
3827
+ $('logoutBtn').addEventListener('click', logout);
3828
+ $('loginCancel').addEventListener('click', closeLoginModal);
3829
+ $('loginOk').addEventListener('click', submitLogin);
3830
+ // 需要令牌验证时不能点空白关掉:关掉之后页面上没有任何可用入口
3831
+ $('loginModal').addEventListener('click', function (e) {
3832
+ if (e.target === $('loginModal') && !needsTokenGate()) closeLoginModal();
3833
+ });
3834
+ $('loginPassword').addEventListener('keydown', function (e) {
3835
+ if (e.key === 'Enter') submitLogin();
3836
+ });
3837
+
3838
+ // 设置面板
3839
+ $('settingsBtn').addEventListener('click', openSettings);
3840
+ // HTTP 能力降级提示:关掉后不再打扰
3841
+ $('insecureTipClose').addEventListener('click', function () {
3842
+ $('insecureTip').classList.add('hidden');
3843
+ $('insecureTip').classList.remove('flex');
3844
+ try {
3845
+ localStorage.setItem('localsend.insecureTipDismissed', '1');
3846
+ } catch (e) {
3847
+ // 忽略存储失败
3848
+ }
3849
+ });
3850
+ // 诊断面板
3851
+ $('diagBtn').addEventListener('click', openDiag);
3852
+ $('diagClose').addEventListener('click', function () { $('diagModal').classList.add('hidden'); });
3853
+ $('diagRefresh').addEventListener('click', loadDiag);
3854
+ $('diagModal').addEventListener('click', function (e) { if (e.target === $('diagModal')) $('diagModal').classList.add('hidden'); });
3855
+ $('settingsClose').addEventListener('click', function () { $('settingsModal').classList.add('hidden'); });
3856
+ $('settingsModal').addEventListener('click', function (e) { if (e.target === $('settingsModal')) $('settingsModal').classList.add('hidden'); });
3857
+ $('settingsSave').addEventListener('click', saveSettings);
3858
+ $('settingsCopyLink').addEventListener('click', function () { copyText(pageUrl); });
3859
+ // 记录哪些输入框被改过,只提交改动过的项
3860
+ $('settingsBody').addEventListener('input', function (e) {
3861
+ var el = e.target;
3862
+ if (el && el.dataset && el.dataset.key) el.dataset.touched = '1';
3863
+ });
3864
+ // 恢复默认 / 清除某一项
3865
+ $('settingsBody').addEventListener('click', function (e) {
3866
+ var btn = e.target.closest('button[data-reset], button[data-clear]');
3867
+ if (!btn) return;
3868
+ if (btn.dataset.reset) {
3869
+ if (!window.confirm('确定恢复该项的默认值?')) return;
3870
+ resetSetting(btn.dataset.reset);
3871
+ return;
3872
+ }
3873
+ if (btn.dataset.clear) {
3874
+ if (!window.confirm('确定停用该项?停用后该项将回到配置文件的取值。')) return;
3875
+ resetSetting(btn.dataset.clear);
3876
+ }
3877
+ });
3878
+
3879
+ // 页面任意处直接粘贴(Ctrl+V)即可分享文本或截图
3880
+ document.addEventListener('paste', function (e) {
3881
+ var target = e.target;
3882
+ // 在输入框 / 文本域里粘贴时保持默认行为
3883
+ if (target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable)) return;
3884
+ var dt = e.clipboardData || e.dataTransfer;
3885
+ if (!dt) return;
3886
+ // 需要访客口令时不能保存内容,先提示并引导登录
3887
+ if (!canWrite()) {
3888
+ toast('需要访客口令才能保存粘贴的内容', 'err', {
3889
+ label: '登录',
3890
+ onClick: function () { openLoginModal('请输入访客口令后即可上传与分享'); },
3891
+ });
3892
+ return;
3893
+ }
3894
+ // 图片(截图)优先
3895
+ if (dt.items && dt.items.length) {
3896
+ for (var i = 0; i < dt.items.length; i++) {
3897
+ var item = dt.items[i];
3898
+ if (item.kind === 'file' && item.type && item.type.indexOf('image/') === 0) {
3899
+ var file = item.getAsFile();
3900
+ if (file) {
3901
+ e.preventDefault();
3902
+ shareClipboardImage(file);
3903
+ return;
3904
+ }
3905
+ }
3906
+ }
3907
+ }
3908
+ var text = dt.getData('text/plain');
3909
+ if (text && text.trim()) {
3910
+ e.preventDefault();
3911
+ openTextModal(text);
3912
+ }
3913
+ });
3914
+ function closePreviewModal() {
3915
+ $('previewModal').classList.add('hidden');
3916
+ // 清空媒体内容,避免残留的音视频继续在后台播放
3917
+ var body = $('previewBody');
3918
+ body.innerHTML = '';
3919
+ body.classList.add('hidden');
3920
+ $('previewContent').textContent = '';
3921
+ $('previewContent').classList.add('hidden');
3922
+ setPreviewCopy('');
3923
+ }
3924
+ $('closePreview').addEventListener('click', closePreviewModal);
3925
+ $('previewModal').addEventListener('click', function (e) { if (e.target === $('previewModal')) closePreviewModal(); });
3926
+ // 复制预览内容:文本预览时才可用
3927
+ $('previewCopy').addEventListener('click', function () {
3928
+ if (!previewText) return;
3929
+ copyText(previewText);
3930
+ });
3931
+ // 回收站
3932
+ $('trashBtn').addEventListener('click', openTrash);
3933
+ $('closeTrash').addEventListener('click', function () { $('trashModal').classList.add('hidden'); });
3934
+ $('trashModal').addEventListener('click', function (e) { if (e.target === $('trashModal')) $('trashModal').classList.add('hidden'); });
3935
+ $('trashEmpty').addEventListener('click', function () {
3936
+ if (!window.confirm('确定清空回收站?其中的文件将无法还原。')) return;
3937
+ apiFetch(API + '/trash', { method: 'DELETE' })
3938
+ .then(function (r) { return r.json(); })
3939
+ .then(function (j) {
3940
+ if (j.code !== 0) { toast(j.msg || '清空失败', 'err'); return; }
3941
+ toast('已清空回收站(' + j.data.removed + ' 项)', 'ok');
3942
+ loadTrashList();
3943
+ refreshTrashCount();
3944
+ })
3945
+ .catch(function () { toast('清空失败', 'err'); });
3946
+ });
3947
+ $('fileList').addEventListener('click', function (e) {
3948
+ // 点击文件名前的目录标记:只看该目录下的文件
3949
+ var dirEl = e.target.closest('[data-dir]');
3950
+ if (dirEl) {
3951
+ setDirFilter(dirFilter === dirEl.dataset.dir ? '' : dirEl.dataset.dir);
3952
+ // 同步目录筛选下拉,避免两处状态不一致
3953
+ $('dirSelect').value = dirFilter;
3954
+ loadFiles();
3955
+ return;
3956
+ }
3957
+ var btnEl = e.target.closest('button[data-act]');
3958
+ if (!btnEl) return;
3959
+ runFileAction(btnEl.dataset.act, btnEl.dataset.name);
3960
+ });
3961
+
3962
+ // 移动端操作菜单
3963
+ $('fileMenuClose').addEventListener('click', closeFileMenu);
3964
+ $('fileMenu').addEventListener('click', function (e) {
3965
+ if (e.target === $('fileMenu')) closeFileMenu();
3966
+ });
3967
+ $('fileMenuList').addEventListener('click', function (e) {
3968
+ var item = e.target.closest('button[data-act]');
3969
+ if (!item) return;
3970
+ var act = item.dataset.act;
3971
+ var name = fileMenuTarget;
3972
+ closeFileMenu();
3973
+ runFileAction(act, name);
3974
+ });
3975
+
3976
+ // 全选 / 批量操作(全选范围为当前页显示的文件)
3977
+ $('selectAll').addEventListener('change', function (e) {
3978
+ var checked = e.target.checked;
3979
+ currentPageItems().forEach(function (f) { selected[f.name] = checked; });
3980
+ updateBatchUI();
3981
+ document.querySelectorAll('#fileList input.file-check').forEach(function (cb) { cb.checked = checked; });
3982
+ document.querySelectorAll('#fileList > div').forEach(function (div) {
3983
+ div.classList.toggle('bg-slate-800/40', checked);
3984
+ });
3985
+ });
3986
+ $('fileList').addEventListener('change', function (e) {
3987
+ if (!e.target.classList.contains('file-check')) return;
3988
+ var name = e.target.dataset.name;
3989
+ selected[name] = e.target.checked;
3990
+ updateBatchUI();
3991
+ e.target.closest('div').classList.toggle('bg-slate-800/40', e.target.checked);
3992
+ });
3993
+ $('batchShare').addEventListener('click', function () {
3994
+ var names = Object.keys(selected).filter(function (n) { return selected[n]; });
3995
+ if (!names.length) return;
3996
+ shareFiles(names);
3997
+ });
3998
+ $('batchDownload').addEventListener('click', function () {
3999
+ var names = Object.keys(selected).filter(function (n) { return selected[n]; });
4000
+ if (!names.length) return;
4001
+ // 多个文件打成一个 zip 由服务端流式打包,浏览器只需下载一次
4002
+ if (names.length === 1) {
4003
+ downloadFile(names[0]);
4004
+ return;
4005
+ }
4006
+ downloadZip(names);
4007
+ });
4008
+ // 批量移动到目录
4009
+ $('batchMove').addEventListener('click', function () {
4010
+ var names = Object.keys(selected).filter(function (n) { return selected[n]; });
4011
+ if (!names.length) return;
4012
+ openMoveDialog(names);
4013
+ });
4014
+ // 批量重命名
4015
+ $('batchRename').addEventListener('click', function () {
4016
+ var names = Object.keys(selected).filter(function (n) { return selected[n]; });
4017
+ if (!names.length) return;
4018
+ openBatchRenameDialog(names);
4019
+ });
4020
+ $('batchDelete').addEventListener('click', function () {
4021
+ var names = Object.keys(selected).filter(function (n) { return selected[n]; });
4022
+ if (!names.length) return;
4023
+ if (!window.confirm('确定删除选中的 ' + names.length + ' 个文件?删除后可在回收站还原。')) return;
4024
+ toast('正在删除 ' + names.length + ' 个文件');
4025
+ var total = names.length;
4026
+ var done = 0;
4027
+ var failed = 0;
4028
+ // 记录成功删除的条目 ID,供撤销使用
4029
+ var trashIds = [];
4030
+ function next() {
4031
+ if (done >= total) {
4032
+ selected = {};
4033
+ refreshAll();
4034
+ refreshTrashCount();
4035
+ if (failed) {
4036
+ toast('已完成 ' + (total - failed) + '/' + total + ',' + failed + ' 个失败', 'err');
4037
+ } else if (trashIds.length) {
4038
+ toast('已删除 ' + total + ' 个文件', 'ok', {
4039
+ label: '撤销',
4040
+ onClick: function () { restoreAll(trashIds); },
4041
+ });
4042
+ } else {
4043
+ toast('已删除 ' + total + ' 个文件', 'ok');
4044
+ }
4045
+ return;
4046
+ }
4047
+ apiFetch(API + '/delete/' + encodeURIComponent(names[done]), { method: 'DELETE' })
4048
+ .then(function (r) { return r.json(); })
4049
+ .then(function (j) {
4050
+ if (j.code !== 0) failed++;
4051
+ else if (j.data && j.data.id) trashIds.push(j.data.id);
4052
+ done++;
4053
+ next();
4054
+ })
4055
+ .catch(function () { failed++; done++; next(); });
4056
+ }
4057
+ next();
4058
+ });
4059
+
4060
+ /** 依次还原多个回收站条目 */
4061
+ function restoreAll(ids) {
4062
+ if (!ids || !ids.length) return;
4063
+ var i = 0;
4064
+ var ok = 0;
4065
+ var failed = 0;
4066
+ function next() {
4067
+ if (i >= ids.length) {
4068
+ refreshAll();
4069
+ refreshTrashCount();
4070
+ if (failed) toast('已还原 ' + ok + '/' + ids.length + ',' + failed + ' 个失败', 'err');
4071
+ else toast('已还原 ' + ok + ' 个文件', 'ok');
4072
+ return;
4073
+ }
4074
+ restoreTrashEntry(ids[i], function (success) {
4075
+ if (success) ok++; else failed++;
4076
+ i++;
4077
+ next();
4078
+ });
4079
+ }
4080
+ next();
4081
+ }
4082
+
4083
+ // 恢复上次选择的排序方式与升降序
4084
+ $('sortSelect').value = sortType;
4085
+ $('orderBtn').textContent = sortOrder === 'desc' ? '↓ 降序' : '↑ 升序';
4086
+ $('pageSizeSelect').value = String(PAGE_SIZE);
4087
+
4088
+ /**
4089
+ * 身份确认之后,开始加载数据并订阅事件。
4090
+ *
4091
+ * 需要访问令牌时先不加载:否则一堆接口都会拿到 401,
4092
+ * 事件流也会自动重连,很快就把频率限制打满。
4093
+ */
4094
+ function startApp() {
4095
+ // 认证还没恢复时不要拉数据、不要订阅事件
4096
+ if (authBlocked) return;
4097
+ loadFiles();
4098
+ applyRole();
4099
+ loadFacets();
4100
+ refreshTrashCount();
4101
+ refreshShareCount();
4102
+ updateInboxBadge();
4103
+ connectEvents();
4104
+ }
4105
+
4106
+ // 认证失败由统一流程处理(提示重新认证 + 停止一切请求),
4107
+ // 这里把未被接住的认证失败吞掉,避免控制台反复报红
4108
+ window.addEventListener('unhandledrejection', function (e) {
4109
+ if (e.reason && e.reason.authFailed) e.preventDefault();
4110
+ });
4111
+
4112
+ // 先取身份再渲染列表,保证按钮的显示与当前权限一致
4113
+ refreshSession().then(function (ok) {
4114
+ if (ok) startApp();
4115
+ });
4116
+ // 候选访问地址与二维码:独立于认证,页面一打开就准备好
4117
+ loadNetworkInfo();
4118
+ // HTTP 下的能力降级说明:不解释的话,用户只会认为「功能坏了」
4119
+ showInsecureTip();
4120
+
4121
+ // 注册 Service Worker,提供离线可用的页面外壳
4122
+ // 仅在安全上下文可用(https 或 localhost);局域网 http 下浏览器会拒绝注册
4123
+ if ('serviceWorker' in navigator && window.isSecureContext) {
4124
+ window.addEventListener('load', function () {
4125
+ var swUrl = '/localsend/sw.js';
4126
+ navigator.serviceWorker.register(swUrl).catch(function () {
4127
+ // 注册失败不影响正常使用,静默忽略
4128
+ });
4129
+ });
4130
+ }
4131
+ })();