BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

test
timfa Tim Falken · pushed by timfa · 6 months ago
2c0e0fdd History
app.js 165.2 KiB Download Raw
1/* =========================================================
2 FILE MANAGER — CLIENT SPA
3 =========================================================
4 Architecture:
5 - RSA-OAEP + AES-256-GCM hybrid encryption via Web Crypto API
6 - Token is stored in localStorage to survive full page refresh
7 - Token is sent as Bearer header on every API call
8 - Fingerprint (derived from navigator info) locks the token to this browser
9 ========================================================= */
10'use strict';
11
12// ───────────────────────────────────────────────────────────────────────────
13// STATE
14// ───────────────────────────────────────────────────────────────────────────
15const STATE = {
16 token: null, // decrypted JWT string
17 username: null,
18 isAdmin: false,
19 permissions: {},
20 roots: [], // [{ label, path }]
21 currentDir: null, // absolute path currently shown (null = roots view)
22 currentRoot: null, // { label, path } of the active root
23 items: [], // current directory listing
24 selectedItem: null, // item object selected in sidebar
25
26 // Ephemeral key pair per session (client-side)
27 clientPrivateKey: null,
28 clientPublicKeyJwk: null,
29
30 // Server public key for encrypting login
31 serverPublicKeyJwk: null,
32
33 // Stable per-browser binding id used in fingerprint derivation
34 clientBindingId: null,
35
36 // Persisted view state
37 restoreDir: null,
38 restoreRootPath: null,
39 lastOperationAt: null,
40
41 // Background refresh state
42 autoRefreshTimer: null,
43 uploadInProgress: false,
44 // Blob URLs for thumbnail previews — revoked on each grid rebuild
45 thumbnailUrls: [],
46 thumbnailObserver: null,
47 folderIconObserver: null,
48
49 // Preview overlay state
50 previewObjectUrl: null,
51 previewCleanup: null,
52 previewDownloadAction: null,
53 previewVideoStreamSessionId: null,
54 previewSourceEl: null, // SVG element that triggered the preview
55 previewClosing: false, // guard to prevent double-close during animation
56 previewExpandState: null, // in-place expanded tile preview state
57 movePicker: null,
58
59 // Sidebar async loading guard to prevent stale updates on rapid selection changes.
60 sidebarLoadId: 0,
61 sidebarAbortController: null,
62
63 // Watched overlays are resolved asynchronously from /files/meta responses.
64 watchedStatusByPath: {},
65 watchedLoadId: 0,
66};
67
68const SESSION_KEY = 'filemanager.session.v1';
69const SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
70const CLIENT_BINDING_KEY = 'filemanager.client-binding-id.v1';
71const MOBILE_BREAKPOINT_QUERY = '(max-width: 600px)';
72const MOBILE_LONG_PRESS_MS = 420;
73const MOBILE_LONG_PRESS_MOVE_THRESHOLD = 10;
74const THUMB_OBSERVER_ROOT_MARGIN = '120px';
75const VIDEO_PREFS_KEY_PREFIX = 'filemanager.video-prefs.v1.';
76const VIDEO_TEXT_TRACK_SETTINGS_KEY = 'vjs-text-track-settings';
77const VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW = JSON.stringify({
78 backgroundOpacity: '0',
79 edgeStyle: 'uniform',
80});
81const VIDEO_FORWARD_BUFFER_SECONDS = 60 * 60;
82const VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED = false;
83let videoJsLoaderPromise = null;
84let threePreviewModulesPromise = null;
85
86// ───────────────────────────────────────────────────────────────────────────
87// CRYPTO HELPERS (Web Crypto API)
88// ───────────────────────────────────────────────────────────────────────────
89
90async function generateClientKeyPair ()
91{
92 if (!hasWebCrypto()) return;
93 const kp = await crypto.subtle.generateKey(
94 { name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
95 true,
96 ['encrypt', 'decrypt'],
97 );
98 STATE.clientPrivateKey = kp.privateKey;
99 STATE.clientPublicKeyJwk = await crypto.subtle.exportKey('jwk', kp.publicKey);
100}
101
102/**
103 * Hybrid-encrypt a JS object using the server's RSA public key.
104 * Returns { encryptedKey, iv, ciphertext, tag } all as base64 strings.
105 */
106async function hybridEncryptForServer (obj)
107{
108 if (!hasWebCrypto() || !STATE.serverPublicKeyJwk)
109 {
110 return { plaintext: obj };
111 }
112
113 const serverPub = await crypto.subtle.importKey(
114 'jwk', STATE.serverPublicKeyJwk,
115 { name: 'RSA-OAEP', hash: 'SHA-256' },
116 false, ['encrypt'],
117 );
118
119 const plaintext = new TextEncoder().encode(JSON.stringify(obj));
120 const aesKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
121 const iv = crypto.getRandomValues(new Uint8Array(12));
122 const gcmResult = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, aesKey, plaintext);
123
124 // gcmResult = ciphertext || tag (last 16 bytes are auth tag)
125 const gcmBytes = new Uint8Array(gcmResult);
126 const ciphertext = gcmBytes.slice(0, gcmBytes.length - 16);
127 const tag = gcmBytes.slice(gcmBytes.length - 16);
128
129 const rawAes = await crypto.subtle.exportKey('raw', aesKey);
130 const encryptedKey = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, serverPub, rawAes);
131
132 return {
133 encryptedKey: b64(encryptedKey),
134 iv: b64(iv),
135 ciphertext: b64(ciphertext),
136 tag: b64(tag),
137 };
138}
139
140/**
141 * Hybrid-decrypt a payload encrypted by the server for us (using our public key).
142 */
143async function hybridDecryptFromServer (payload)
144{
145 if (!payload) return null;
146 if (payload.token) return payload.token;
147 if (!hasWebCrypto()) return null;
148
149 const encryptedKey = unb64(payload.encryptedKey);
150 const iv = unb64(payload.iv);
151 const ciphertext = unb64(payload.ciphertext);
152 const tag = unb64(payload.tag);
153
154 const rawAes = await crypto.subtle.decrypt(
155 { name: 'RSA-OAEP' }, STATE.clientPrivateKey, encryptedKey,
156 );
157
158 const aesKey = await crypto.subtle.importKey('raw', rawAes, { name: 'AES-GCM' }, false, ['decrypt']);
159
160 // Recombine ciphertext + tag for AES-GCM
161 const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
162 combined.set(new Uint8Array(ciphertext));
163 combined.set(new Uint8Array(tag), ciphertext.byteLength);
164
165 const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, aesKey, combined);
166 return new TextDecoder().decode(plain);
167}
168
169// ───────────────────────────────────────────────────────────────────────────
170// UTIL
171// ───────────────────────────────────────────────────────────────────────────
172
173function b64 (buf)
174{
175 return btoa(String.fromCharCode(...new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer)));
176}
177
178function hasWebCrypto ()
179{
180 return !!(window.crypto && window.crypto.subtle);
181}
182
183function unb64 (str)
184{
185 const binary = atob(str);
186 const buf = new Uint8Array(binary.length);
187 for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
188 return buf.buffer;
189}
190
191/** Stable browser fingerprint (not stored, derived fresh each load) */
192function getFingerprint ()
193{
194 const binding = getOrCreateClientBindingId();
195 const nav = navigator;
196
197 // Keep this stable: avoid viewport/screen metrics that can change when
198 // devtools opens, orientation changes, or window state changes.
199 return [
200 binding,
201 nav.userAgent || '',
202 nav.language,
203 nav.platform || nav.userAgentData?.platform || '',
204 Intl.DateTimeFormat().resolvedOptions().timeZone,
205 ].join('|');
206}
207
208function randomIdHex (bytes = 16)
209{
210 const arr = new Uint8Array(bytes);
211 if (window.crypto && typeof window.crypto.getRandomValues === 'function')
212 {
213 window.crypto.getRandomValues(arr);
214 } else
215 {
216 for (let i = 0; i < arr.length; i++) arr[i] = Math.floor(Math.random() * 256);
217 }
218 return Array.from(arr).map(n => n.toString(16).padStart(2, '0')).join('');
219}
220
221function userVideoPrefsKey ()
222{
223 const name = String(STATE.username || 'anonymous').trim().toLowerCase() || 'anonymous';
224 return VIDEO_PREFS_KEY_PREFIX + name;
225}
226
227function loadUserVideoPrefs ()
228{
229 try
230 {
231 const raw = localStorage.getItem(userVideoPrefsKey());
232 const parsed = raw ? JSON.parse(raw) : {};
233 if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
234 return parsed;
235 } catch
236 {
237 return {};
238 }
239}
240
241function saveUserVideoPrefs (patch)
242{
243 try
244 {
245 const current = loadUserVideoPrefs();
246 localStorage.setItem(userVideoPrefsKey(), JSON.stringify({ ...current, ...(patch || {}) }));
247 } catch
248 {
249 // Ignore localStorage failures.
250 }
251}
252
253function applyUserVideoTextTrackPrefs ()
254{
255 try
256 {
257 // Only override the two requested defaults and leave other settings at Video.js defaults.
258 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
259 } catch
260 {
261 // Ignore localStorage failures.
262 }
263}
264
265function normaliseTrackName (name)
266{
267 return String(name || '').trim().toLowerCase();
268}
269
270function getTrackName (track)
271{
272 if (!track || typeof track !== 'object') return '';
273 const label = String(track.label || '').trim();
274 if (label) return label;
275 const name = String(track.name || '').trim();
276 if (name) return name;
277 const language = String(track.language || '').trim();
278 if (language) return language;
279 const id = String(track.id || '').trim();
280 if (id) return id;
281 return '';
282}
283
284function trackListToArray (trackList)
285{
286 if (!trackList || typeof trackList.length !== 'number') return [];
287 const out = [];
288 for (let i = 0; i < trackList.length; i++)
289 {
290 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
291 if (track) out.push(track);
292 }
293 return out;
294}
295
296function subtitleTracksFromPlayer (player)
297{
298 if (!player || typeof player.textTracks !== 'function') return [];
299 return trackListToArray(player.textTracks()).filter((track) =>
300 {
301 const kind = String(track.kind || '').toLowerCase();
302 return kind === 'subtitles' || kind === 'captions';
303 });
304}
305
306function audioTracksFromPlayer (player)
307{
308 if (!player || typeof player.audioTracks !== 'function') return [];
309 return trackListToArray(player.audioTracks());
310}
311
312function applySavedSubtitleTrack (player, savedName)
313{
314 if (typeof savedName !== 'string') return;
315 const tracks = subtitleTracksFromPlayer(player);
316 if (!tracks.length) return;
317
318 const wanted = normaliseTrackName(savedName);
319 if (!wanted)
320 {
321 for (const track of tracks) track.mode = 'disabled';
322 return;
323 }
324
325 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
326 if (!match) return;
327
328 for (const track of tracks)
329 {
330 track.mode = track === match ? 'showing' : 'disabled';
331 }
332}
333
334function applySavedAudioTrack (player, savedName)
335{
336 if (typeof savedName !== 'string') return;
337 const tracks = audioTracksFromPlayer(player);
338 if (!tracks.length) return;
339
340 const wanted = normaliseTrackName(savedName);
341 if (!wanted) return;
342
343 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
344 if (!match) return;
345
346 for (const track of tracks)
347 {
348 track.enabled = track === match;
349 }
350}
351
352function getSelectedSubtitleTrackName (player)
353{
354 const tracks = subtitleTracksFromPlayer(player);
355 if (!tracks.length) return null;
356 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
357 return active ? getTrackName(active) : '';
358}
359
360function getSelectedAudioTrackName (player)
361{
362 const tracks = audioTracksFromPlayer(player);
363 if (!tracks.length) return null;
364 const active = tracks.find((track) => !!track.enabled);
365 return active ? getTrackName(active) : '';
366}
367
368function bindUserVideoTrackPrefs (player, prefs)
369{
370 const applySavedTracks = () =>
371 {
372 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
373 applySavedAudioTrack(player, prefs.audioTrackName);
374 };
375
376 const captureSelectedTracks = () =>
377 {
378 const subtitleTrackName = getSelectedSubtitleTrackName(player);
379 const audioTrackName = getSelectedAudioTrackName(player);
380 const patch = {};
381
382 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
383 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
384
385 if (Object.keys(patch).length) saveUserVideoPrefs(patch);
386 };
387
388 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
389 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
390 const onTrackListChange = () => captureSelectedTracks();
391
392 if (textTrackList && typeof textTrackList.addEventListener === 'function')
393 {
394 textTrackList.addEventListener('change', onTrackListChange);
395 }
396
397 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
398 {
399 audioTrackList.addEventListener('change', onTrackListChange);
400 }
401
402 return {
403 applySavedTracks,
404 captureSelectedTracks,
405 detach: () =>
406 {
407 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
408 {
409 textTrackList.removeEventListener('change', onTrackListChange);
410 }
411 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
412 {
413 audioTrackList.removeEventListener('change', onTrackListChange);
414 }
415 },
416 };
417}
418
419function normaliseVideoDuration (player, durationSeconds)
420{
421 const duration = Number(durationSeconds);
422 if (!player || !Number.isFinite(duration) || duration <= 0) return;
423
424 let originalDuration = null;
425 let durationWasChanged = false;
426 try
427 {
428 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
429 installDurationFallback(player, originalDuration, duration);
430 if (player.__filemanagerDurationApplied) return;
431
432 const current = originalDuration ? Number(originalDuration()) : NaN;
433 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
434 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
435 if (withinTolerance)
436 {
437 player.__filemanagerDurationApplied = true;
438 return;
439 }
440
441 if (originalDuration)
442 {
443 durationWasChanged = true;
444 originalDuration(duration);
445 }
446 } catch
447 {
448 // Ignore players that do not support setting duration.
449 }
450
451 try
452 {
453 const updated = originalDuration ? Number(originalDuration()) : NaN;
454 if (Number.isFinite(updated) && updated >= duration * 0.95)
455 {
456 player.__filemanagerDurationApplied = true;
457 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
458 return;
459 }
460
461 player.__filemanagerDurationApplied = true;
462 if (typeof player.trigger === 'function') player.trigger('durationchange');
463 } catch
464 {
465 // Ignore duration fallback failures.
466 }
467}
468
469function installDurationFallback (player, originalDuration, duration)
470{
471 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
472
473 player.__filemanagerDurationFallback = true;
474 player.duration = function durationWithFallback (...args)
475 {
476 if (args.length) return originalDuration(...args);
477 const current = Number(originalDuration());
478 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
479 };
480}
481
482function formatDurationForDebug (seconds)
483{
484 const value = Number(seconds);
485 if (!Number.isFinite(value) || value < 0) return 'unknown';
486
487 const totalSeconds = Math.floor(value);
488 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
489 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
490 const ss = String(totalSeconds % 60).padStart(2, '0');
491 return `${hh}:${mm}:${ss}`;
492}
493
494function ensureVideoPlaybackUi (player, durationSeconds)
495{
496 if (!player || typeof player.on !== 'function') return;
497
498 const forceVodUi = () =>
499 {
500 normaliseVideoDuration(player, durationSeconds);
501
502 try
503 {
504 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
505 {
506 player.liveTracker.stopTracking();
507 }
508 } catch
509 {
510 // Ignore live tracker availability issues.
511 }
512
513 try
514 {
515 if (typeof player.removeClass === 'function')
516 {
517 player.removeClass('vjs-live');
518 }
519 } catch
520 {
521 // Ignore class update failures.
522 }
523
524 try
525 {
526 const display = player.el() && player.el().querySelector('.vjs-live-display');
527 if (display) display.style.display = 'none';
528 } catch
529 {
530 // Ignore missing DOM.
531 }
532 };
533
534 player.ready(forceVodUi);
535 player.on('loadedmetadata', forceVodUi);
536 player.on('durationchange', forceVodUi);
537 player.on('loadedplaylist', forceVodUi);
538}
539
540async function reportWatchProgress (filePath, progress)
541{
542 if (!filePath || !Number.isFinite(progress)) return;
543 await api('POST', '/files/watch-progress', {
544 filePath,
545 progress,
546 }).catch(() => null);
547
548 const nextStatus = progress >= 0.7 ? 'fully' : progress >= 0.1 ? 'partway' : null;
549 if (!nextStatus) return;
550
551 const prev = STATE.watchedStatusByPath[filePath];
552 if (prev === 'fully') return;
553 STATE.watchedStatusByPath[filePath] = nextStatus;
554
555 const iconEl = findTileIconByPath(filePath);
556 renderWatchedOverlayOnIcon(iconEl, nextStatus);
557}
558
559function getOrCreateClientBindingId ()
560{
561 if (STATE.clientBindingId) return STATE.clientBindingId;
562
563 try
564 {
565 const existing = localStorage.getItem(CLIENT_BINDING_KEY);
566 if (existing && typeof existing === 'string')
567 {
568 STATE.clientBindingId = existing;
569 return existing;
570 }
571 } catch
572 {
573 // Ignore storage read errors.
574 }
575
576 const created = randomIdHex(16);
577 STATE.clientBindingId = created;
578
579 try
580 {
581 localStorage.setItem(CLIENT_BINDING_KEY, created);
582 } catch
583 {
584 // Ignore storage write errors; in-memory fallback still keeps this stable
585 // for the current page session.
586 }
587
588 return created;
589}
590
591function formatBytes (bytes)
592{
593 if (bytes == null) return '—';
594 if (bytes < 1024) return bytes + ' B';
595 if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
596 if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
597 return (bytes / 1073741824).toFixed(2) + ' GB';
598}
599
600function parseHumanSize (input)
601{
602 const raw = String(input || '').trim();
603 if (!raw) return null;
604
605 const m = raw.match(/^(\d+(?:\.\d+)?)\s*([kmgt]?)(?:i?b)?$/i);
606 if (!m) return null;
607
608 const value = Number(m[1]);
609 if (!Number.isFinite(value) || value <= 0) return null;
610
611 const unit = String(m[2] || '').toLowerCase();
612 const multipliers = {
613 '': 1,
614 k: 1024,
615 m: 1024 * 1024,
616 g: 1024 * 1024 * 1024,
617 t: 1024 * 1024 * 1024 * 1024,
618 };
619 return Math.floor(value * (multipliers[unit] || 1));
620}
621
622function updateAdminSizeFeedback (rawValue)
623{
624 const feedback = document.getElementById('admin-user-size-feedback');
625 if (!feedback) return { bytes: null, valid: true };
626
627 const trimmed = String(rawValue || '').trim();
628 if (!trimmed)
629 {
630 feedback.textContent = '';
631 feedback.classList.add('hidden');
632 feedback.classList.remove('ok', 'err');
633 return { bytes: null, valid: true };
634 }
635
636 const bytes = parseHumanSize(trimmed);
637 feedback.classList.remove('hidden', 'ok', 'err');
638 if (bytes == null)
639 {
640 feedback.textContent = 'Invalid size. Use formats like 25 MB, 1 GB, or 500 KB.';
641 feedback.classList.add('err');
642 return { bytes: null, valid: false };
643 }
644
645 feedback.textContent = `Valid size: ${formatBytes(bytes)}`;
646 feedback.classList.add('ok');
647 return { bytes, valid: true };
648}
649
650function extOf (name)
651{
652 const i = name.lastIndexOf('.');
653 return i >= 0 ? name.slice(i + 1).toLowerCase() : '';
654}
655
656function getPathSep (basePath)
657{
658 return basePath && basePath.includes('\\') ? '\\' : '/';
659}
660
661function joinServerPath (basePath, segment)
662{
663 const sep = getPathSep(basePath);
664 const base = String(basePath || '').replace(/[\\/]+$/, '');
665 return base + sep + segment;
666}
667
668function samePath (a, b)
669{
670 if (!a || !b) return false;
671 return String(a).toLowerCase() === String(b).toLowerCase();
672}
673
674function pathInside (child, root)
675{
676 if (!child || !root) return false;
677 if (samePath(child, root)) return true;
678 const sep = getPathSep(root);
679 return String(child).toLowerCase().startsWith((String(root) + sep).toLowerCase());
680}
681
682function relativePathFromRoot (targetPath, rootPath)
683{
684 if (!targetPath || !rootPath) return String(targetPath || '');
685 if (samePath(targetPath, rootPath)) return '.';
686
687 const prefix = String(rootPath).replace(/[\\/]+$/, '');
688 const rel = String(targetPath).slice(prefix.length).replace(/^[\\/]+/, '');
689 if (!rel) return '.';
690 return rel;
691}
692
693function displayPathWithRootLabel (targetPath, rootPath, rootLabel)
694{
695 const rel = relativePathFromRoot(targetPath, rootPath);
696 const safeRoot = String(rootLabel || '').replace(/^\/+|\/+$/g, '');
697 if (!safeRoot) return '/';
698 if (rel === '.') return `/${safeRoot}`;
699 return `/${safeRoot}/${String(rel).replace(/\\/g, '/')}`;
700}
701
702function splitNameExt (name)
703{
704 const dot = String(name || '').lastIndexOf('.');
705 if (dot <= 0) return { stem: String(name || ''), ext: '' };
706 return {
707 stem: String(name).slice(0, dot),
708 ext: String(name).slice(dot),
709 };
710}
711
712function nextAvailableName (requestedName, existingNames)
713{
714 const set = existingNames instanceof Set ? existingNames : new Set(existingNames || []);
715 if (!set.has(requestedName)) return requestedName;
716
717 const { stem, ext } = splitNameExt(requestedName);
718 let n = 1;
719 while (n <= 10000)
720 {
721 const candidate = `${stem || 'file'} (${n})${ext}`;
722 if (!set.has(candidate)) return candidate;
723 n++;
724 }
725
726 return requestedName;
727}
728
729async function listDirNameSet (dir)
730{
731 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dir)}`);
732 const names = new Set();
733 for (const it of ((data && data.items) || [])) names.add(it.name);
734 return names;
735}
736
737function cloneFileWithName (file, newName)
738{
739 return new File([file], newName, {
740 type: file.type,
741 lastModified: file.lastModified,
742 });
743}
744
745function saveSessionState ()
746{
747 if (!STATE.token) return;
748 const now = Date.now();
749 STATE.lastOperationAt = now;
750 const payload = {
751 token: STATE.token,
752 dir: STATE.currentDir || null,
753 rootPath: STATE.currentRoot ? STATE.currentRoot.path : null,
754 lastOperationAt: STATE.lastOperationAt,
755 };
756 try
757 {
758 localStorage.setItem(SESSION_KEY, JSON.stringify(payload));
759 } catch
760 {
761 // Ignore storage errors (private mode/full quota).
762 }
763}
764
765function loadSessionState ()
766{
767 try
768 {
769 const raw = localStorage.getItem(SESSION_KEY);
770 if (!raw) return null;
771 const parsed = JSON.parse(raw);
772 if (!parsed || typeof parsed.token !== 'string') return null;
773 if (!Number.isFinite(parsed.lastOperationAt)) return null;
774
775 if (Date.now() - parsed.lastOperationAt > SESSION_IDLE_TIMEOUT_MS)
776 {
777 clearSessionState();
778 return null;
779 }
780
781 return parsed;
782 } catch
783 {
784 return null;
785 }
786}
787
788function clearSessionState ()
789{
790 try { localStorage.removeItem(SESSION_KEY); } catch { /* ignore */ }
791}
792
793// ───────────────────────────────────────────────────────────────────────────
794// API
795// ───────────────────────────────────────────────────────────────────────────
796
797async function api (method, path, body, opts = {})
798{
799 const headers = { 'Content-Type': 'application/json' };
800 const noAutoLogout = !!opts.noAutoLogout;
801 if (STATE.token)
802 {
803 headers['Authorization'] = 'Bearer ' + STATE.token;
804 try
805 {
806 const fp = getFingerprint();
807 if (fp) headers['X-Fp'] = fp;
808 } catch
809 {
810 // Continue without a fingerprint header in constrained test/runtime contexts.
811 }
812 }
813 const fetchOpts = { ...opts };
814 delete fetchOpts.noAutoLogout;
815 const res = await fetch('/api' + path, {
816 method,
817 headers,
818 body: body != null ? JSON.stringify(body) : undefined,
819 ...fetchOpts,
820 });
821 if (!res.ok)
822 {
823 const j = await res.json().catch(() => ({}));
824 // Session-expired → force re-login
825 if (res.status === 401)
826 {
827 if (!noAutoLogout) logout();
828 return null;
829 }
830 throw new Error(j.error || res.statusText);
831 }
832 if (STATE.token && !path.startsWith('/auth/server-key') && !path.startsWith('/auth/setup-needed'))
833 {
834 saveSessionState();
835 }
836 return res.json();
837}
838
839// ───────────────────────────────────────────────────────────────────────────
840// TOAST
841// ───────────────────────────────────────────────────────────────────────────
842
843function toast (msg, type = '')
844{
845 const el = document.createElement('div');
846 el.className = 'toast-msg' + (type ? ' ' + type : '');
847 el.textContent = msg;
848 document.getElementById('toast').appendChild(el);
849 setTimeout(() => el.remove(), 3500);
850}
851
852// ───────────────────────────────────────────────────────────────────────────
853// DIALOG MODALS — centralised replacements for alert / confirm / prompt
854// ───────────────────────────────────────────────────────────────────────────
855
856/**
857 * Show a confirmation dialog.
858 * @param {string} title
859 * @param {string} message
860 * @returns {Promise<boolean>} true = OK, false = Cancel
861 */
862function showConfirm (title, message, { html = false, okLabel = null } = {})
863{
864 return new Promise((resolve) =>
865 {
866 const overlay = document.getElementById('confirm-modal');
867 document.getElementById('confirm-modal-title').textContent = title;
868 const msgEl = document.getElementById('confirm-modal-message');
869 if (html) msgEl.innerHTML = message;
870 else msgEl.textContent = message;
871 overlay.classList.remove('hidden');
872
873 const ok = document.getElementById('confirm-modal-ok');
874 const prevOkLabel = ok.textContent;
875 if (okLabel != null) ok.textContent = okLabel;
876
877 const cancel = document.getElementById('confirm-modal-cancel');
878
879 function finish (result)
880 {
881 overlay.classList.add('hidden');
882 ok.textContent = prevOkLabel;
883 ok.removeEventListener('click', onOk);
884 cancel.removeEventListener('click', onCancel);
885 resolve(result);
886 }
887 function onOk () { finish(true); }
888 function onCancel () { finish(false); }
889
890 ok.addEventListener('click', onOk);
891 cancel.addEventListener('click', onCancel);
892 ok.focus();
893 });
894}
895
896function escHtml (s)
897{
898 return String(s || '')
899 .replace(/&/g, '&amp;')
900 .replace(/</g, '&lt;')
901 .replace(/>/g, '&gt;')
902 .replace(/"/g, '&quot;');
903}
904
905/**
906 * Show a text-input dialog.
907 * @param {string} title
908 * @param {string} [message] — optional helper text shown above the input
909 * @param {string} [defaultValue] — pre-filled value
910 * @returns {Promise<string|null>} string = submitted value, null = cancelled
911 */
912function showPrompt (title, message = '', defaultValue = '')
913{
914 return new Promise((resolve) =>
915 {
916 const overlay = document.getElementById('prompt-modal');
917 const msgEl = document.getElementById('prompt-modal-message');
918 const input = document.getElementById('prompt-modal-input');
919 const errorEl = document.getElementById('prompt-modal-error');
920 const form = document.getElementById('prompt-modal-form');
921 const cancel = document.getElementById('prompt-modal-cancel');
922
923 document.getElementById('prompt-modal-title').textContent = title;
924 msgEl.textContent = message;
925 msgEl.classList.toggle('hidden', !message);
926 input.value = defaultValue;
927 errorEl.classList.add('hidden');
928 overlay.classList.remove('hidden');
929 input.focus();
930 input.select();
931
932 function finish (result)
933 {
934 overlay.classList.add('hidden');
935 form.removeEventListener('submit', onSubmit);
936 cancel.removeEventListener('click', onCancel);
937 resolve(result);
938 }
939 function onSubmit (e)
940 {
941 e.preventDefault();
942 finish(input.value);
943 }
944 function onCancel () { finish(null); }
945
946 form.addEventListener('submit', onSubmit);
947 cancel.addEventListener('click', onCancel);
948 });
949}
950
951/**
952 * Show an overwrite-decision dialog for a single file conflict.
953 * @param {string} filename
954 * @returns {Promise<'yes'|'no'|'all'|'none'>}
955 */
956function showOverwrite (filename)
957{
958 return new Promise((resolve) =>
959 {
960 const overlay = document.getElementById('overwrite-modal');
961 document.getElementById('overwrite-modal-filename').textContent = filename;
962 overlay.classList.remove('hidden');
963
964 const btnYes = document.getElementById('overwrite-modal-yes');
965 const btnNo = document.getElementById('overwrite-modal-no');
966 const btnAll = document.getElementById('overwrite-modal-all');
967 const btnSkipAll = document.getElementById('overwrite-modal-skip-all');
968
969 function finish (result)
970 {
971 overlay.classList.add('hidden');
972 btnYes.removeEventListener('click', onYes);
973 btnNo.removeEventListener('click', onNo);
974 btnAll.removeEventListener('click', onAll);
975 btnSkipAll.removeEventListener('click', onSkipAll);
976 resolve(result);
977 }
978 function onYes () { finish('yes'); }
979 function onNo () { finish('no'); }
980 function onAll () { finish('all'); }
981 function onSkipAll () { finish('none'); }
982
983 btnYes.addEventListener('click', onYes);
984 btnNo.addEventListener('click', onNo);
985 btnAll.addEventListener('click', onAll);
986 btnSkipAll.addEventListener('click', onSkipAll);
987 btnNo.focus();
988 });
989}
990
991/**
992 * Show single-file conflict options.
993 * @param {string} filename
994 * @param {string} renameTo
995 * @param {string} mode - upload|move
996 * @returns {Promise<'overwrite'|'rename'|'cancel'>}
997 */
998function showFileConflictChoice (filename, renameTo, mode = 'upload')
999{
1000 return new Promise((resolve) =>
1001 {
1002 const overlay = document.getElementById('file-conflict-modal');
1003 const title = document.getElementById('file-conflict-title');
1004 const fileEl = document.getElementById('file-conflict-filename');
1005 const renameEl = document.getElementById('file-conflict-rename');
1006 const btnOverwrite = document.getElementById('file-conflict-overwrite');
1007 const btnRename = document.getElementById('file-conflict-rename-btn');
1008 const btnCancel = document.getElementById('file-conflict-cancel');
1009
1010 title.textContent = mode === 'move' ? 'Move file' : 'Upload file';
1011 fileEl.textContent = filename;
1012 renameEl.textContent = renameTo;
1013 btnRename.textContent = `Rename (${renameTo})`;
1014
1015 overlay.classList.remove('hidden');
1016
1017 function finish (result)
1018 {
1019 overlay.classList.add('hidden');
1020 btnOverwrite.removeEventListener('click', onOverwrite);
1021 btnRename.removeEventListener('click', onRename);
1022 btnCancel.removeEventListener('click', onCancel);
1023 resolve(result);
1024 }
1025
1026 function onOverwrite () { finish('overwrite'); }
1027 function onRename () { finish('rename'); }
1028 function onCancel () { finish('cancel'); }
1029
1030 btnOverwrite.addEventListener('click', onOverwrite);
1031 btnRename.addEventListener('click', onRename);
1032 btnCancel.addEventListener('click', onCancel);
1033 btnCancel.focus();
1034 });
1035}
1036
1037// ───────────────────────────────────────────────────────────────────────────
1038// SHARE MODAL
1039// ───────────────────────────────────────────────────────────────────────────
1040
1041async function openShareModal (item)
1042{
1043 const overlay = document.getElementById('share-modal');
1044 const urlInput = document.getElementById('share-url-input');
1045 const copyBtn = document.getElementById('share-copy-btn');
1046 const okBtn = document.getElementById('share-modal-ok');
1047 const closeBtn = document.getElementById('share-modal-close');
1048 const msgEl = document.getElementById('share-modal-msg');
1049
1050 urlInput.value = 'Creating link...';
1051 copyBtn.disabled = true;
1052 msgEl.textContent = 'This link is valid for 24 hours.';
1053 overlay.classList.remove('hidden');
1054
1055 let data;
1056 try
1057 {
1058 data = await api('POST', '/share/create', { filePath: item.path });
1059 } catch (err)
1060 {
1061 msgEl.textContent = 'Error: ' + (err.message || 'Could not create link.');
1062 urlInput.value = '';
1063 return;
1064 }
1065
1066 if (!data || !data.token)
1067 {
1068 msgEl.textContent = 'Unknown error while creating link.';
1069 urlInput.value = '';
1070 return;
1071 }
1072
1073 const shareUrl = `${location.origin}/share/${data.token}`;
1074 urlInput.value = shareUrl;
1075 copyBtn.disabled = false;
1076
1077 function close ()
1078 {
1079 overlay.classList.add('hidden');
1080 okBtn.removeEventListener('click', close);
1081 closeBtn.removeEventListener('click', close);
1082 copyBtn.removeEventListener('click', onCopy);
1083 }
1084
1085 function onCopy ()
1086 {
1087 navigator.clipboard.writeText(shareUrl).then(() =>
1088 {
1089 const orig = copyBtn.textContent;
1090 copyBtn.textContent = 'Copied!';
1091 setTimeout(() => { copyBtn.textContent = orig; }, 1500);
1092 }).catch(() =>
1093 {
1094 // Fallback: select the text
1095 urlInput.select();
1096 });
1097 }
1098
1099 okBtn.addEventListener('click', close);
1100 closeBtn.addEventListener('click', close);
1101 copyBtn.addEventListener('click', onCopy);
1102 okBtn.focus();
1103}
1104
1105// ───────────────────────────────────────────────────────────────────────────
1106// AUTH FLOW
1107// ───────────────────────────────────────────────────────────────────────────
1108
1109function showAuthOverlay (setupMode = false)
1110{
1111 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1112 document.getElementById('app').classList.add('hidden');
1113 const overlay = document.getElementById('auth-overlay');
1114 const usernameInput = document.getElementById('auth-username');
1115 const passwordInput = document.getElementById('auth-password');
1116 overlay.classList.remove('hidden');
1117 document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
1118 document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
1119 const submitBtn = document.getElementById('auth-submit');
1120 submitBtn.disabled = false;
1121 submitBtn.textContent = setupMode ? 'Create Account' : 'Sign In';
1122 document.getElementById('auth-error').classList.add('hidden');
1123 usernameInput.value = '';
1124 passwordInput.value = '';
1125 usernameInput.autocomplete = 'username';
1126 passwordInput.autocomplete = setupMode ? 'new-password' : 'current-password';
1127 usernameInput.focus();
1128 document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
1129}
1130
1131function showApp ()
1132{
1133 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1134 document.getElementById('auth-overlay').classList.add('hidden');
1135 document.getElementById('app').classList.remove('hidden');
1136 if (isMobileViewport())
1137 {
1138 hideSidebarPanel();
1139 } else
1140 {
1141 openFolderSidebar();
1142 }
1143 document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
1144 startAutoRefresh();
1145}
1146
1147async function initAuth ()
1148{
1149 // Generate a fresh key pair in the background; login falls back gracefully
1150 // while this is still in progress.
1151 generateClientKeyPair().catch(() =>
1152 {
1153 toast('Secure crypto unavailable in this browser context; using compatibility login mode.', 'err');
1154 });
1155
1156 // Fetch server public key
1157 const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
1158 if (publicKey) STATE.serverPublicKeyJwk = publicKey;
1159 if (!publicKey && hasWebCrypto()) { toast('Could not reach server.', 'err'); return; }
1160 STATE.serverPublicKeyJwk = publicKey;
1161
1162 // Check whether first-run setup is needed
1163 const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
1164
1165 if (!needed)
1166 {
1167 const saved = loadSessionState();
1168 if (saved && saved.token)
1169 {
1170 STATE.token = saved.token;
1171 STATE.restoreDir = saved.dir || null;
1172 STATE.restoreRootPath = saved.rootPath || null;
1173 STATE.lastOperationAt = saved.lastOperationAt;
1174
1175 const me = await api('GET', '/auth/me', null, { noAutoLogout: true }).catch(() => null);
1176 if (me)
1177 {
1178 STATE.username = me.username;
1179 STATE.isAdmin = me.isAdmin;
1180 STATE.permissions = me.permissions;
1181 showApp();
1182 await loadRoots({
1183 preferredDir: STATE.restoreDir,
1184 preferredRootPath: STATE.restoreRootPath,
1185 });
1186 return;
1187 }
1188
1189 STATE.token = null;
1190 clearSessionState();
1191 }
1192 }
1193
1194 showAuthOverlay(needed);
1195}
1196
1197async function doLogin (username, password, isSetup)
1198{
1199 const encrypted = await hybridEncryptForServer({ username, password });
1200 const endpoint = isSetup ? '/auth/setup' : '/auth/login';
1201
1202 let data;
1203 try
1204 {
1205 data = await api('POST', endpoint, {
1206 encrypted,
1207 clientPublicKey: STATE.clientPublicKeyJwk,
1208 fingerprint: getFingerprint(),
1209 });
1210 } catch (err)
1211 {
1212 return err.message;
1213 }
1214
1215 if (!data) return 'Login failed.';
1216
1217 // Decrypt the token sent back by the server
1218 const token = await hybridDecryptFromServer(data.encrypted || data);
1219 if (!token) return 'Login failed.';
1220 STATE.token = token;
1221
1222 // Load user info
1223 const me = await api('GET', '/auth/me');
1224 if (!me) return 'Session error.';
1225
1226 STATE.username = me.username;
1227 STATE.isAdmin = me.isAdmin;
1228 STATE.permissions = me.permissions;
1229
1230 saveSessionState();
1231 showApp();
1232 await loadRoots();
1233 return null; // no error
1234}
1235
1236function logout ()
1237{
1238 void performLogout();
1239}
1240
1241async function performLogout ()
1242{
1243 const tokenAtStart = STATE.token;
1244 stopAutoRefresh();
1245
1246 if (tokenAtStart)
1247 {
1248 try
1249 {
1250 await api('POST', '/auth/logout', {}, { noAutoLogout: true });
1251 } catch
1252 {
1253 // Ignore network errors while logging out locally.
1254 }
1255 }
1256
1257 STATE.token = null;
1258 STATE.username = null;
1259 STATE.isAdmin = false;
1260 STATE.permissions = {};
1261 STATE.currentDir = null;
1262 STATE.currentRoot = null;
1263 STATE.items = [];
1264 STATE.restoreDir = null;
1265 STATE.restoreRootPath = null;
1266 STATE.lastOperationAt = null;
1267 clearSessionState();
1268 closePreview({ force: true });
1269 closeSidebar();
1270 await initAuth();
1271}
1272
1273// ───────────────────────────────────────────────────────────────────────────
1274// NAVIGATION
1275// ───────────────────────────────────────────────────────────────────────────
1276
1277async function loadRoots (opts = {})
1278{
1279 const data = await api('GET', '/files/roots');
1280 if (!data) return;
1281 STATE.roots = data.roots;
1282
1283 const preferredDir = opts.preferredDir || null;
1284 const preferredRootPath = opts.preferredRootPath || null;
1285
1286 if (preferredDir && preferredRootPath)
1287 {
1288 const preferredRoot = STATE.roots.find(r => samePath(r.path, preferredRootPath));
1289 if (preferredRoot && pathInside(preferredDir, preferredRoot.path))
1290 {
1291 try
1292 {
1293 await navigateTo(preferredDir, preferredRoot, { keepSidebar: true });
1294 return;
1295 } catch
1296 {
1297 // Fall back to default root behavior.
1298 }
1299 }
1300 }
1301
1302 if (STATE.roots.length === 1)
1303 {
1304 // Single root → open it directly
1305 await navigateTo(STATE.roots[0].path, STATE.roots[0]);
1306 } else
1307 {
1308 renderRootsView();
1309 }
1310}
1311
1312function renderRootsView ()
1313{
1314 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1315 disconnectThumbnailObserver();
1316 disconnectFolderIconObserver();
1317 revokeThumbnails();
1318
1319 STATE.currentDir = null;
1320 STATE.currentRoot = null;
1321 saveSessionState();
1322 renderBreadcrumb();
1323 const grid = document.getElementById('file-grid');
1324 grid.innerHTML = '';
1325 document.getElementById('empty-notice').classList.add('hidden');
1326 document.getElementById('folder-stats').classList.add('hidden');
1327 closeSidebar();
1328
1329 for (const root of STATE.roots)
1330 {
1331 const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
1332 grid.appendChild(el);
1333 }
1334
1335 loadThumbnails();
1336}
1337
1338async function navigateTo (absPath, root, opts = {})
1339{
1340 if (root) STATE.currentRoot = root;
1341 STATE.currentDir = absPath;
1342
1343 const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
1344 if (!data) return;
1345
1346 STATE.items = data.items;
1347 saveSessionState();
1348 renderBreadcrumb();
1349 renderFileGrid();
1350 await refreshFolderStats();
1351 closeSidebar();
1352}
1353
1354function renderBreadcrumb ()
1355{
1356 if (typeof document === 'undefined') return;
1357 const nav = document.getElementById('breadcrumb');
1358 if (!nav) return;
1359 nav.innerHTML = '';
1360
1361 // "Home" crumb
1362 const home = document.createElement('span');
1363 home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
1364 home.textContent = 'Home';
1365 home.addEventListener('click', () =>
1366 {
1367 if (STATE.roots.length === 1)
1368 {
1369 navigateTo(STATE.roots[0].path, STATE.roots[0]);
1370 } else
1371 {
1372 renderRootsView();
1373 }
1374 });
1375 nav.appendChild(home);
1376
1377 if (!STATE.currentDir || !STATE.currentRoot) return;
1378
1379 // Build path segments relative to the root.
1380 const rootPath = STATE.currentRoot.path;
1381 const relative = relativePathFromRoot(STATE.currentDir, rootPath);
1382 const segments = relative === '.' ? [] : relative.split(/[\\/]/).filter(Boolean);
1383 const parts = [STATE.currentRoot.label, ...segments];
1384
1385 for (let i = 0; i < parts.length; i++)
1386 {
1387 const sep = document.createElement('span');
1388 sep.className = 'sep';
1389 sep.textContent = ' / ';
1390 nav.appendChild(sep);
1391
1392 const crumb = document.createElement('span');
1393 crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
1394 crumb.textContent = parts[i];
1395
1396 // Root crumb points to rootPath; segment crumbs point to their folder.
1397 const capturedPath = i === 0
1398 ? rootPath
1399 : joinServerPath(rootPath, segments.slice(0, i).join('/'));
1400 crumb.classList.add('crumb-drop-target');
1401 crumb.dataset.path = capturedPath;
1402 if (i < parts.length - 1)
1403 {
1404 crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
1405 }
1406
1407 nav.appendChild(crumb);
1408 }
1409}
1410
1411async function refreshFolderStats ()
1412{
1413 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1414 const el = document.getElementById('folder-stats');
1415 if (!STATE.currentDir)
1416 {
1417 el.classList.add('hidden');
1418 return;
1419 }
1420
1421 const data = await api('GET', `/files/space?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
1422 if (!data)
1423 {
1424 el.classList.add('hidden');
1425 return;
1426 }
1427
1428 const used = formatBytes(data.usedBytes);
1429 if (data.userFreeBytes != null)
1430 {
1431 el.textContent = `Folder usage: ${used} | Free space remaining: ${formatBytes(data.userFreeBytes)}`;
1432 } else
1433 {
1434 const free = data.freeBytes == null ? 'unknown' : formatBytes(data.freeBytes);
1435 el.textContent = `Folder usage: ${used} | Free on disk: ${free}`;
1436 }
1437 el.classList.remove('hidden');
1438}
1439
1440function itemsSignature (items)
1441{
1442 return JSON.stringify(
1443 (items || []).map(it => [it.path, it.mtime, it.size, it.isDir])
1444 .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
1445 );
1446}
1447
1448async function incrementalRefreshCurrentDir ()
1449{
1450 if (STATE.previewExpandState) return;
1451 if (!STATE.currentDir || STATE.uploadInProgress) return;
1452
1453 const data = await api('GET', `/files/list?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
1454 if (!data) return;
1455
1456 const oldSig = itemsSignature(STATE.items);
1457 const newSig = itemsSignature(data.items);
1458 if (oldSig !== newSig)
1459 {
1460 const selectedPath = STATE.selectedItem ? STATE.selectedItem.path : null;
1461 STATE.items = data.items;
1462 renderFileGrid();
1463
1464 if (selectedPath)
1465 {
1466 const match = STATE.items.find(i => i.path === selectedPath);
1467 if (match)
1468 {
1469 const selectedEl = Array.from(document.querySelectorAll('.file-item'))
1470 .find(el => el.dataset.path === selectedPath);
1471 if (selectedEl) selectItem(selectedEl, match);
1472 } else
1473 {
1474 closeSidebar();
1475 }
1476 }
1477 }
1478 else
1479 {
1480 loadThumbnails();
1481 void loadWatchedStatusesForCurrentDir();
1482 }
1483
1484 await refreshFolderStats();
1485}
1486
1487function startAutoRefresh ()
1488{
1489 stopAutoRefresh();
1490 STATE.autoRefreshTimer = setInterval(() =>
1491 {
1492 if (document.hidden) return;
1493 incrementalRefreshCurrentDir();
1494 }, 5000);
1495}
1496
1497function stopAutoRefresh ()
1498{
1499 if (STATE.autoRefreshTimer)
1500 {
1501 clearInterval(STATE.autoRefreshTimer);
1502 STATE.autoRefreshTimer = null;
1503 }
1504}
1505
1506// ───────────────────────────────────────────────────────────────────────────
1507// FILE GRID RENDERING
1508// ───────────────────────────────────────────────────────────────────────────
1509
1510function renderFileGrid ()
1511{
1512 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1513 disconnectThumbnailObserver();
1514 disconnectFolderIconObserver();
1515 revokeThumbnails();
1516 const grid = document.getElementById('file-grid');
1517 grid.innerHTML = '';
1518 const empty = document.getElementById('empty-notice');
1519
1520 const sorted = [...STATE.items].sort((a, b) =>
1521 {
1522 if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
1523 return a.name.localeCompare(b.name);
1524 });
1525
1526 empty.classList.toggle('hidden', sorted.length > 0);
1527
1528 for (const item of sorted)
1529 {
1530 grid.appendChild(makeFileItem(item));
1531 }
1532
1533 loadThumbnails();
1534 void loadWatchedStatusesForCurrentDir();
1535}
1536
1537function makeFileItem (item)
1538{
1539 const el = document.createElement('div');
1540 el.className = 'file-item';
1541 el.dataset.path = item.path;
1542 if (item.isDir) el.dataset.isdir = '1';
1543
1544 const icon = document.createElement('div');
1545 icon.className = 'icon';
1546 icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
1547 if (!item.isDir)
1548 {
1549 icon.dataset.previewPath = item.path;
1550 renderWatchedOverlayOnIcon(icon, watchStatusForTile(item));
1551 } else
1552 {
1553 icon.dataset.folderPath = item.path;
1554 }
1555 el.appendChild(icon);
1556
1557 const name = document.createElement('div');
1558 name.className = 'name';
1559 name.textContent = item.name;
1560 el.appendChild(name);
1561
1562 if (!item._root) makeDraggable(el, item);
1563 attachMobileLongPress(el, item);
1564
1565 el.addEventListener('contextmenu', (e) =>
1566 {
1567 if (!isMobileViewport()) return;
1568 e.preventDefault();
1569 e.stopPropagation();
1570 });
1571
1572 // Single-click: open sidebar
1573 el.addEventListener('click', (e) =>
1574 {
1575 e.stopPropagation();
1576 if (el.classList.contains('file-item--preview')) return;
1577 if (isMobileViewport())
1578 {
1579 if (el.dataset.longPressTriggered === '1')
1580 {
1581 el.dataset.longPressTriggered = '0';
1582 return;
1583 }
1584
1585 if (item.isDir)
1586 {
1587 navigateTo(item.path, item._root || STATE.currentRoot);
1588 } else
1589 {
1590 downloadOrView(item, icon.querySelector('svg'));
1591 }
1592 return;
1593 }
1594
1595 selectItem(el, item);
1596 });
1597
1598 // Double-click: enter folder or view/download file
1599 el.addEventListener('dblclick', (e) =>
1600 {
1601 e.stopPropagation();
1602 if (el.classList.contains('file-item--preview')) return;
1603 if (item.isDir)
1604 {
1605 navigateTo(item.path, item._root || STATE.currentRoot);
1606 } else
1607 {
1608 downloadOrView(item, icon.querySelector('svg'));
1609 }
1610 });
1611
1612 return el;
1613}
1614
1615function attachMobileLongPress (el, item)
1616{
1617 if (item._root) return;
1618
1619 let pressTimer = null;
1620 let startX = 0;
1621 let startY = 0;
1622
1623 function clearPress ()
1624 {
1625 if (!pressTimer) return;
1626 clearTimeout(pressTimer);
1627 pressTimer = null;
1628 }
1629
1630 function cancelPress ()
1631 {
1632 clearPress();
1633 }
1634
1635 el.addEventListener('pointerdown', (e) =>
1636 {
1637 if (!isMobileViewport()) return;
1638 if (e.button !== undefined && e.button !== 0) return;
1639 if (e.pointerType && e.pointerType === 'mouse') return;
1640
1641 startX = e.clientX;
1642 startY = e.clientY;
1643 clearPress();
1644
1645 pressTimer = setTimeout(() =>
1646 {
1647 pressTimer = null;
1648 el.dataset.longPressTriggered = '1';
1649 selectItem(el, item);
1650 }, MOBILE_LONG_PRESS_MS);
1651 });
1652
1653 el.addEventListener('pointermove', (e) =>
1654 {
1655 if (!pressTimer) return;
1656 if (Math.hypot(e.clientX - startX, e.clientY - startY) > MOBILE_LONG_PRESS_MOVE_THRESHOLD)
1657 {
1658 clearPress();
1659 }
1660 });
1661
1662 el.addEventListener('pointerup', cancelPress);
1663 el.addEventListener('pointercancel', cancelPress);
1664 el.addEventListener('pointerleave', cancelPress);
1665}
1666
1667function selectItem (el, item)
1668{
1669 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
1670 el.classList.add('selected');
1671 STATE.selectedItem = item;
1672 openSidebar(item);
1673}
1674
1675function isAbortError (err)
1676{
1677 if (!err) return false;
1678 return err.name === 'AbortError' || /abort/i.test(String(err.message || ''));
1679}
1680
1681function beginSidebarLoad ()
1682{
1683 if (STATE.sidebarAbortController && typeof STATE.sidebarAbortController.abort === 'function')
1684 {
1685 try { STATE.sidebarAbortController.abort(); } catch { /* ignore */ }
1686 }
1687
1688 STATE.sidebarLoadId += 1;
1689 STATE.sidebarAbortController = null;
1690
1691 return {
1692 id: STATE.sidebarLoadId,
1693 };
1694}
1695
1696function isSidebarLoadStale (item, sidebarLoadId)
1697{
1698 if (sidebarLoadId !== STATE.sidebarLoadId) return true;
1699 if (!STATE.selectedItem) return true;
1700 return STATE.selectedItem !== item && STATE.selectedItem.path !== item.path;
1701}
1702
1703// ───────────────────────────────────────────────────────────────────────────
1704// SIDEBAR
1705// ───────────────────────────────────────────────────────────────────────────
1706
1707/**
1708 * Renders (or clears) the duplicates panel at the bottom of the sidebar.
1709 * @param {object|null} item — the item whose duplicates are shown; null = clear
1710 * @param {Array|null} duplicates — array of {path, name, dir, relativePath}; null = loading state
1711 */
1712function renderSidebarDuplicates (item, duplicates)
1713{
1714 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1715 const panel = document.getElementById('sidebar-duplicates');
1716 if (!panel) return;
1717
1718 // Clear / hide when no item or no duplicates.
1719 if (!item || (Array.isArray(duplicates) && duplicates.length === 0))
1720 {
1721 panel.classList.add('hidden');
1722 panel.innerHTML = '';
1723 return;
1724 }
1725
1726 // Loading state.
1727 if (duplicates === null)
1728 {
1729 panel.classList.add('hidden');
1730 panel.innerHTML = '';
1731 return;
1732 }
1733
1734 panel.innerHTML = '';
1735 const heading = document.createElement('p');
1736 heading.className = 'sidebar-duplicates-heading';
1737 heading.textContent = `Duplicates (${duplicates.length})`;
1738 panel.appendChild(heading);
1739
1740 const list = document.createElement('ul');
1741 list.className = 'sidebar-duplicates-list';
1742
1743 for (const dup of duplicates)
1744 {
1745 const li = document.createElement('li');
1746 const btn = document.createElement('button');
1747 btn.className = 'sidebar-duplicate-entry';
1748 btn.title = dup.path;
1749 // Show path relative to its root; keep absolute path in the tooltip.
1750 btn.textContent = dup.relativePath || dup.path;
1751 btn.addEventListener('click', () => navigateToDuplicate(dup));
1752 li.appendChild(btn);
1753 list.appendChild(li);
1754 }
1755
1756 panel.appendChild(list);
1757 panel.classList.remove('hidden');
1758}
1759
1760/**
1761 * Navigates to the folder containing a duplicate file and then auto-opens it.
1762 * @param {{ path: string, name: string, dir: string }} dup
1763 */
1764async function navigateToDuplicate (dup)
1765{
1766 // If the duplicate lives in the folder already shown, just select it.
1767 if (STATE.currentDir && samePath(dup.dir, STATE.currentDir))
1768 {
1769 const tile = Array.from(document.querySelectorAll('.file-item'))
1770 .find((el) => el.dataset.path === dup.path);
1771 const dupItem = STATE.items.find((i) => i.path === dup.path);
1772 if (tile && dupItem)
1773 {
1774 selectItem(tile, dupItem);
1775 }
1776 return;
1777 }
1778
1779 // Find the root that contains the duplicate.
1780 const root = STATE.roots.find(
1781 (r) => dup.dir === r.path || dup.dir.startsWith(r.path + '/') || dup.dir.startsWith(r.path + '\\'),
1782 );
1783 if (!root)
1784 {
1785 toast('Cannot navigate to duplicate: root not accessible.', 'err');
1786 return;
1787 }
1788
1789 await navigateTo(dup.dir, root);
1790
1791 // After navigation, find and select the file tile to open it.
1792 const tile = Array.from(document.querySelectorAll('.file-item'))
1793 .find((el) => el.dataset.path === dup.path);
1794 const dupItem = STATE.items.find((i) => i.path === dup.path);
1795
1796 if (tile && dupItem)
1797 {
1798 selectItem(tile, dupItem);
1799 }
1800}
1801// ───────────────────────────────────────────────────────────────────────────
1802
1803async function openSidebar (item)
1804{
1805 const sidebarLoad = beginSidebarLoad();
1806
1807 const sidebar = document.getElementById('sidebar');
1808 sidebar.classList.remove('hidden');
1809 document.getElementById('app').classList.add('sidebar-open');
1810
1811 document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
1812 if (item.isDir)
1813 {
1814 document.getElementById('sidebar-icon').dataset.folderPath = item.path;
1815 } else
1816 {
1817 delete document.getElementById('sidebar-icon').dataset.folderPath;
1818 }
1819 document.getElementById('sidebar-name').textContent = item.name;
1820
1821 // Load metadata
1822 const dl = document.getElementById('sidebar-meta');
1823 dl.innerHTML = '<dt>Loading…</dt><dd></dd>';
1824
1825 const actions = document.getElementById('sidebar-actions');
1826 actions.innerHTML = '';
1827
1828 // Reset duplicates panel whenever a new item is opened.
1829 renderSidebarDuplicates(null, null);
1830
1831 if (!item.isDir)
1832 {
1833 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`).catch((err) =>
1834 {
1835 if (isAbortError(err)) return null;
1836 throw err;
1837 });
1838 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
1839
1840 if (meta)
1841 {
1842 const watchedBy = VIDEO_EXTS.has(extOf(item.name))
1843 ? Object.entries(meta.watchedBy || {})
1844 .map(([user, status]) => `${String(user)}: ${String(status)}`)
1845 .sort((a, b) => a.localeCompare(b))
1846 : [];
1847
1848 dl.innerHTML = `
1849 <dt>Size</dt> <dd>${formatBytes(meta.size)}</dd>
1850 <dt>Modified</dt> <dd>${new Date(meta.mtime).toLocaleString()}</dd>
1851 <dt>Uploaded by</dt><dd>${meta.uploader || '—'}</dd>
1852 <dt>Downloaded by</dt><dd>${meta.downloaders.join(', ') || '—'}</dd>
1853 ${VIDEO_EXTS.has(extOf(item.name)) ? `<dt>Watched by</dt><dd>${watchedBy.join(', ') || '—'}</dd>` : ''}
1854 `;
1855 }
1856
1857 // Fetch and render duplicate files.
1858 renderSidebarDuplicates(item, null); // show loading state
1859 const selectedPathAtRequest = item.path;
1860 api('GET', `/files/duplicates?file=${encodeURIComponent(item.path)}`)
1861 .then((data) =>
1862 {
1863 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
1864 if (!STATE.selectedItem || STATE.selectedItem.path !== selectedPathAtRequest) return;
1865 renderSidebarDuplicates(item, data ? data.duplicates : []);
1866 })
1867 .catch((err) =>
1868 {
1869 if (isAbortError(err)) return;
1870 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
1871 if (!STATE.selectedItem || STATE.selectedItem.path !== selectedPathAtRequest) return;
1872 renderSidebarDuplicates(item, []);
1873 });
1874
1875 // View / download button
1876 const btnDl = document.createElement('button');
1877 btnDl.textContent = 'View / Download';
1878 btnDl.addEventListener('click', () =>
1879 {
1880 const tile = Array.from(document.querySelectorAll('.file-item')).find(node => node.dataset.path === item.path);
1881 const source = (tile ? tile.querySelector('.icon svg') : null) || document.querySelector('#sidebar-icon svg');
1882 downloadOrView(item, source);
1883 });
1884 actions.appendChild(btnDl);
1885
1886 // Share button (file)
1887 const btnShareFile = document.createElement('button');
1888 btnShareFile.textContent = 'Share';
1889 btnShareFile.addEventListener('click', () => openShareModal(item));
1890 actions.appendChild(btnShareFile);
1891 } else
1892 {
1893 dl.innerHTML = `<dt>Type</dt><dd>${item._root ? 'Root folder' : 'Folder'}</dd>`;
1894
1895 if (item._root)
1896 {
1897 dl.innerHTML += `
1898 <dt>Alias</dt><dd>${item.name}</dd>
1899 <dt>Original name</dt><dd>${item._root.originalName || basenameOfPath(item.path)}</dd>
1900 `;
1901
1902 const space = await api('GET', `/files/space?dir=${encodeURIComponent(item.path)}`).catch((err) =>
1903 {
1904 if (isAbortError(err)) return null;
1905 return null;
1906 });
1907 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
1908
1909 if (space)
1910 {
1911 const used = formatBytes(space.usedBytes);
1912 const free = space.userFreeBytes != null
1913 ? formatBytes(space.userFreeBytes)
1914 : (space.freeBytes == null ? 'unknown' : formatBytes(space.freeBytes));
1915 const freeLabel = space.userFreeBytes != null ? 'Free space remaining' : 'Remaining';
1916 dl.innerHTML += `
1917 <dt>Used</dt><dd>${used}</dd>
1918 <dt>${freeLabel}</dt><dd>${free}</dd>
1919 `;
1920 }
1921
1922 if (item._root.isUserFolder)
1923 {
1924 dl.innerHTML += `
1925 <dt>Access</dt><dd>Private (your folder)</dd>
1926 `;
1927 } else
1928 {
1929 const accessUsers = await fetchRootAccessList(item.path);
1930 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
1931 if (accessUsers)
1932 {
1933 dl.innerHTML += `
1934 <dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>
1935 `;
1936 }
1937 }
1938 }
1939
1940 const btnOpen = document.createElement('button');
1941 btnOpen.textContent = 'Open folder';
1942 btnOpen.addEventListener('click', () => navigateTo(item.path, item._root || STATE.currentRoot));
1943 actions.appendChild(btnOpen);
1944
1945 // Download as zip button (folder)
1946 const btnZip = document.createElement('button');
1947 btnZip.textContent = 'Download as zip';
1948 btnZip.addEventListener('click', () =>
1949 {
1950 btnZip.disabled = true;
1951 btnZip.textContent = 'Working...';
1952 const url = `/api/files/download-zip?dir=${encodeURIComponent(item.path)}`;
1953 const headers = {
1954 Authorization: 'Bearer ' + STATE.token,
1955 'X-Fp': getFingerprint(),
1956 };
1957 fetch(url, { headers })
1958 .then(res =>
1959 {
1960 if (!res.ok) throw new Error('Download mislukt');
1961 return res.blob();
1962 })
1963 .then(blob =>
1964 {
1965 const blobUrl = URL.createObjectURL(blob);
1966 const a = document.createElement('a');
1967 a.href = blobUrl;
1968 a.download = item.name + '.zip';
1969 a.click();
1970 setTimeout(() => URL.revokeObjectURL(blobUrl), 10000);
1971 })
1972 .catch((err) => toast(err.message || 'Download mislukt', 'err'))
1973 .finally(() =>
1974 {
1975 btnZip.disabled = false;
1976 btnZip.textContent = 'Download as zip';
1977 });
1978 });
1979 actions.appendChild(btnZip);
1980
1981 // Share button (folder)
1982 const btnShareFolder = document.createElement('button');
1983 btnShareFolder.textContent = 'Share';
1984 btnShareFolder.addEventListener('click', () => openShareModal(item));
1985 actions.appendChild(btnShareFolder);
1986
1987 // Load folder icon thumbnail into the sidebar icon element.
1988 void loadOneFolderIcon(document.getElementById('sidebar-icon'));
1989 }
1990
1991 // Rename button (write access required)
1992 if (canWrite(item))
1993 {
1994 if (item.isDir)
1995 {
1996 const btnSetIcon = document.createElement('button');
1997 btnSetIcon.textContent = 'Set icon';
1998 btnSetIcon.addEventListener('click', () => openFolderIconPicker(item));
1999 actions.appendChild(btnSetIcon);
2000 }
2001
2002 if (!item._root)
2003 {
2004 const btnMove = document.createElement('button');
2005 btnMove.textContent = 'Move to';
2006 btnMove.addEventListener('click', () => openMovePicker(item));
2007 actions.appendChild(btnMove);
2008
2009 if (!item.isDir)
2010 {
2011 const btnCopy = document.createElement('button');
2012 btnCopy.textContent = 'Copy to';
2013 btnCopy.addEventListener('click', () => openCopyPicker(item));
2014 actions.appendChild(btnCopy);
2015 }
2016 }
2017
2018 const btnRen = document.createElement('button');
2019 btnRen.textContent = 'Rename';
2020 btnRen.addEventListener('click', () => openRenameModal(item));
2021 actions.appendChild(btnRen);
2022
2023 if (!item._root)
2024 {
2025 const btnDel = document.createElement('button');
2026 btnDel.textContent = 'Delete';
2027 btnDel.className = 'danger';
2028 btnDel.addEventListener('click', () => deleteItem(item));
2029 actions.appendChild(btnDel);
2030 }
2031 }
2032}
2033
2034function openFolderSidebar ()
2035{
2036 beginSidebarLoad();
2037
2038 const sidebar = document.getElementById('sidebar');
2039 sidebar.classList.remove('hidden');
2040 document.getElementById('app').classList.add('sidebar-open');
2041
2042 document.getElementById('sidebar-icon').innerHTML = iconFolder(64);
2043
2044 const nameEl = document.getElementById('sidebar-name');
2045 const dl = document.getElementById('sidebar-meta');
2046 const actions = document.getElementById('sidebar-actions');
2047 actions.innerHTML = '';
2048 renderSidebarDuplicates(null, null);
2049
2050 if (!STATE.currentDir || !STATE.currentRoot)
2051 {
2052 nameEl.textContent = 'Storage Roots';
2053 dl.innerHTML = `
2054 <dt>Type</dt><dd>Root overview</dd>
2055 <dt>Roots</dt><dd>${STATE.roots.length}</dd>
2056 `;
2057 return;
2058 }
2059
2060 const parts = String(STATE.currentDir).split(/[\\/]/).filter(Boolean);
2061 const fallback = STATE.currentRoot.label || 'Folder';
2062 nameEl.textContent = parts.length ? parts[parts.length - 1] : fallback;
2063
2064 const dirs = STATE.items.filter(i => i.isDir).length;
2065 const files = STATE.items.length - dirs;
2066 const displayPath = displayPathWithRootLabel(STATE.currentDir, STATE.currentRoot.path, STATE.currentRoot.label);
2067 const baseDetails = `
2068 <dt>Path</dt><dd>${displayPath}</dd>
2069 <dt>Folders</dt><dd>${dirs}</dd>
2070 <dt>Files</dt><dd>${files}</dd>
2071 `;
2072 dl.innerHTML = baseDetails;
2073
2074 if (samePath(STATE.currentDir, STATE.currentRoot.path))
2075 {
2076 if (STATE.currentRoot.isUserFolder)
2077 {
2078 dl.innerHTML += '<dt>Access</dt><dd>Private (your folder)</dd>';
2079 return;
2080 }
2081
2082 dl.innerHTML += '<dt>Access</dt><dd>Loading…</dd>';
2083 const currentDirAtStart = STATE.currentDir;
2084 const currentRootPathAtStart = STATE.currentRoot.path;
2085 void fetchRootAccessList(currentRootPathAtStart).then((accessUsers) =>
2086 {
2087 if (!accessUsers) return;
2088 if (!STATE.currentRoot) return;
2089 if (!samePath(STATE.currentDir, currentDirAtStart)) return;
2090 if (!samePath(STATE.currentRoot.path, currentRootPathAtStart)) return;
2091 dl.innerHTML = `${baseDetails}<dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>`;
2092 });
2093 }
2094}
2095
2096function closeSidebar ()
2097{
2098 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return;
2099 beginSidebarLoad();
2100 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
2101 STATE.selectedItem = null;
2102
2103 if (isMobileViewport())
2104 {
2105 hideSidebarPanel();
2106 return;
2107 }
2108
2109 openFolderSidebar();
2110}
2111
2112function isMobileViewport ()
2113{
2114 return window.matchMedia(MOBILE_BREAKPOINT_QUERY).matches;
2115}
2116
2117function hideSidebarPanel ()
2118{
2119 const sidebar = document.getElementById('sidebar');
2120 const app = document.getElementById('app');
2121 sidebar.classList.add('hidden');
2122 app.classList.remove('sidebar-open');
2123}
2124
2125function basenameOfPath (p)
2126{
2127 const parts = String(p || '').split(/[\\/]/).filter(Boolean);
2128 return parts.length ? parts[parts.length - 1] : String(p || '');
2129}
2130
2131async function fetchRootAccessList (rootPath)
2132{
2133 if (!rootPath) return null;
2134 const data = await api('GET', `/files/root-access?rootPath=${encodeURIComponent(rootPath)}`).catch((err) =>
2135 {
2136 if (isAbortError(err)) return null;
2137 return null;
2138 });
2139 if (!data || !Array.isArray(data.users)) return null;
2140 return data.users;
2141}
2142
2143function formatRootAccessList (users)
2144{
2145 if (!Array.isArray(users) || users.length === 0) return 'No users';
2146
2147 const sorted = [...users].sort((a, b) =>
2148 {
2149 const modeRank = (mode) => mode === 'R+W' ? 0 : 1;
2150 const byMode = modeRank(a.mode) - modeRank(b.mode);
2151 if (byMode !== 0) return byMode;
2152 return String(a.username).localeCompare(String(b.username));
2153 });
2154
2155 const items = sorted
2156 .map((u) => `<li>${escapeHtml(String(u.username || ''))} ${escapeHtml(String(u.mode || 'R'))}</li>`)
2157 .join('');
2158 return `<ul class="root-access-list">${items}</ul>`;
2159}
2160
2161function rootPermissionLabel (root)
2162{
2163 if (root && root.isUserFolder) return 'My Folder';
2164 return (root && (root.originalName || root.label)) || '';
2165}
2166
2167function resolveRootForPath (targetPath)
2168{
2169 if (!targetPath) return null;
2170 return STATE.roots.find((r) => samePath(targetPath, r.path) || pathInside(targetPath, r.path)) || null;
2171}
2172
2173function writableRoots ()
2174{
2175 if (STATE.isAdmin) return STATE.roots.slice();
2176 return STATE.roots.filter((r) =>
2177 {
2178 if (r.isUserFolder) return true;
2179 const perm = STATE.permissions[rootPermissionLabel(r)];
2180 return !!(perm && perm.write);
2181 });
2182}
2183
2184async function moveWithConflictResolution (item, targetDir)
2185{
2186 try
2187 {
2188 return await api('POST', '/files/move', { from: item.path, toDir: targetDir });
2189 }
2190 catch (err)
2191 {
2192 if (!/already exists/i.test(err.message || '')) throw err;
2193
2194 const existingNames = await listDirNameSet(targetDir);
2195 const desiredName = item.name || basenameOfPath(item.path) || 'file';
2196 const suggestedName = nextAvailableName(desiredName, existingNames);
2197 const decision = await showFileConflictChoice(desiredName, suggestedName, 'move');
2198 if (decision === 'cancel') return null;
2199
2200 if (decision === 'overwrite')
2201 {
2202 return api('POST', '/files/move', {
2203 from: item.path,
2204 toDir: targetDir,
2205 conflict: 'overwrite',
2206 });
2207 }
2208
2209 return api('POST', '/files/move', {
2210 from: item.path,
2211 toDir: targetDir,
2212 conflict: 'rename',
2213 targetName: suggestedName,
2214 });
2215 }
2216}
2217
2218async function copyWithConflictResolution (item, targetDir)
2219{
2220 try
2221 {
2222 return await api('POST', '/files/copy', { from: item.path, toDir: targetDir });
2223 }
2224 catch (err)
2225 {
2226 if (!/already exists/i.test(err.message || '')) throw err;
2227
2228 const existingNames = await listDirNameSet(targetDir);
2229 const desiredName = item.name || basenameOfPath(item.path) || 'file';
2230 const suggestedName = nextAvailableName(desiredName, existingNames);
2231 const decision = await showFileConflictChoice(desiredName, suggestedName, 'copy');
2232 if (decision === 'cancel') return null;
2233
2234 if (decision === 'overwrite')
2235 {
2236 return api('POST', '/files/copy', {
2237 from: item.path,
2238 toDir: targetDir,
2239 conflict: 'overwrite',
2240 });
2241 }
2242
2243 return api('POST', '/files/copy', {
2244 from: item.path,
2245 toDir: targetDir,
2246 conflict: 'rename',
2247 targetName: suggestedName,
2248 });
2249 }
2250}
2251
2252function ensureMoveModal ()
2253{
2254 let overlay = document.getElementById('move-modal');
2255 if (overlay) return overlay;
2256
2257 overlay = document.createElement('div');
2258 overlay.id = 'move-modal';
2259 overlay.className = 'modal-overlay hidden';
2260 overlay.innerHTML = `
2261 <div class="modal move-modal">
2262 <button class="modal-close" id="move-modal-close" aria-label="Close">✕</button>
2263 <h2>Move To</h2>
2264 <p id="move-modal-caption" class="muted"></p>
2265 <div id="move-tree" class="move-tree"></div>
2266 <p id="move-selected" class="muted"></p>
2267 <div class="dialog-actions">
2268 <button id="move-modal-cancel">Cancel</button>
2269 <button id="move-modal-confirm" class="primary">Move</button>
2270 </div>
2271 </div>
2272 `;
2273 document.body.appendChild(overlay);
2274
2275 const closeBtn = overlay.querySelector('#move-modal-close');
2276 const cancelBtn = overlay.querySelector('#move-modal-cancel');
2277 const confirmBtn = overlay.querySelector('#move-modal-confirm');
2278
2279 function hide ()
2280 {
2281 overlay.classList.add('hidden');
2282 STATE.movePicker = null;
2283 }
2284
2285 closeBtn.addEventListener('click', hide);
2286 cancelBtn.addEventListener('click', hide);
2287 overlay.addEventListener('click', (e) =>
2288 {
2289 if (e.target === overlay) hide();
2290 });
2291
2292 confirmBtn.addEventListener('click', async () =>
2293 {
2294 const st = STATE.movePicker;
2295 if (!st || !st.item || !st.selectedPath)
2296 {
2297 toast('Select a destination folder first.', 'err');
2298 return;
2299 }
2300
2301 try
2302 {
2303 if (st.mode === 'copy')
2304 {
2305 const copied = await copyWithConflictResolution(st.item, st.selectedPath);
2306 if (!copied) return;
2307 }
2308 else
2309 {
2310 const moved = await moveWithConflictResolution(st.item, st.selectedPath);
2311 if (!moved) return;
2312 }
2313 }
2314 catch (err)
2315 {
2316 const action = st.mode === 'copy' ? 'Copy' : 'Move';
2317 toast(`${action} failed: ${err.message}`, 'err');
2318 return;
2319 }
2320
2321 hide();
2322 if (st.mode !== 'copy' && STATE.selectedItem && STATE.selectedItem.path === st.item.path) closeSidebar();
2323 navigateTo(STATE.currentDir, STATE.currentRoot);
2324 });
2325
2326 return overlay;
2327}
2328
2329function setMoveSelection (path, buttonEl)
2330{
2331 if (!STATE.movePicker) return;
2332 STATE.movePicker.selectedPath = path;
2333
2334 document.querySelectorAll('.move-node-label.selected').forEach((el) => el.classList.remove('selected'));
2335 if (buttonEl) buttonEl.classList.add('selected');
2336
2337 const selectedEl = document.getElementById('move-selected');
2338 selectedEl.textContent = path ? `Destination: ${path}` : 'Destination: none';
2339}
2340
2341async function loadMoveChildren (containerEl, dirPath)
2342{
2343 if (containerEl.dataset.loaded === '1') return;
2344 containerEl.dataset.loaded = '1';
2345
2346 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dirPath)}`).catch(() => null);
2347 const folders = data ? data.items.filter((it) => it.isDir).sort((a, b) => a.name.localeCompare(b.name)) : [];
2348
2349 if (!folders.length)
2350 {
2351 const empty = document.createElement('div');
2352 empty.className = 'move-empty';
2353 empty.textContent = 'No subfolders';
2354 containerEl.appendChild(empty);
2355 return;
2356 }
2357
2358 for (const child of folders)
2359 {
2360 containerEl.appendChild(createMoveNode(child.path, child.name));
2361 }
2362}
2363
2364function createMoveNode (folderPath, label)
2365{
2366 const node = document.createElement('div');
2367 node.className = 'move-node';
2368
2369 const row = document.createElement('div');
2370 row.className = 'move-node-row';
2371
2372 const toggle = document.createElement('button');
2373 toggle.type = 'button';
2374 toggle.className = 'move-toggle';
2375 toggle.textContent = '▸';
2376
2377 const selectBtn = document.createElement('button');
2378 selectBtn.type = 'button';
2379 selectBtn.className = 'move-node-label';
2380 selectBtn.textContent = label;
2381 selectBtn.addEventListener('click', () => setMoveSelection(folderPath, selectBtn));
2382
2383 const children = document.createElement('div');
2384 children.className = 'move-children hidden';
2385
2386 toggle.addEventListener('click', async () =>
2387 {
2388 if (children.classList.contains('hidden'))
2389 {
2390 await loadMoveChildren(children, folderPath);
2391 children.classList.remove('hidden');
2392 toggle.textContent = '▾';
2393 } else
2394 {
2395 children.classList.add('hidden');
2396 toggle.textContent = '▸';
2397 }
2398 });
2399
2400 row.appendChild(toggle);
2401 row.appendChild(selectBtn);
2402 node.appendChild(row);
2403 node.appendChild(children);
2404 return node;
2405}
2406
2407function openDestinationPicker (item, mode)
2408{
2409 if (!canWrite())
2410 {
2411 toast('No write access.', 'err');
2412 return;
2413 }
2414
2415 const roots = writableRoots();
2416 if (!roots.length)
2417 {
2418 toast('No writable destination roots available.', 'err');
2419 return;
2420 }
2421
2422 const overlay = ensureMoveModal();
2423 const tree = overlay.querySelector('#move-tree');
2424 const caption = overlay.querySelector('#move-modal-caption');
2425 const titleEl = overlay.querySelector('h2');
2426 const confirmBtn = overlay.querySelector('#move-modal-confirm');
2427
2428 const op = mode === 'copy' ? 'copy' : 'move';
2429 STATE.movePicker = { item, selectedPath: null, mode: op };
2430 titleEl.textContent = op === 'copy' ? 'Copy To' : 'Move To';
2431 confirmBtn.textContent = op === 'copy' ? 'Copy' : 'Move';
2432 caption.textContent = `Select destination folder for: ${item.name}`;
2433 tree.innerHTML = '';
2434
2435 for (const root of roots)
2436 {
2437 tree.appendChild(createMoveNode(root.path, root.label));
2438 }
2439
2440 setMoveSelection(null, null);
2441 overlay.classList.remove('hidden');
2442}
2443
2444function openMovePicker (item)
2445{
2446 openDestinationPicker(item, 'move');
2447}
2448
2449function openCopyPicker (item)
2450{
2451 openDestinationPicker(item, 'copy');
2452}
2453
2454// ───────────────────────────────────────────────────────────────────────────
2455// FOLDER ICON PICKER
2456// ───────────────────────────────────────────────────────────────────────────
2457
2458async function openFolderIconPicker (item)
2459{
2460 if (!canWrite(item))
2461 {
2462 toast('No write access.', 'err');
2463 return;
2464 }
2465
2466 // Fetch the list of available files (only those with cached thumbnails).
2467 const data = await api('GET', `/files/folder-images?dir=${encodeURIComponent(item.path)}`).catch(() => null);
2468 const images = data ? data.images : [];
2469
2470 let existingIconOverlay = document.getElementById('folder-icon-picker');
2471 if (existingIconOverlay) existingIconOverlay.remove();
2472
2473 const overlay = document.createElement('div');
2474 overlay.id = 'folder-icon-picker';
2475 overlay.className = 'modal-overlay';
2476
2477 const modal = document.createElement('div');
2478 modal.className = 'modal folder-icon-modal';
2479
2480 const closeBtn = document.createElement('button');
2481 closeBtn.className = 'modal-close';
2482 closeBtn.setAttribute('aria-label', 'Close');
2483 closeBtn.textContent = '✕';
2484
2485 const title = document.createElement('h2');
2486 title.textContent = 'Set folder icon';
2487
2488 const subtitle = document.createElement('p');
2489 subtitle.className = 'muted';
2490
2491 const grid = document.createElement('div');
2492 grid.className = 'folder-icon-grid';
2493
2494 if (!images.length)
2495 {
2496 subtitle.textContent = 'No files with cached thumbnails were found inside this folder.';
2497 } else
2498 {
2499 subtitle.textContent = 'Select a file thumbnail to use as the folder icon.';
2500
2501 for (const { filePath } of images)
2502 {
2503 const cell = document.createElement('div');
2504 cell.className = 'folder-icon-cell';
2505 cell.dataset.path = filePath;
2506
2507 const imgEl = document.createElement('img');
2508 imgEl.alt = filePath.split('/').pop();
2509 imgEl.className = 'folder-icon-thumb';
2510 // Lazy-load via IntersectionObserver on the cell.
2511 imgEl.dataset.src = filePath;
2512
2513 const label = document.createElement('div');
2514 label.className = 'folder-icon-label';
2515 label.textContent = filePath.split('/').pop();
2516
2517 cell.appendChild(imgEl);
2518 cell.appendChild(label);
2519
2520 cell.addEventListener('click', () =>
2521 {
2522 grid.querySelectorAll('.folder-icon-cell.selected').forEach(el => el.classList.remove('selected'));
2523 cell.classList.add('selected');
2524 confirmBtn.disabled = false;
2525 });
2526
2527 grid.appendChild(cell);
2528 }
2529 }
2530
2531 const dialogActions = document.createElement('div');
2532 dialogActions.className = 'dialog-actions';
2533
2534 const clearBtn = document.createElement('button');
2535 clearBtn.textContent = 'Clear icon';
2536 clearBtn.addEventListener('click', async () =>
2537 {
2538 try
2539 {
2540 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath: null });
2541 } catch (err)
2542 {
2543 toast('Failed to clear icon: ' + err.message, 'err');
2544 return;
2545 }
2546 hide();
2547 refreshAfterIconChange(item);
2548 });
2549
2550 const cancelBtn = document.createElement('button');
2551 cancelBtn.textContent = 'Cancel';
2552 cancelBtn.addEventListener('click', () => hide());
2553
2554 const confirmBtn = document.createElement('button');
2555 confirmBtn.className = 'primary';
2556 confirmBtn.textContent = 'Set icon';
2557 confirmBtn.disabled = true;
2558 confirmBtn.addEventListener('click', async () =>
2559 {
2560 const selected = grid.querySelector('.folder-icon-cell.selected');
2561 if (!selected) return;
2562 const imagePath = selected.dataset.path;
2563 try
2564 {
2565 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath });
2566 } catch (err)
2567 {
2568 toast('Failed to set icon: ' + err.message, 'err');
2569 return;
2570 }
2571 hide();
2572 refreshAfterIconChange(item);
2573 });
2574
2575 dialogActions.appendChild(clearBtn);
2576 dialogActions.appendChild(cancelBtn);
2577 dialogActions.appendChild(confirmBtn);
2578
2579 modal.appendChild(closeBtn);
2580 modal.appendChild(title);
2581 modal.appendChild(subtitle);
2582 modal.appendChild(grid);
2583 modal.appendChild(dialogActions);
2584 overlay.appendChild(modal);
2585 document.body.appendChild(overlay);
2586
2587 function hide ()
2588 {
2589 overlay.remove();
2590 // Revoke any blob URLs we created for the picker thumbnails.
2591 grid.querySelectorAll('.folder-icon-thumb[src^="blob:"]').forEach(img =>
2592 {
2593 URL.revokeObjectURL(img.src);
2594 });
2595 }
2596
2597 closeBtn.addEventListener('click', hide);
2598 overlay.addEventListener('click', (e) => { if (e.target === overlay) hide(); });
2599
2600 // Eagerly load thumbnails for all cells (picker is small, fetch all).
2601 for (const cell of grid.querySelectorAll('.folder-icon-cell'))
2602 {
2603 const imgEl = cell.querySelector('.folder-icon-thumb');
2604 const filePath = imgEl.dataset.src;
2605 void fetch(`/api/files/thumbnail?file=${encodeURIComponent(filePath)}`, {
2606 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
2607 }).then(async (r) =>
2608 {
2609 if (!r.ok || !overlay.isConnected) return;
2610 const blob = await r.blob();
2611 const url = URL.createObjectURL(blob);
2612 imgEl.src = url;
2613 }).catch(() => { });
2614 }
2615}
2616
2617function refreshAfterIconChange (item)
2618{
2619 // Reset and reload icon in grid tiles.
2620 const gridTile = Array.from(document.querySelectorAll('.icon[data-folder-path]'))
2621 .find(el => el.dataset.folderPath === item.path);
2622 if (gridTile)
2623 {
2624 const svg = gridTile.querySelector('svg');
2625 if (svg)
2626 {
2627 // Rebuild to plain folder SVG, then reload.
2628 gridTile.innerHTML = iconFolder();
2629 delete gridTile.dataset.thumbReady;
2630 gridTile.dataset.folderPath = item.path;
2631 void loadOneFolderIcon(gridTile);
2632 }
2633 }
2634
2635 // Also reset the sidebar icon if it's showing the same folder.
2636 const sidebarIcon = document.getElementById('sidebar-icon');
2637 if (sidebarIcon && sidebarIcon.dataset.folderPath === item.path)
2638 {
2639 sidebarIcon.innerHTML = iconFolder(64);
2640 delete sidebarIcon.dataset.thumbReady;
2641 void loadOneFolderIcon(sidebarIcon);
2642 }
2643}
2644
2645// ───────────────────────────────────────────────────────────────────────────
2646// DOWNLOAD / VIEW
2647// ───────────────────────────────────────────────────────────────────────────
2648
2649function isInlinePreviewableBlob (blob, name)
2650{
2651 const mime = String(blob.type || '').toLowerCase();
2652 if (/^(image|video|audio)\//.test(mime)) return true;
2653 if (/^text\//.test(mime)) return true;
2654 if (mime === 'application/pdf') return true;
2655 if (mime === 'application/json') return true;
2656 if (mime === 'application/xml') return true;
2657 if (mime === 'application/javascript') return true;
2658
2659 // Fallback by extension when MIME is missing or generic.
2660 const ext = extOf(name || '');
2661 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || AUDIO_EXTS.has(ext)) return true;
2662 if (MODEL_EXTS.has(ext)) return true;
2663 if (MODEL_EXTS.has(ext)) return true;
2664 if (CODE_EXTS.has(ext)) return true;
2665 return false;
2666}
2667
2668function isTextLikeBlob (blob, name)
2669{
2670 const mime = String(blob.type || '').toLowerCase();
2671 if (/^text\//.test(mime)) return true;
2672 if (mime === 'application/json' || mime === 'application/xml' || mime === 'application/javascript') return true;
2673 const ext = extOf(name || '');
2674 return CODE_EXTS.has(ext);
2675}
2676
2677function detectCodeLanguage (name, mime)
2678{
2679 const ext = extOf(name || '');
2680 const m = String(mime || '').toLowerCase();
2681 if (m.includes('json') || ext === 'json') return 'json';
2682 if (m.includes('xml') || ext === 'xml') return 'xml';
2683 if (m.includes('html') || ext === 'html' || ext === 'htm') return 'html';
2684 if (m.includes('css') || ext === 'css') return 'css';
2685 if (m.includes('javascript') || ['js', 'jsx', 'mjs', 'cjs'].includes(ext)) return 'js';
2686 if (m.includes('typescript') || ['ts', 'tsx'].includes(ext)) return 'ts';
2687 if (['sh', 'bash', 'zsh'].includes(ext)) return 'sh';
2688 if (['md', 'txt', 'log', 'ini', 'toml', 'yaml', 'yml'].includes(ext)) return 'plain';
2689 return CODE_EXTS.has(ext) ? 'js' : 'plain';
2690}
2691
2692function prettyPrintMarkup (raw)
2693{
2694 const src = String(raw || '')
2695 .replace(/>\s+</g, '><')
2696 .replace(/\r\n/g, '\n');
2697
2698 const lines = src.replace(/></g, '>\n<').split('\n');
2699 let indent = 0;
2700 const out = [];
2701
2702 for (const ln of lines)
2703 {
2704 const line = ln.trim();
2705 if (!line) continue;
2706 const isClose = /^<\//.test(line);
2707 const isSelf = /\/>$/.test(line) || /^<[^!?][^>]*>[^<]*<\/[^>]+>$/.test(line);
2708 const isOpen = /^<[^!?/][^>]*>$/.test(line);
2709
2710 if (isClose) indent = Math.max(0, indent - 1);
2711 out.push(' '.repeat(indent) + line);
2712 if (isOpen && !isSelf) indent += 1;
2713 }
2714
2715 return out.join('\n');
2716}
2717
2718function prettyPrintBraces (raw)
2719{
2720 const lines = String(raw || '')
2721 .replace(/\r\n/g, '\n')
2722 .split('\n');
2723 let indent = 0;
2724 const out = [];
2725
2726 for (const ln of lines)
2727 {
2728 const line = ln.trim();
2729 if (!line)
2730 {
2731 out.push('');
2732 continue;
2733 }
2734 if (/^[}\])]/.test(line)) indent = Math.max(0, indent - 1);
2735 out.push(' '.repeat(indent) + line);
2736 if (/[{[(]$/.test(line) || /[{[(]\s*(\/\/.*)?$/.test(line)) indent += 1;
2737 }
2738 return out.join('\n');
2739}
2740
2741function prettyPrintCode (raw, lang)
2742{
2743 const text = String(raw || '').replace(/\r\n/g, '\n');
2744 if (lang === 'json')
2745 {
2746 try { return JSON.stringify(JSON.parse(text), null, 2); } catch { return text; }
2747 }
2748 if (lang === 'xml' || lang === 'html') return prettyPrintMarkup(text);
2749 if (lang === 'js' || lang === 'ts' || lang === 'css') return prettyPrintBraces(text);
2750 return text;
2751}
2752
2753function escapeHtml (s)
2754{
2755 return String(s)
2756 .replace(/&/g, '&amp;')
2757 .replace(/</g, '&lt;')
2758 .replace(/>/g, '&gt;');
2759}
2760
2761function highlightCode (raw, lang)
2762{
2763 if (lang === 'plain') return escapeHtml(raw);
2764
2765 let html = escapeHtml(raw);
2766 const stash = [];
2767 const keep = (regex, cls) =>
2768 {
2769 html = html.replace(regex, (m) =>
2770 {
2771 const idx = stash.push(`<span class="tok-${cls}">${m}</span>`) - 1;
2772 return `@@TOK${idx}@@`;
2773 });
2774 };
2775
2776 if (lang === 'json')
2777 {
2778 html = html
2779 .replace(/("(?:\\.|[^"\\])*")\s*:/g, '<span class="tok-key">$1</span>:')
2780 .replace(/: ("(?:\\.|[^"\\])*")/g, ': <span class="tok-string">$1</span>')
2781 .replace(/\b(true|false|null)\b/g, '<span class="tok-keyword">$1</span>')
2782 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
2783 return html;
2784 }
2785
2786 if (lang === 'xml' || lang === 'html')
2787 {
2788 html = html
2789 .replace(/(&lt;\/?)([a-zA-Z0-9:_-]+)/g, '$1<span class="tok-keyword">$2</span>')
2790 .replace(/([a-zA-Z0-9:_-]+)=(&quot;[^&]*&quot;|"[^"]*")/g, '<span class="tok-key">$1</span>=<span class="tok-string">$2</span>');
2791 return html;
2792 }
2793
2794 if (lang === 'sh') keep(/(^|\s)#.*$/gm, 'comment');
2795 else keep(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, 'comment');
2796 keep(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, 'string');
2797
2798 html = html
2799 .replace(/\b(function|return|if|else|for|while|switch|case|break|continue|const|let|var|class|new|import|from|export|default|try|catch|finally|throw|await|async|true|false|null|undefined)\b/g, '<span class="tok-keyword">$1</span>')
2800 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
2801
2802 html = html.replace(/@@TOK(\d+)@@/g, (_, idx) => stash[Number(idx)] || '');
2803 return html;
2804}
2805
2806function clearPreviewObjectUrl ()
2807{
2808 if (typeof STATE.previewCleanup === 'function')
2809 {
2810 try { STATE.previewCleanup(); } catch { /* ignore */ }
2811 }
2812 STATE.previewCleanup = null;
2813 STATE.previewDownloadAction = null;
2814 if (!STATE.previewObjectUrl) return;
2815 if (String(STATE.previewObjectUrl).startsWith('blob:'))
2816 {
2817 URL.revokeObjectURL(STATE.previewObjectUrl);
2818 }
2819 STATE.previewObjectUrl = null;
2820}
2821
2822function ensureStylesheet (id, href)
2823{
2824 let link = document.getElementById(id);
2825 if (link) return Promise.resolve(link);
2826
2827 link = document.createElement('link');
2828 link.id = id;
2829 link.rel = 'stylesheet';
2830 link.href = href;
2831
2832 return new Promise((resolve, reject) =>
2833 {
2834 link.addEventListener('load', () => resolve(link), { once: true });
2835 link.addEventListener('error', () => reject(new Error('Failed to load video player styles.')), { once: true });
2836 document.head.appendChild(link);
2837 });
2838}
2839
2840function ensureScript (id, src)
2841{
2842 let script = document.getElementById(id);
2843 if (script && window.videojs) return Promise.resolve(window.videojs);
2844
2845 if (!script)
2846 {
2847 script = document.createElement('script');
2848 script.id = id;
2849 script.src = src;
2850 }
2851
2852 return new Promise((resolve, reject) =>
2853 {
2854 script.addEventListener('load', () => resolve(window.videojs), { once: true });
2855 script.addEventListener('error', () => reject(new Error('Failed to load video player script.')), { once: true });
2856 if (!script.isConnected) document.head.appendChild(script);
2857 });
2858}
2859
2860async function ensureVideoJsLoaded ()
2861{
2862 if (window.videojs)
2863 {
2864 configureVideoJsBuffering(window.videojs);
2865 return window.videojs;
2866 }
2867 if (!videoJsLoaderPromise)
2868 {
2869 videoJsLoaderPromise = Promise.all([
2870 ensureStylesheet('videojs-styles', '/vendor/video.js/video-js.css'),
2871 ensureScript('videojs-script', '/vendor/video.js/video.min.js'),
2872 ]).then(() =>
2873 {
2874 configureVideoJsBuffering(window.videojs);
2875 return window.videojs;
2876 });
2877 }
2878 return videoJsLoaderPromise;
2879}
2880
2881function configureVideoJsBuffering (videojs)
2882{
2883 if (!VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED)
2884 return;
2885
2886 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
2887 videojs.__filemanagerBufferingConfigured = true;
2888
2889 try
2890 {
2891 videojs.Vhs.GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
2892 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
2893 } catch
2894 {
2895 // Ignore builds that do not expose VHS buffer configuration.
2896 }
2897}
2898
2899async function createVideoStreamSessionForItem (item)
2900{
2901 return api('POST', '/files/video-stream', { filePath: item.path });
2902}
2903
2904async function releaseVideoStreamSession (sessionId, opts = {})
2905{
2906 const id = String(sessionId || '').trim();
2907 if (!id) return;
2908
2909 await api('DELETE', `/files/video-stream/${encodeURIComponent(id)}`, null, {
2910 keepalive: !!opts.keepalive,
2911 noAutoLogout: true,
2912 }).catch(() => null);
2913}
2914
2915function releaseActivePreviewVideoStreamSession (opts = {})
2916{
2917 const sessionId = String(STATE.previewVideoStreamSessionId || '').trim();
2918 if (!sessionId) return;
2919 STATE.previewVideoStreamSessionId = null;
2920 void releaseVideoStreamSession(sessionId, opts);
2921}
2922
2923async function preparePreviewDownload (item)
2924{
2925 const blob = await fetchFileBlob(item);
2926 if (!blob)
2927 {
2928 toast('Download failed.', 'err');
2929 return;
2930 }
2931
2932 const objectUrl = URL.createObjectURL(blob);
2933 triggerDownload(item.name, objectUrl);
2934 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
2935}
2936
2937async function renderStreamedVideoPreview (item, targetEl)
2938{
2939 const videojs = await ensureVideoJsLoaded();
2940 const session = await createVideoStreamSessionForItem(item);
2941 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
2942 const prefs = loadUserVideoPrefs();
2943 applyUserVideoTextTrackPrefs();
2944
2945 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
2946 {
2947 toast('Some subtitle tracks could not be converted for web playback.', 'err');
2948 }
2949
2950 STATE.previewDownloadAction = () => preparePreviewDownload(item);
2951
2952 const video = document.createElement('video');
2953 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
2954 video.controls = true;
2955 video.preload = 'auto';
2956 video.playsInline = true;
2957 targetEl.classList.add('preview-expand-content--video');
2958 targetEl.appendChild(video);
2959
2960 const player = videojs(video, {
2961 controls: true,
2962 fluid: false,
2963 fill: true,
2964 responsive: false,
2965 preload: 'auto',
2966 controlBar: {
2967 currentTimeDisplay: true,
2968 timeDivider: true,
2969 durationDisplay: true,
2970 remainingTimeDisplay: false,
2971 },
2972 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
2973 tracks: (session.subtitleTracks || []).map((track) => ({
2974 kind: 'subtitles',
2975 src: track.src,
2976 srclang: track.language || 'und',
2977 label: track.label,
2978 default: !!track.default,
2979 })),
2980 });
2981
2982 const trackPrefs = bindUserVideoTrackPrefs(player, prefs);
2983
2984 ensureVideoPlaybackUi(player, session.durationSeconds);
2985
2986 // -------------------------------------------------------------------------
2987 // Image-based subtitle overlays (PGS, DVD, etc.)
2988 // Extracted and displayed as PNG frames at the bottom of the video.
2989 // -------------------------------------------------------------------------
2990 const imageSubtitleTracks = session.imageSubtitleTracks || [];
2991 let activeImageStreamIndex = null;
2992 let imageOverlayContainer = null;
2993 let imageOverlayImg = null;
2994 let frameExtractionTimer = null;
2995
2996 const createImageOverlay = () =>
2997 {
2998 if (imageOverlayContainer) return;
2999
3000 imageOverlayContainer = document.createElement('div');
3001 imageOverlayContainer.className = 'video-subtitle-overlay';
3002 imageOverlayContainer.style.position = 'absolute';
3003 imageOverlayContainer.style.bottom = '0';
3004 imageOverlayContainer.style.left = '0';
3005 imageOverlayContainer.style.right = '0';
3006 imageOverlayContainer.style.display = 'none';
3007 imageOverlayContainer.style.textAlign = 'center';
3008 imageOverlayContainer.style.zIndex = '1';
3009 imageOverlayContainer.style.padding = '4px';
3010 imageOverlayContainer.style.backgroundColor = 'rgba(0, 0, 0, 0.3)';
3011 imageOverlayContainer.style.maxHeight = '30%';
3012 imageOverlayContainer.style.overflow = 'hidden';
3013
3014 imageOverlayImg = document.createElement('img');
3015 imageOverlayImg.style.maxHeight = '100%';
3016 imageOverlayImg.style.maxWidth = '100%';
3017 imageOverlayImg.style.display = 'none';
3018 imageOverlayImg.addEventListener('error', () => imageOverlayImg.style.display = 'none');
3019
3020 imageOverlayContainer.appendChild(imageOverlayImg);
3021
3022 const videoContainer = video.parentElement;
3023 videoContainer.style.position = 'relative';
3024 videoContainer.appendChild(imageOverlayContainer);
3025 };
3026
3027 const updateImageSubtitleFrame = async () =>
3028 {
3029 if (activeImageStreamIndex === null || !imageOverlayImg) return;
3030
3031 try
3032 {
3033 const currentTime = player.currentTime();
3034 const url = `/api/files/video-stream-subtitle-frame?filePath=${encodeURIComponent(item.path)}&streamIndex=${activeImageStreamIndex}&timeSeconds=${currentTime}`;
3035
3036 // Set a new src to trigger the load; use cache busting to ensure fresh frames
3037 imageOverlayImg.src = url + '&t=' + Date.now();
3038 imageOverlayImg.style.display = 'block';
3039 imageOverlayContainer.style.display = 'block';
3040 } catch
3041 {
3042 imageOverlayImg.style.display = 'none';
3043 }
3044 };
3045
3046 const scheduleFrameExtraction = () =>
3047 {
3048 if (frameExtractionTimer)
3049 {
3050 clearInterval(frameExtractionTimer);
3051 }
3052
3053 // Update frame every 100ms while playing
3054 if (!player.paused())
3055 {
3056 void updateImageSubtitleFrame();
3057 frameExtractionTimer = setInterval(updateImageSubtitleFrame, 100);
3058 }
3059 };
3060
3061 const handleImageTrackChange = async () =>
3062 {
3063 const allTextTracks = subtitleTracksFromPlayer(player);
3064 const activeImageEntry = imageSubtitleTracks.find(({ label }) =>
3065 allTextTracks.some((t) => t.label === label && String(t.mode || '') === 'showing'),
3066 );
3067
3068 const wantedStreamIndex = activeImageEntry ? activeImageEntry.streamIndex : null;
3069
3070 if (wantedStreamIndex === activeImageStreamIndex) return;
3071
3072 activeImageStreamIndex = wantedStreamIndex;
3073
3074 if (wantedStreamIndex === null)
3075 {
3076 if (imageOverlayContainer) imageOverlayContainer.style.display = 'none';
3077 if (frameExtractionTimer) clearInterval(frameExtractionTimer);
3078 } else
3079 {
3080 createImageOverlay();
3081 await updateImageSubtitleFrame();
3082 scheduleFrameExtraction();
3083 }
3084 };
3085
3086 // Add image subtitle tracks to VideoJS (as empty stubs so they show in menu)
3087 if (imageSubtitleTracks.length)
3088 {
3089 for (const imgTrack of imageSubtitleTracks)
3090 {
3091 player.addRemoteTextTrack({
3092 kind: 'subtitles',
3093 src: '/api/files/video-stream/empty.vtt',
3094 srclang: imgTrack.language || 'und',
3095 label: imgTrack.label,
3096 }, true);
3097 }
3098 }
3099
3100 // -------------------------------------------------------------------------
3101
3102 let sentPartway = false;
3103 let sentFully = false;
3104 const markWatch = async () =>
3105 {
3106 let ratio = 0;
3107 try
3108 {
3109 const duration = Number(player.duration());
3110 const current = Number(player.currentTime());
3111 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
3112 {
3113 ratio = current / duration;
3114 }
3115 } catch
3116 {
3117 return;
3118 }
3119
3120 if (ratio >= 0.7)
3121 {
3122 if (sentFully) return;
3123 sentPartway = true;
3124 sentFully = true;
3125 void reportWatchProgress(item.path, ratio);
3126 return;
3127 }
3128
3129 if (ratio >= 0.05)
3130 {
3131 if (sentPartway) return;
3132 sentPartway = true;
3133 void reportWatchProgress(item.path, ratio);
3134 }
3135 };
3136
3137 player.ready(() =>
3138 {
3139 if (imageSubtitleTracks.length)
3140 {
3141 player.textTracks().addEventListener('change', handleImageTrackChange);
3142 }
3143
3144 const volume = Number(prefs.volume);
3145 if (Number.isFinite(volume))
3146 {
3147 player.volume(Math.max(0, Math.min(1, volume)));
3148 }
3149
3150 const settings = player && player.textTrackSettings;
3151 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
3152 {
3153 settings.setValues({
3154 backgroundColor: '#000',
3155 backgroundOpacity: '0',
3156 edgeStyle: 'uniform',
3157 });
3158 settings.updateDisplay();
3159 }
3160
3161 trackPrefs.applySavedTracks();
3162 });
3163
3164 player.on('loadedmetadata', trackPrefs.applySavedTracks);
3165 player.on('loadedplaylist', trackPrefs.applySavedTracks);
3166
3167 player.on('play', scheduleFrameExtraction);
3168 player.on('pause', () =>
3169 {
3170 if (frameExtractionTimer)
3171 {
3172 clearInterval(frameExtractionTimer);
3173 frameExtractionTimer = null;
3174 }
3175 });
3176 player.on('seeking', updateImageSubtitleFrame);
3177 player.on('timeupdate', markWatch);
3178 player.on('ended', () =>
3179 {
3180 sentPartway = true;
3181 sentFully = true;
3182 void reportWatchProgress(item.path, 1);
3183 });
3184 player.on('volumechange', () =>
3185 {
3186 const v = Number(player.volume());
3187 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
3188 });
3189
3190 STATE.previewCleanup = () =>
3191 {
3192 if (imageSubtitleTracks.length)
3193 {
3194 try { player.textTracks().removeEventListener('change', handleImageTrackChange); } catch { /* ignore */ }
3195 }
3196 if (frameExtractionTimer)
3197 {
3198 clearInterval(frameExtractionTimer);
3199 frameExtractionTimer = null;
3200 }
3201 releaseActivePreviewVideoStreamSession();
3202 try { markWatch(); } catch { /* ignore */ }
3203 try { trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
3204 try { trackPrefs.detach(); } catch { /* ignore */ }
3205 try { player.dispose(); } catch { /* ignore */ }
3206 };
3207}
3208
3209function fileAccentColor (name)
3210{
3211 const ext = extOf(name || '');
3212 if (IMAGE_EXTS.has(ext)) return '#3fcf8e';
3213 if (VIDEO_EXTS.has(ext)) return '#e05c6e';
3214 if (AUDIO_EXTS.has(ext)) return '#c084fc';
3215 if (MODEL_EXTS.has(ext)) return '#2f6dff';
3216 if (DOC_EXTS.has(ext)) return '#f97316';
3217 if (CODE_EXTS.has(ext)) return '#38bdf8';
3218 if (ARCHIVE_EXTS.has(ext)) return '#facc15';
3219 return '#7880a0';
3220}
3221
3222function animateRect (el, fromRect, toRect, opts = {})
3223{
3224 const duration = opts.duration == null ? 260 : opts.duration;
3225 const easeOut = (t) => 1 - Math.pow(1 - t, 3);
3226
3227 el.style.left = `${fromRect.left}px`;
3228 el.style.top = `${fromRect.top}px`;
3229 el.style.width = `${fromRect.width}px`;
3230 el.style.height = `${fromRect.height}px`;
3231
3232 return new Promise((resolve) =>
3233 {
3234 const t0 = performance.now();
3235
3236 function frame (now)
3237 {
3238 const raw = Math.min((now - t0) / duration, 1);
3239 const t = easeOut(raw);
3240
3241 const left = fromRect.left + (toRect.left - fromRect.left) * t;
3242 const top = fromRect.top + (toRect.top - fromRect.top) * t;
3243 const width = fromRect.width + (toRect.width - fromRect.width) * t;
3244 const height = fromRect.height + (toRect.height - fromRect.height) * t;
3245
3246 el.style.left = `${left}px`;
3247 el.style.top = `${top}px`;
3248 el.style.width = `${width}px`;
3249 el.style.height = `${height}px`;
3250
3251 if (raw < 1)
3252 {
3253 requestAnimationFrame(frame);
3254 } else
3255 {
3256 resolve();
3257 }
3258 }
3259
3260 requestAnimationFrame(frame);
3261 });
3262}
3263
3264async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewContent)
3265{
3266 if (!tileEl || !sourceSvgEl) return false;
3267
3268 if (STATE.previewExpandState)
3269 {
3270 await closeExpandedTilePreview();
3271 }
3272
3273 const iconEl = tileEl.querySelector('.icon');
3274 const nameEl = tileEl.querySelector('.name');
3275 if (!iconEl) return false;
3276
3277 const startRect = tileEl.getBoundingClientRect();
3278 const targetW = Math.min(window.innerWidth * 0.94, 1100);
3279 const targetH = Math.min(window.innerHeight * 0.9, 860);
3280 const targetRect = {
3281 left: (window.innerWidth - targetW) / 2,
3282 top: (window.innerHeight - targetH) / 2,
3283 width: targetW,
3284 height: targetH,
3285 };
3286
3287 const backdrop = document.createElement('div');
3288 backdrop.className = 'preview-backdrop';
3289 document.body.appendChild(backdrop);
3290
3291 const parent = tileEl.parentNode;
3292 const nextSibling = tileEl.nextSibling;
3293 const iconHtml = iconEl.innerHTML;
3294 const originalIconSvg = iconEl.querySelector('svg');
3295 const placeholder = document.createElement('div');
3296 placeholder.className = 'file-item file-item--preview-placeholder';
3297 placeholder.style.width = `${startRect.width}px`;
3298 placeholder.style.height = `${startRect.height}px`;
3299
3300 if (parent)
3301 {
3302 parent.insertBefore(placeholder, tileEl);
3303 }
3304
3305 tileEl.remove();
3306 document.body.appendChild(tileEl);
3307 tileEl.classList.add('file-item--preview');
3308 tileEl.style.setProperty('--preview-accent', fileAccentColor(item.name));
3309 tileEl.style.position = 'fixed';
3310 tileEl.style.left = `${startRect.left}px`;
3311 tileEl.style.top = `${startRect.top}px`;
3312 tileEl.style.width = `${startRect.width}px`;
3313 tileEl.style.height = `${startRect.height}px`;
3314 tileEl.style.margin = '0';
3315 tileEl.style.zIndex = '10000';
3316
3317 if (nameEl) nameEl.style.display = 'none';
3318
3319 const titleEl = document.createElement('div');
3320 titleEl.className = 'preview-expand-title';
3321 titleEl.textContent = item.name;
3322
3323 const closeBtn = document.createElement('button');
3324 closeBtn.className = 'preview-expand-close';
3325 closeBtn.type = 'button';
3326 closeBtn.textContent = '×';
3327 closeBtn.setAttribute('aria-label', 'Close preview');
3328
3329 const dlBtn = document.createElement('button');
3330 dlBtn.className = 'preview-expand-download';
3331 dlBtn.type = 'button';
3332 dlBtn.textContent = 'Download';
3333 dlBtn.addEventListener('click', async (e) =>
3334 {
3335 e.stopPropagation();
3336 if (STATE.previewDownloadAction)
3337 {
3338 await STATE.previewDownloadAction();
3339 return;
3340 }
3341 if (!STATE.previewObjectUrl)
3342 {
3343 toast('Preview still loading.', 'err');
3344 return;
3345 }
3346 triggerDownload(item.name, STATE.previewObjectUrl);
3347 });
3348
3349 const shareBtn = document.createElement('button');
3350 shareBtn.className = 'preview-expand-share';
3351 shareBtn.type = 'button';
3352 shareBtn.textContent = 'Share';
3353 shareBtn.addEventListener('click', (e) =>
3354 {
3355 e.stopPropagation();
3356 openShareModal(item);
3357 });
3358
3359 const actionsEl = document.createElement('div');
3360 actionsEl.className = 'preview-expand-actions';
3361 actionsEl.appendChild(shareBtn);
3362 actionsEl.appendChild(dlBtn);
3363
3364 iconEl.innerHTML = '';
3365
3366 if (originalIconSvg)
3367 {
3368 const outline = originalIconSvg.cloneNode(true);
3369 outline.classList.add('preview-expand-outline');
3370 iconEl.appendChild(outline);
3371 }
3372
3373 const previewMount = document.createElement('div');
3374 previewMount.className = 'preview-expand-content';
3375 iconEl.appendChild(previewMount);
3376
3377 // Show spinner during expansion animation; content loads after it finishes
3378 const spinner = document.createElement('div');
3379 spinner.className = 'preview-loading-spinner';
3380 previewMount.appendChild(spinner);
3381
3382 tileEl.insertBefore(titleEl, tileEl.firstChild);
3383 tileEl.appendChild(closeBtn);
3384 tileEl.appendChild(actionsEl);
3385
3386 STATE.previewExpandState = {
3387 item,
3388 requireExplicitClose: VIDEO_EXTS.has(extOf(item.name)),
3389 tileEl,
3390 sourceSvgEl,
3391 parent,
3392 nextSibling,
3393 iconEl,
3394 iconHtml,
3395 nameEl,
3396 backdrop,
3397 placeholder,
3398 closeBtn,
3399 dlBtn,
3400 shareBtn,
3401 actionsEl,
3402 titleEl,
3403 previewMount,
3404 startRect,
3405 };
3406
3407 const onBackdrop = (e) =>
3408 {
3409 if (e.target === backdrop) closePreview();
3410 };
3411 const onClose = () => closePreview({ force: true });
3412 backdrop.addEventListener('click', onBackdrop);
3413 closeBtn.addEventListener('click', onClose);
3414 STATE.previewExpandState.onBackdrop = onBackdrop;
3415 STATE.previewExpandState.onClose = onClose;
3416
3417 requestAnimationFrame(() => backdrop.classList.add('visible'));
3418 await animateRect(tileEl, startRect, targetRect);
3419
3420 tileEl.style.left = `${targetRect.left}px`;
3421 tileEl.style.top = `${targetRect.top}px`;
3422 tileEl.style.width = `${targetRect.width}px`;
3423 tileEl.style.height = `${targetRect.height}px`;
3424
3425 try
3426 {
3427 await loadPreviewContent(previewMount);
3428 } catch
3429 {
3430 if (previewMount.isConnected)
3431 {
3432 previewMount.innerHTML = '';
3433 const msg = document.createElement('p');
3434 msg.className = 'preview-unsupported';
3435 msg.textContent = 'Preview failed to load. You can try again.';
3436 previewMount.appendChild(msg);
3437 }
3438 }
3439
3440 return true;
3441}
3442
3443async function closeExpandedTilePreview ()
3444{
3445 const st = STATE.previewExpandState;
3446 if (!st) return;
3447
3448 st.backdrop.classList.remove('visible');
3449 if (st.backdrop && st.onBackdrop) st.backdrop.removeEventListener('click', st.onBackdrop);
3450 if (st.closeBtn && st.onClose) st.closeBtn.removeEventListener('click', st.onClose);
3451
3452 const fromRect = st.tileEl.getBoundingClientRect();
3453 await animateRect(st.tileEl, fromRect, st.startRect, { duration: 220 });
3454
3455 st.tileEl.classList.remove('file-item--preview');
3456 st.tileEl.style.position = '';
3457 st.tileEl.style.left = '';
3458 st.tileEl.style.top = '';
3459 st.tileEl.style.width = '';
3460 st.tileEl.style.height = '';
3461 st.tileEl.style.margin = '';
3462 st.tileEl.style.zIndex = '';
3463
3464 if (st.titleEl) st.titleEl.remove();
3465 if (st.closeBtn) st.closeBtn.remove();
3466 if (st.actionsEl) st.actionsEl.remove();
3467 if (st.iconEl) st.iconEl.innerHTML = st.iconHtml;
3468 if (st.nameEl) st.nameEl.style.display = '';
3469
3470 if (st.placeholder && st.placeholder.parentNode)
3471 {
3472 st.placeholder.parentNode.insertBefore(st.tileEl, st.placeholder);
3473 st.placeholder.remove();
3474 } else if (st.parent)
3475 {
3476 if (st.nextSibling && st.nextSibling.parentNode === st.parent)
3477 {
3478 st.parent.insertBefore(st.tileEl, st.nextSibling);
3479 } else
3480 {
3481 st.parent.appendChild(st.tileEl);
3482 }
3483 }
3484
3485 if (st.backdrop) st.backdrop.remove();
3486 STATE.previewExpandState = null;
3487}
3488
3489async function closePreview (opts = {})
3490{
3491 if (STATE.previewClosing) return;
3492 if (STATE.previewExpandState)
3493 {
3494 if (STATE.previewExpandState.requireExplicitClose && !opts.force)
3495 {
3496 return;
3497 }
3498
3499 STATE.previewClosing = true;
3500 clearPreviewObjectUrl();
3501 try
3502 {
3503 await closeExpandedTilePreview();
3504 STATE.previewSourceEl = null;
3505 } finally
3506 {
3507 STATE.previewClosing = false;
3508 }
3509 }
3510}
3511
3512async function fetchFileBlob (item)
3513{
3514 const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
3515 try
3516 {
3517 const res = await fetch(url, {
3518 headers: {
3519 Authorization: 'Bearer ' + STATE.token,
3520 'X-Fp': getFingerprint(),
3521 },
3522 });
3523 if (!res.ok) throw new Error('Download failed.');
3524 return await res.blob();
3525 } catch
3526 {
3527 return null;
3528 }
3529}
3530
3531function triggerDownload (filename, objectUrl)
3532{
3533 const a = document.createElement('a');
3534 a.href = objectUrl;
3535 a.download = filename;
3536 a.click();
3537}
3538
3539function modelPreviewType (name)
3540{
3541 const ext = extOf(name || '');
3542 if (MODEL_EXTS.has(ext)) return ext;
3543 return null;
3544}
3545
3546async function loadThreePreviewModules ()
3547{
3548 if (!threePreviewModulesPromise)
3549 {
3550 threePreviewModulesPromise = Promise.all([
3551 import('/vendor/three/three.module.js'),
3552 import('/vendor/three/addons/controls/OrbitControls.js'),
3553 import('/vendor/three/addons/loaders/STLLoader.js'),
3554 import('/vendor/three/addons/loaders/OBJLoader.js'),
3555 ]).then(([THREE, controlsMod, stlMod, objMod]) =>
3556 {
3557 return {
3558 THREE,
3559 OrbitControls: controlsMod.OrbitControls,
3560 STLLoader: stlMod.STLLoader,
3561 OBJLoader: objMod.OBJLoader,
3562 };
3563 });
3564 }
3565
3566 return threePreviewModulesPromise;
3567}
3568
3569function disposeObject3D (root)
3570{
3571 if (!root || typeof root.traverse !== 'function') return;
3572 root.traverse((node) =>
3573 {
3574 if (node.geometry && typeof node.geometry.dispose === 'function')
3575 {
3576 node.geometry.dispose();
3577 }
3578
3579 if (!node.material) return;
3580 if (Array.isArray(node.material))
3581 {
3582 node.material.forEach((material) =>
3583 {
3584 if (material && typeof material.dispose === 'function') material.dispose();
3585 });
3586 return;
3587 }
3588
3589 if (typeof node.material.dispose === 'function') node.material.dispose();
3590 });
3591}
3592
3593async function buildModelObjectFromBlob (blob, type, modules)
3594{
3595 const { THREE, STLLoader, OBJLoader } = modules;
3596 const sharedMaterial = new THREE.MeshStandardMaterial({
3597 color: 0x2f6dff,
3598 metalness: 0.08,
3599 roughness: 0.72,
3600 });
3601
3602 if (type === 'stl')
3603 {
3604 const arr = await blob.arrayBuffer();
3605 const geometry = new STLLoader().parse(arr);
3606 geometry.computeVertexNormals();
3607 return new THREE.Mesh(geometry, sharedMaterial);
3608 }
3609
3610 if (type === 'obj')
3611 {
3612 const text = await blob.text();
3613 const obj = new OBJLoader().parse(text);
3614 obj.traverse((node) =>
3615 {
3616 if (!node || !node.isMesh) return;
3617 node.material = sharedMaterial.clone();
3618 });
3619 sharedMaterial.dispose();
3620 return obj;
3621 }
3622
3623 throw new Error('Unsupported 3D model format.');
3624}
3625
3626function setModelPreviewMessage (wrap, text)
3627{
3628 wrap.innerHTML = '';
3629 const msg = document.createElement('p');
3630 msg.className = 'preview-unsupported';
3631 msg.textContent = text;
3632 wrap.appendChild(msg);
3633}
3634
3635async function renderModelPreview (item, blob, targetEl)
3636{
3637 const type = modelPreviewType(item && item.name);
3638 if (!type)
3639 {
3640 const msg = document.createElement('p');
3641 msg.className = 'preview-unsupported';
3642 msg.textContent = 'This 3D file type is not supported yet.';
3643 targetEl.appendChild(msg);
3644 return;
3645 }
3646
3647 const wrap = document.createElement('div');
3648 wrap.className = 'preview-model-wrap';
3649 targetEl.appendChild(wrap);
3650
3651 const canvas = document.createElement('canvas');
3652 canvas.className = 'preview-model-canvas';
3653 canvas.style.touchAction = 'none';
3654 wrap.appendChild(canvas);
3655
3656 const hint = document.createElement('p');
3657 hint.className = 'preview-model-hint';
3658 hint.textContent = 'Drag to rotate. Use the scroll wheel to zoom.';
3659 wrap.appendChild(hint);
3660
3661 const gl =
3662 canvas.getContext('webgl2', { antialias: true, alpha: true }) ||
3663 canvas.getContext('webgl', { antialias: true, alpha: true });
3664 if (!gl)
3665 {
3666 setModelPreviewMessage(wrap, '3D preview is not available in this browser. You can still download this file.');
3667 return;
3668 }
3669
3670 let modules;
3671 try
3672 {
3673 modules = await loadThreePreviewModules();
3674 } catch
3675 {
3676 setModelPreviewMessage(wrap, '3D preview dependencies failed to load. You can still download this file.');
3677 return;
3678 }
3679
3680 if (!wrap.isConnected) return;
3681
3682 const { THREE, OrbitControls } = modules;
3683 const scene = new THREE.Scene();
3684 scene.background = new THREE.Color(0x0d111a);
3685
3686 const camera = new THREE.PerspectiveCamera(50, 1, 0.01, 5000);
3687 const renderer = new THREE.WebGLRenderer({ canvas, context: gl, antialias: true, alpha: true });
3688 renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
3689
3690 const ambient = new THREE.AmbientLight(0xffffff, 0.9);
3691 const key = new THREE.DirectionalLight(0xffffff, 0.95);
3692 key.position.set(1.2, 1.6, 1.1);
3693 scene.add(ambient);
3694 scene.add(key);
3695
3696 let modelRoot;
3697 try
3698 {
3699 modelRoot = await buildModelObjectFromBlob(blob, type, modules);
3700 } catch
3701 {
3702 renderer.dispose();
3703 setModelPreviewMessage(wrap, 'This 3D file could not be parsed. You can still download it.');
3704 return;
3705 }
3706
3707 if (!wrap.isConnected)
3708 {
3709 disposeObject3D(modelRoot);
3710 renderer.dispose();
3711 return;
3712 }
3713
3714 scene.add(modelRoot);
3715
3716 const box = new THREE.Box3().setFromObject(modelRoot);
3717 if (box.isEmpty())
3718 {
3719 disposeObject3D(modelRoot);
3720 renderer.dispose();
3721 setModelPreviewMessage(wrap, 'This 3D file has no visible geometry to preview.');
3722 return;
3723 }
3724
3725 const size = new THREE.Vector3();
3726 const center = new THREE.Vector3();
3727 box.getSize(size);
3728 box.getCenter(center);
3729 modelRoot.position.sub(center);
3730
3731 const maxDim = Math.max(size.x, size.y, size.z) || 1;
3732 const camDistance = maxDim * 1.8;
3733 camera.position.set(camDistance, camDistance * 0.75, camDistance);
3734 camera.near = Math.max(0.001, maxDim / 2000);
3735 camera.far = Math.max(1000, maxDim * 2000);
3736 camera.updateProjectionMatrix();
3737
3738 const controls = new OrbitControls(camera, renderer.domElement);
3739 controls.enableDamping = true;
3740 controls.dampingFactor = 0.08;
3741 controls.target.set(0, 0, 0);
3742 controls.minDistance = maxDim * 0.2;
3743 controls.maxDistance = maxDim * 25;
3744 controls.update();
3745
3746 const resize = () =>
3747 {
3748 const w = Math.max(160, Math.floor(wrap.clientWidth || 0));
3749 const h = Math.max(160, Math.floor((wrap.clientHeight || 0) - (hint.offsetHeight || 0) - 6));
3750 renderer.setSize(w, h, false);
3751 camera.aspect = w / h;
3752 camera.updateProjectionMatrix();
3753 };
3754 resize();
3755
3756 let stop = false;
3757 let rafId = 0;
3758 const frame = () =>
3759 {
3760 if (stop) return;
3761 controls.update();
3762 renderer.render(scene, camera);
3763 rafId = requestAnimationFrame(frame);
3764 };
3765 frame();
3766
3767 const resizeObserver = typeof ResizeObserver === 'function'
3768 ? new ResizeObserver(() => resize())
3769 : null;
3770 if (resizeObserver) resizeObserver.observe(wrap);
3771
3772 STATE.previewCleanup = () =>
3773 {
3774 stop = true;
3775 if (rafId) cancelAnimationFrame(rafId);
3776 if (resizeObserver) resizeObserver.disconnect();
3777 try { controls.dispose(); } catch { /* ignore */ }
3778 try { disposeObject3D(modelRoot); } catch { /* ignore */ }
3779 try { renderer.dispose(); } catch { /* ignore */ }
3780 };
3781}
3782
3783async function renderPreviewBody (item, blob, objectUrl, targetEl = null)
3784{
3785 const body = targetEl || document.getElementById('preview-body');
3786 body.innerHTML = '';
3787
3788 const mime = String(blob.type || '').toLowerCase();
3789 const previewable = isInlinePreviewableBlob(blob, item.name);
3790
3791 if (!previewable)
3792 {
3793 const msg = document.createElement('p');
3794 msg.className = 'preview-unsupported';
3795 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
3796 body.appendChild(msg);
3797 return;
3798 }
3799
3800 if (/^image\//.test(mime) || IMAGE_EXTS.has(extOf(item.name)))
3801 {
3802 const img = document.createElement('img');
3803 img.className = 'preview-media';
3804 img.src = objectUrl;
3805 img.alt = item.name;
3806 body.appendChild(img);
3807 return;
3808 }
3809
3810 if (/^video\//.test(mime) || VIDEO_EXTS.has(extOf(item.name)))
3811 {
3812 const video = document.createElement('video');
3813 video.className = 'preview-media';
3814 video.src = objectUrl;
3815 video.controls = true;
3816 video.preload = 'metadata';
3817 body.appendChild(video);
3818 return;
3819 }
3820
3821 if (/^audio\//.test(mime) || AUDIO_EXTS.has(extOf(item.name)))
3822 {
3823 const audio = document.createElement('audio');
3824 audio.className = 'preview-audio';
3825 audio.src = objectUrl;
3826 audio.controls = true;
3827 body.appendChild(audio);
3828 return;
3829 }
3830
3831 if (modelPreviewType(item.name))
3832 {
3833 await renderModelPreview(item, blob, body);
3834 return;
3835 }
3836
3837 if (mime === 'application/pdf')
3838 {
3839 const frame = document.createElement('iframe');
3840 frame.className = 'preview-frame';
3841 frame.src = objectUrl;
3842 frame.title = item.name;
3843 body.appendChild(frame);
3844 return;
3845 }
3846
3847 if (isTextLikeBlob(blob, item.name))
3848 {
3849 const text = await blob.text();
3850 const lang = detectCodeLanguage(item.name, mime);
3851 const formatted = prettyPrintCode(text, lang);
3852 const pre = document.createElement('pre');
3853 pre.className = 'preview-text preview-code';
3854 pre.innerHTML = highlightCode(formatted, lang);
3855 body.appendChild(pre);
3856 return;
3857 }
3858
3859 const msg = document.createElement('p');
3860 msg.className = 'preview-unsupported';
3861 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
3862 body.appendChild(msg);
3863}
3864
3865async function downloadOrView (item, sourceSvgEl = null)
3866{
3867 if (STATE.previewExpandState)
3868 {
3869 await closePreview({ force: true });
3870 }
3871
3872 const sourceTileEl = sourceSvgEl ? sourceSvgEl.closest('.file-item') : null;
3873 if (sourceTileEl)
3874 {
3875 STATE.previewSourceEl = sourceSvgEl;
3876 const expanded = await openExpandedTilePreview(item, sourceTileEl, sourceSvgEl, async (previewMount) =>
3877 {
3878 if (VIDEO_EXTS.has(extOf(item.name)))
3879 {
3880 clearPreviewObjectUrl();
3881 previewMount.innerHTML = '';
3882 await renderStreamedVideoPreview(item, previewMount);
3883 return;
3884 }
3885
3886 const blob = await fetchFileBlob(item);
3887 if (!blob) throw new Error('Download failed');
3888
3889 clearPreviewObjectUrl();
3890 const objectUrl = URL.createObjectURL(blob);
3891 STATE.previewObjectUrl = objectUrl;
3892
3893 if (!previewMount.isConnected) return;
3894
3895 previewMount.innerHTML = '';
3896 await renderPreviewBody(item, blob, objectUrl, previewMount);
3897 });
3898 if (expanded) return;
3899 }
3900
3901 toast('Preview unavailable — no source tile found.', 'err');
3902}
3903
3904// ───────────────────────────────────────────────────────────────────────────
3905// UPLOAD
3906// ───────────────────────────────────────────────────────────────────────────
3907
3908function canWrite (item = null)
3909{
3910 if (STATE.isAdmin) return true;
3911 const root = item && item._root
3912 ? item._root
3913 : (STATE.currentRoot || (item ? resolveRootForPath(item.path) : null));
3914 if (!root) return false;
3915 if (root.isUserFolder) return true;
3916 const p = STATE.permissions[rootPermissionLabel(root)];
3917 return p && p.write;
3918}
3919
3920async function uploadFiles (fileList)
3921{
3922 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
3923 if (!canWrite()) { toast('No write access.', 'err'); return; }
3924
3925 const files = Array.from(fileList || []);
3926 if (!files.length) return;
3927
3928 // Show upload bar
3929 const wrap = document.createElement('div');
3930 wrap.className = 'upload-bar-wrap';
3931 wrap.innerHTML = `<span>Preparing upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
3932 document.body.appendChild(wrap);
3933 STATE.uploadInProgress = true;
3934
3935 try
3936 {
3937 const existingNames = await listDirNameSet(STATE.currentDir);
3938 let done = 0;
3939 let uploaded = 0;
3940
3941 for (const original of files)
3942 {
3943 let fileToUpload = original;
3944
3945 if (existingNames.has(original.name))
3946 {
3947 const suggested = nextAvailableName(original.name, existingNames);
3948 const decision = await showFileConflictChoice(original.name, suggested, 'upload');
3949 if (decision === 'cancel')
3950 {
3951 done++;
3952 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
3953 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
3954 continue;
3955 }
3956
3957 if (decision === 'rename')
3958 {
3959 fileToUpload = cloneFileWithName(original, suggested);
3960 }
3961 }
3962
3963 await uploadSingleFile(fileToUpload, STATE.currentDir);
3964 existingNames.add(fileToUpload.name);
3965 done++;
3966 uploaded++;
3967 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
3968 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
3969 }
3970
3971 toast(`Uploaded ${uploaded} file(s).`, 'ok');
3972 await navigateTo(STATE.currentDir, STATE.currentRoot);
3973 } catch (err)
3974 {
3975 toast(err.message, 'err');
3976 } finally
3977 {
3978 STATE.uploadInProgress = false;
3979 wrap.remove();
3980 }
3981}
3982
3983async function uploadSingleFile (file, targetDir)
3984{
3985 const formData = new FormData();
3986 formData.append('files', file);
3987
3988 await new Promise((resolve, reject) =>
3989 {
3990 const xhr = new XMLHttpRequest();
3991 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
3992 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
3993 xhr.setRequestHeader('X-Fp', getFingerprint());
3994 xhr.setRequestHeader('X-Upload-Size', String(file.size || 0));
3995 xhr.onload = () => xhr.status === 200
3996 ? resolve()
3997 : reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
3998 xhr.onerror = () => reject(new Error('Network error'));
3999 xhr.send(formData);
4000 });
4001}
4002
4003async function ensureServerDir (baseDir, relativeDir)
4004{
4005 const parts = String(relativeDir || '').split(/[\\/]/).filter(Boolean);
4006 let current = baseDir;
4007 for (const part of parts)
4008 {
4009 try
4010 {
4011 const resp = await api('POST', '/files/mkdir', { dir: current, name: part });
4012 current = resp && resp.path ? resp.path : joinServerPath(current, part);
4013 } catch (err)
4014 {
4015 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
4016 current = joinServerPath(current, part);
4017 }
4018 }
4019 return current;
4020}
4021
4022async function uploadFolderInputFiles (fileList)
4023{
4024 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
4025 if (!canWrite()) { toast('No write access.', 'err'); return; }
4026 if (!fileList || !fileList.length) return;
4027
4028 const files = Array.from(fileList);
4029 const total = files.length;
4030 let done = 0;
4031
4032 const wrap = document.createElement('div');
4033 wrap.className = 'upload-bar-wrap';
4034 wrap.innerHTML = `<span>Preparing folder upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
4035 document.body.appendChild(wrap);
4036 STATE.uploadInProgress = true;
4037
4038 try
4039 {
4040 const dirCache = new Map();
4041 dirCache.set('', STATE.currentDir);
4042
4043 for (const file of files)
4044 {
4045 const rel = file.webkitRelativePath || file.name;
4046 const relParts = rel.split(/[\\/]/).filter(Boolean);
4047 const relDir = relParts.slice(0, -1).join('/');
4048
4049 if (!dirCache.has(relDir))
4050 {
4051 const parentRel = relParts.slice(0, -2).join('/');
4052 const parentAbs = dirCache.get(parentRel) || await ensureServerDir(STATE.currentDir, parentRel);
4053 const thisName = relParts[relParts.length - 2];
4054
4055 try
4056 {
4057 const created = await api('POST', '/files/mkdir', { dir: parentAbs, name: thisName });
4058 dirCache.set(relDir, created.path || joinServerPath(parentAbs, thisName));
4059 } catch (err)
4060 {
4061 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
4062 dirCache.set(relDir, joinServerPath(parentAbs, thisName));
4063 }
4064 }
4065
4066 const targetDir = dirCache.get(relDir) || STATE.currentDir;
4067 await uploadSingleFile(file, targetDir);
4068 done++;
4069 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
4070 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
4071 }
4072
4073 toast(`Uploaded ${total} file(s).`, 'ok');
4074 await navigateTo(STATE.currentDir, STATE.currentRoot);
4075 } catch (err)
4076 {
4077 toast(err.message, 'err');
4078 } finally
4079 {
4080 STATE.uploadInProgress = false;
4081 wrap.remove();
4082 }
4083}
4084
4085// ───────────────────────────────────────────────────────────────────────────
4086// FOLDER DRAG-AND-DROP (recursive)
4087// ───────────────────────────────────────────────────────────────────────────
4088
4089/**
4090 * Reads all readEntries batches from a DirectoryReader (browsers may return
4091 * results in chunks; we must keep calling until we get an empty array).
4092 */
4093function readAllEntries (reader)
4094{
4095 return new Promise((resolve, reject) =>
4096 {
4097 const all = [];
4098 function next ()
4099 {
4100 reader.readEntries(batch =>
4101 {
4102 if (!batch.length) { resolve(all); return; }
4103 all.push(...batch);
4104 next();
4105 }, reject);
4106 }
4107 next();
4108 });
4109}
4110
4111/**
4112 * Recursively walk a FileSystemEntry tree, creating server-side directories
4113 * on the fly and collecting { file, targetDir } pairs for upload.
4114 */
4115async function collectEntries (entry, serverDir, toUpload)
4116{
4117 if (entry.isFile)
4118 {
4119 const file = await new Promise((res, rej) => entry.file(res, rej));
4120 toUpload.push({ file, targetDir: serverDir });
4121 } else if (entry.isDirectory)
4122 {
4123 // Ask the server to create the directory; it returns the canonical path.
4124 let newServerDir;
4125 try
4126 {
4127 const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
4128 newServerDir = resp.path;
4129 } catch
4130 {
4131 // Directory may already exist — reconstruct path from what we know.
4132 // The server always returns JSON with {error} on failure, so we can
4133 // still continue by falling back to a best-effort path join.
4134 // We rely on the fact that the server separator is consistent within
4135 // a session (the list/browse API already returned paths in that format).
4136 const sep = serverDir.includes('\\') ? '\\' : '/';
4137 newServerDir = serverDir + sep + entry.name;
4138 }
4139 const reader = entry.createReader();
4140 const subEntries = await readAllEntries(reader);
4141 for (const sub of subEntries)
4142 {
4143 await collectEntries(sub, newServerDir, toUpload);
4144 }
4145 }
4146}
4147
4148async function uploadEntries (entries)
4149{
4150 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
4151 if (!canWrite()) { toast('No write access.', 'err'); return; }
4152
4153 const wrap = document.createElement('div');
4154 wrap.className = 'upload-bar-wrap';
4155 wrap.innerHTML = `<span>Scanning…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
4156 document.body.appendChild(wrap);
4157 STATE.uploadInProgress = true;
4158
4159 try
4160 {
4161 const toUpload = [];
4162 for (const entry of entries)
4163 {
4164 await collectEntries(entry, STATE.currentDir, toUpload);
4165 }
4166
4167 if (!toUpload.length) { toast('No files found.', 'err'); return; }
4168
4169 let done = 0;
4170 const total = toUpload.length;
4171 const updateBar = () =>
4172 {
4173 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
4174 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
4175 };
4176 updateBar();
4177
4178 for (const { file, targetDir } of toUpload)
4179 {
4180 await uploadSingleFile(file, targetDir);
4181 done++;
4182 updateBar();
4183 }
4184
4185 toast(`Uploaded ${total} file(s).`, 'ok');
4186 await navigateTo(STATE.currentDir, STATE.currentRoot);
4187 } catch (err)
4188 {
4189 toast(err.message, 'err');
4190 } finally
4191 {
4192 STATE.uploadInProgress = false;
4193 wrap.remove();
4194 }
4195}
4196
4197// DRAG-AND-DROP
4198// ───────────────────────────────────────────────────────────────────────────
4199
4200function initDragDrop ()
4201{
4202 const main = document.getElementById('main-content');
4203 const dropOvl = document.getElementById('drop-overlay');
4204 let dragDepth = 0;
4205
4206 main.addEventListener('dragenter', e =>
4207 {
4208 e.preventDefault();
4209 dragDepth++;
4210 dropOvl.classList.remove('hidden');
4211 });
4212 main.addEventListener('dragleave', () =>
4213 {
4214 dragDepth--;
4215 if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
4216 });
4217 main.addEventListener('dragover', e => e.preventDefault());
4218 main.addEventListener('drop', async e =>
4219 {
4220 e.preventDefault();
4221 dragDepth = 0;
4222 dropOvl.classList.add('hidden');
4223 if (!canWrite()) { toast('No write access.', 'err'); return; }
4224
4225 const items = Array.from(e.dataTransfer.items || []);
4226 // Use the FileSystem Entry API when available so we can handle folders.
4227 if (items.length && typeof items[0].webkitGetAsEntry === 'function')
4228 {
4229 const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
4230 if (entries.some(en => en.isDirectory))
4231 {
4232 await uploadEntries(entries);
4233 return;
4234 }
4235 }
4236 // Plain files only — use the fast batch path.
4237 const files = e.dataTransfer.files;
4238 if (files.length) await uploadFiles(files);
4239 });
4240}
4241
4242// ───────────────────────────────────────────────────────────────────────────
4243// RENAME
4244// ───────────────────────────────────────────────────────────────────────────
4245
4246function openRenameModal (item)
4247{
4248 const modal = document.getElementById('rename-modal');
4249 modal.classList.remove('hidden');
4250 const input = document.getElementById('rename-input');
4251 input.value = item.name;
4252 input.focus();
4253 input.select();
4254 document.getElementById('rename-error').classList.add('hidden');
4255 document.getElementById('rename-form').onsubmit = async (e) =>
4256 {
4257 e.preventDefault();
4258 const newName = input.value.trim();
4259 if (!newName) return;
4260 try
4261 {
4262 if (item._root)
4263 {
4264 await api('POST', '/files/root-alias', { rootPath: item.path, alias: newName });
4265 } else
4266 {
4267 await api('POST', '/files/rename', { from: item.path, to: newName });
4268 }
4269 modal.classList.add('hidden');
4270 toast(item._root ? 'Alias updated.' : 'Renamed.', 'ok');
4271 if (item._root)
4272 {
4273 await loadRoots({
4274 preferredDir: STATE.currentDir,
4275 preferredRootPath: (STATE.currentRoot && STATE.currentRoot.path) || item.path,
4276 });
4277 } else
4278 {
4279 await navigateTo(STATE.currentDir, STATE.currentRoot);
4280 }
4281 } catch (err)
4282 {
4283 document.getElementById('rename-error').textContent = err.message;
4284 document.getElementById('rename-error').classList.remove('hidden');
4285 }
4286 };
4287}
4288
4289// ───────────────────────────────────────────────────────────────────────────
4290// DELETE
4291// ───────────────────────────────────────────────────────────────────────────
4292
4293async function deleteItem (item)
4294{
4295 if (!await showConfirm('Delete item', `Delete "${item.name}"? This cannot be undone.`)) return;
4296 try
4297 {
4298 await api('POST', '/files/delete', { path: item.path });
4299 toast('Deleted.', 'ok');
4300 closeSidebar();
4301 await navigateTo(STATE.currentDir, STATE.currentRoot);
4302 } catch (err)
4303 {
4304 toast(err.message, 'err');
4305 }
4306}
4307
4308// ───────────────────────────────────────────────────────────────────────────
4309// ADMIN PANEL
4310// ───────────────────────────────────────────────────────────────────────────
4311
4312let _adminUpdateStatus = null;
4313
4314async function openAdminModal ()
4315{
4316 document.getElementById('admin-modal').classList.remove('hidden');
4317 await refreshAdminConfig();
4318 await refreshAdminUsers();
4319 void refreshAdminUpdateStatus();
4320}
4321
4322async function refreshAdminConfig ()
4323{
4324 const data = await api('GET', '/admin/config');
4325 if (!data) return;
4326
4327 const userPathInput = document.getElementById('admin-user-path');
4328 const sizeInput = document.getElementById('admin-user-size-limit');
4329 if (userPathInput) userPathInput.value = data.userPath || '';
4330 if (sizeInput)
4331 {
4332 sizeInput.value = data.userFolderSizeLimit ? formatBytes(data.userFolderSizeLimit) : '';
4333 updateAdminSizeFeedback(sizeInput.value);
4334 }
4335
4336 const container = document.getElementById('admin-paths');
4337 container.innerHTML = '';
4338 for (const p of data.paths)
4339 {
4340 const row = document.createElement('div');
4341 row.className = 'path-row';
4342 row.innerHTML = `<span>${p}</span><button data-path="${p}" title="Remove">✕</button>`;
4343 row.querySelector('button').addEventListener('click', () =>
4344 {
4345 row.remove();
4346 });
4347 container.appendChild(row);
4348 }
4349}
4350
4351async function refreshAdminUsers ()
4352{
4353 const data = await api('GET', '/admin/users');
4354 if (!data) return;
4355 const container = document.getElementById('admin-users-list');
4356 container.innerHTML = '';
4357
4358 // Need paths for permission rows
4359 const cfg = await api('GET', '/admin/config');
4360 const paths = cfg ? (cfg.effectivePaths || []) : [];
4361
4362 for (const u of data.users)
4363 {
4364 const row = document.createElement('div');
4365 row.className = 'user-row';
4366 row.innerHTML = `
4367 <span class="user-name">${u.username}</span>
4368 ${u.isAdmin ? '<span class="user-admin-badge">Admin</span>' : ''}
4369 <button data-id="${u.id}" data-action="edit">Edit</button>
4370 ${u.username === STATE.username ? '' : `<button data-id="${u.id}" data-action="delete" class="danger">Delete</button>`}
4371 `;
4372 row.querySelector('[data-action="edit"]').addEventListener('click', () =>
4373 openUserModal(u, paths));
4374 const deleteBtn = row.querySelector('[data-action="delete"]');
4375 if (deleteBtn) deleteBtn.addEventListener('click', async () =>
4376 {
4377 if (!await showConfirm('Delete user', `Delete user "${u.username}"? This cannot be undone.`)) return;
4378 try
4379 {
4380 await api('DELETE', `/admin/users/${u.id}`);
4381 toast('User deleted.', 'ok');
4382 await refreshAdminUsers();
4383 } catch (err) { toast(err.message, 'err'); }
4384 });
4385 container.appendChild(row);
4386 }
4387}
4388
4389async function refreshAdminUpdateStatus ()
4390{
4391 const btn = document.getElementById('admin-shutdown-btn');
4392 _adminUpdateStatus = null;
4393 btn.textContent = 'Shut down server';
4394
4395 try
4396 {
4397 const data = await api('GET', '/admin/update-status');
4398 if (!data) return;
4399 _adminUpdateStatus = data;
4400
4401 if (!data.underSystemd)
4402 {
4403 btn.textContent = 'Shut down server';
4404 }
4405 else if (data.commitsAhead.length === 0)
4406 {
4407 btn.textContent = 'Restart Server';
4408 }
4409 else
4410 {
4411 btn.textContent = 'Restart & Update';
4412 }
4413 }
4414 catch
4415 {
4416 // Not critical; button stays as "Shut down server".
4417 }
4418}
4419
4420function openUserModal (user, paths)
4421{
4422 const modal = document.getElementById('user-modal');
4423 modal.classList.remove('hidden');
4424 document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
4425 document.getElementById('user-error').classList.add('hidden');
4426
4427 const usernameInput = document.getElementById('user-username');
4428 usernameInput.value = user ? user.username : '';
4429 usernameInput.readOnly = !!user;
4430
4431 document.getElementById('user-password').value = '';
4432 document.getElementById('user-is-admin').checked = user ? user.isAdmin : false;
4433
4434 // Password placeholder
4435 document.getElementById('user-password').placeholder =
4436 user ? 'Leave blank to keep current' : 'Min 8 characters';
4437
4438 // Build permissions grid
4439 const permDiv = document.getElementById('user-permissions');
4440 permDiv.innerHTML = '';
4441 if (paths.length)
4442 {
4443 const heading = document.createElement('h4');
4444 heading.textContent = 'Path Permissions';
4445 permDiv.appendChild(heading);
4446
4447 const isAdminUser = !!(user && user.isAdmin);
4448 // Mirror the is-admin checkbox so toggling it live-updates the perm rows.
4449 const adminChk = document.getElementById('user-is-admin');
4450 const rebuildPermRows = (admin) =>
4451 {
4452 permDiv.querySelectorAll('.perm-row').forEach(r =>
4453 {
4454 r.querySelectorAll('input[type=checkbox]').forEach(cb =>
4455 {
4456 cb.disabled = admin;
4457 if (admin) cb.checked = true;
4458 });
4459 r.title = admin ? 'Admins always have full access' : '';
4460 });
4461 };
4462 adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
4463
4464 const syncReadWriteConstraints = (row, admin = false) =>
4465 {
4466 const readCb = row.querySelector('input[data-type="read"]');
4467 const writeCb = row.querySelector('input[data-type="write"]');
4468 if (!readCb || !writeCb) return;
4469
4470 if (admin)
4471 {
4472 readCb.checked = true;
4473 writeCb.checked = true;
4474 readCb.disabled = true;
4475 writeCb.disabled = true;
4476 return;
4477 }
4478
4479 readCb.disabled = false;
4480 if (!readCb.checked)
4481 {
4482 writeCb.checked = false;
4483 writeCb.disabled = true;
4484 }
4485 else
4486 {
4487 writeCb.disabled = false;
4488 }
4489 };
4490
4491 const syncAllReadWriteConstraints = () =>
4492 {
4493 const admin = adminChk.checked;
4494 permDiv.querySelectorAll('.perm-row').forEach((row) =>
4495 {
4496 syncReadWriteConstraints(row, admin);
4497 });
4498 };
4499
4500 for (const p of paths)
4501 {
4502 const label = p.split(/[\\/]/).pop();
4503 const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
4504 const row = document.createElement('div');
4505 row.className = 'perm-row';
4506 const readChecked = isAdminUser || perms.read;
4507 const writeChecked = isAdminUser || perms.write;
4508 row.innerHTML = `
4509 <span class="perm-label">${label}</span>
4510 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="read" ${readChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Read</label>
4511 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="write" ${writeChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Write</label>
4512 `;
4513 if (isAdminUser) row.title = 'Admins always have full access';
4514 const readCb = row.querySelector('input[data-type="read"]');
4515 if (readCb)
4516 {
4517 readCb.addEventListener('change', () =>
4518 {
4519 syncReadWriteConstraints(row, adminChk.checked);
4520 });
4521 }
4522 permDiv.appendChild(row);
4523 }
4524
4525 syncAllReadWriteConstraints();
4526 adminChk.addEventListener('change', syncAllReadWriteConstraints);
4527 }
4528
4529 document.getElementById('user-form').onsubmit = async (e) =>
4530 {
4531 e.preventDefault();
4532 const password = document.getElementById('user-password').value;
4533 const isAdmin = document.getElementById('user-is-admin').checked;
4534 const permissions = {};
4535 permDiv.querySelectorAll('input[data-label]').forEach(cb =>
4536 {
4537 const lbl = cb.dataset.label;
4538 if (!permissions[lbl]) permissions[lbl] = {};
4539 permissions[lbl][cb.dataset.type] = cb.checked;
4540 });
4541
4542 try
4543 {
4544 if (user)
4545 {
4546 const body = { isAdmin, permissions };
4547 if (password) body.password = password;
4548 await api('PATCH', `/admin/users/${user.id}`, body);
4549 } else
4550 {
4551 const uname = document.getElementById('user-username').value.trim();
4552 await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
4553 }
4554 modal.classList.add('hidden');
4555 toast('User saved.', 'ok');
4556 await refreshAdminUsers();
4557 } catch (err)
4558 {
4559 document.getElementById('user-error').textContent = err.message;
4560 document.getElementById('user-error').classList.remove('hidden');
4561 }
4562 };
4563}
4564
4565// ───────────────────────────────────────────────────────────────────────────
4566// SVG ICONS
4567// ───────────────────────────────────────────────────────────────────────────
4568
4569const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif']);
4570const VIDEO_EXTS = new Set(['mp4', 'webm', 'ogv', 'mov', 'avi', 'mkv']);
4571const AUDIO_EXTS = new Set(['mp3', 'ogg', 'wav', 'flac', 'aac', 'm4a']);
4572const MODEL_EXTS = new Set(['stl', 'obj']);
4573const DOC_EXTS = new Set(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp']);
4574const CODE_EXTS = new Set(['js', 'ts', 'py', 'rb', 'go', 'rs', 'c', 'cpp', 'h', 'cs', 'java', 'php', 'html', 'css', 'json', 'xml', 'yaml', 'yml', 'sh', 'bash', 'md', 'txt']);
4575const ARCHIVE_EXTS = new Set(['zip', 'tar', 'gz', 'bz2', 'xz', 'rar', '7z']);
4576const MAX_DIRECT_SVG_THUMB_BYTES = 1024 * 1024;
4577
4578function iconFolder (size = 52)
4579{
4580 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
4581 stroke="#5b7fff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
4582 <path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
4583 </svg>`;
4584}
4585
4586function iconFile (name, size = 52)
4587{
4588 const color = fileAccentColor(name);
4589 let symbol = '';
4590
4591 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
4592 stroke="${color}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
4593 <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
4594 <polyline points="14 2 14 8 20 8"/>
4595 </svg>`;
4596}
4597
4598function watchStatusForTile (item)
4599{
4600 if (!item || item.isDir) return null;
4601 if (!VIDEO_EXTS.has(extOf(item.name || ''))) return null;
4602
4603 const cached = STATE.watchedStatusByPath[item.path];
4604 if (cached === 'fully' || cached === 'partway') return cached;
4605
4606 const currentUser = String(STATE.username || '').trim();
4607 if (!currentUser) return null;
4608
4609 const watchedBy = item.watchedBy && typeof item.watchedBy === 'object' ? item.watchedBy : {};
4610 const statusRaw = watchedBy[currentUser];
4611 const status = String(statusRaw || '').toLowerCase();
4612 if (status === 'fully' || status === 'partway') return status;
4613 return null;
4614}
4615
4616function renderWatchedOverlayOnIcon (iconEl, watchStatus)
4617{
4618 if (!iconEl) return;
4619
4620 const existing = iconEl.querySelector('.watched-overlay');
4621 if (existing) existing.remove();
4622 if (watchStatus !== 'fully' && watchStatus !== 'partway') return;
4623
4624 const overlay = document.createElement('div');
4625 overlay.className = `watched-overlay watched-overlay--${watchStatus}`;
4626 overlay.innerHTML = watchedEyeFilledSvg();
4627 iconEl.appendChild(overlay);
4628}
4629
4630function findTileIconByPath (filePath)
4631{
4632 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return null;
4633 const tile = Array.from(document.querySelectorAll('.file-item')).find((el) => el.dataset.path === filePath);
4634 if (!tile) return null;
4635 return tile.querySelector('.icon');
4636}
4637
4638function watchStatusFromWatchedBy (watchedBy)
4639{
4640 const currentUser = String(STATE.username || '').trim();
4641 if (!currentUser) return null;
4642
4643 const map = watchedBy && typeof watchedBy === 'object' ? watchedBy : {};
4644 const statusRaw = map[currentUser];
4645 const status = String(statusRaw || '').toLowerCase();
4646 if (status === 'fully' || status === 'partway') return status;
4647 return null;
4648}
4649
4650async function loadWatchedStatusesForCurrentDir ()
4651{
4652 const dirAtStart = STATE.currentDir;
4653 if (!dirAtStart) return;
4654
4655 const videoItems = (STATE.items || []).filter((item) =>
4656 item && !item.isDir && VIDEO_EXTS.has(extOf(item.name || ''))
4657 );
4658 if (!videoItems.length) return;
4659
4660 const loadId = ++STATE.watchedLoadId;
4661
4662 let statusMap = null;
4663 const filePaths = videoItems.map((item) => item.path);
4664
4665 const bulk = await api('POST', '/files/watched-statuses', { filePaths }).catch(() => null);
4666 if (bulk && bulk.statuses && typeof bulk.statuses === 'object')
4667 {
4668 statusMap = {};
4669 for (const item of videoItems)
4670 {
4671 const status = String(bulk.statuses[item.path] || '').toLowerCase();
4672 statusMap[item.path] = status === 'fully' || status === 'partway' ? status : null;
4673 }
4674 }
4675
4676 // Compatibility fallback for older servers that do not expose bulk statuses yet.
4677 if (!statusMap)
4678 {
4679 statusMap = {};
4680 const statuses = await Promise.all(videoItems.map(async (item) =>
4681 {
4682 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`).catch(() => null);
4683 return {
4684 path: item.path,
4685 status: watchStatusFromWatchedBy(meta && meta.watchedBy),
4686 };
4687 }));
4688
4689 for (const entry of statuses)
4690 {
4691 statusMap[entry.path] = entry.status;
4692 }
4693 }
4694
4695 if (loadId !== STATE.watchedLoadId) return;
4696 if (!samePath(STATE.currentDir, dirAtStart)) return;
4697 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return;
4698
4699 for (const item of videoItems)
4700 {
4701 const status = statusMap[item.path] || null;
4702 if (status) STATE.watchedStatusByPath[item.path] = status;
4703 else delete STATE.watchedStatusByPath[item.path];
4704
4705 const iconEl = findTileIconByPath(item.path);
4706 renderWatchedOverlayOnIcon(iconEl, status);
4707 }
4708}
4709
4710function watchedEyeFilledSvg ()
4711{
4712 return `<svg class="watched-overlay-svg" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false"><path fill="#ffffff" d="M651.669528 512c0-14.5903-2.084475-28.290323-6.251378-41.395806-11.019984 24.423249-35.143405 41.395806-63.733557 41.395806l-7.440459-0.593518-5.957689 0.593518c-30.973432 0-56.285934-25.607214-56.285934-56.882522l0.297782-5.952572-0.297782-7.447623c0-28.290323 16.97665-52.709479 41.097-63.727417-13.104459-4.172019-26.802436-6.252401-41.097-6.252401-77.132728 0-139.67311 62.834071-139.67311 140.263557 0 77.428464 62.540382 139.971915 139.67311 139.971915S651.669528 589.428464 651.669528 512L651.669528 512zM958.70846 512c0 0-153.36904-297.80564-448.198905-297.80564-293.63669 0-445.219037 297.80564-445.219037 297.80564s164.385954 297.804616 447.306582 297.804616C805.038568 809.80564 958.70846 512 958.70846 512L958.70846 512zM304.725748 512c0-114.954125 92.619444-208.164017 207.27374-208.164017 114.657366 0 207.27067 93.209892 207.27067 208.164017 0 114.953102-92.613304 208.167087-207.27067 208.167087C397.345192 720.167087 304.725748 626.953102 304.725748 512L304.725748 512zM304.725748 512"/></svg>`;
4713}
4714
4715// ───────────────────────────────────────────────────────────────────────────
4716// EVENT WIRING
4717// ───────────────────────────────────────────────────────────────────────────
4718
4719// ───────────────────────────────────────────────────────────────────────────
4720// THUMBNAIL PREVIEWS
4721// ───────────────────────────────────────────────────────────────────────────
4722
4723function revokeThumbnails ()
4724{
4725 STATE.thumbnailUrls.forEach(u => URL.revokeObjectURL(u));
4726 STATE.thumbnailUrls = [];
4727}
4728
4729function disconnectThumbnailObserver ()
4730{
4731 if (!STATE.thumbnailObserver) return;
4732 STATE.thumbnailObserver.disconnect();
4733 STATE.thumbnailObserver = null;
4734}
4735
4736function disconnectFolderIconObserver ()
4737{
4738 if (!STATE.folderIconObserver) return;
4739 STATE.folderIconObserver.disconnect();
4740 STATE.folderIconObserver = null;
4741}
4742
4743function setThumbnailPending (iconEl, pending)
4744{
4745 if (!iconEl) return;
4746 if (pending)
4747 {
4748 iconEl.classList.add('thumb-pending');
4749 iconEl.dataset.thumbPending = '1';
4750 return;
4751 }
4752
4753 iconEl.classList.remove('thumb-pending');
4754 delete iconEl.dataset.thumbPending;
4755}
4756
4757function getThumbnailKind (name)
4758{
4759 const ext = extOf(name || '');
4760 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || MODEL_EXTS.has(ext)) return 'image';
4761 if (CODE_EXTS.has(ext)) return 'text';
4762 return 'badge';
4763}
4764
4765function maxThumbBytesForKind (kind)
4766{
4767 if (kind === 'image') return 15 * 1024 * 1024;
4768 if (kind === 'text') return 1024 * 1024;
4769 return 0;
4770}
4771
4772function drawTokenizedLine (ctx, line, x, y)
4773{
4774 const tokenRe = /(\/\/.*$|\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b(?:function|return|if|else|for|while|switch|case|break|continue|const|let|var|class|new|import|from|export|default|try|catch|finally|throw|await|async|true|false|null|undefined)\b|\b\d+(?:\.\d+)?\b)/g;
4775 let last = 0;
4776 let cursor = x;
4777 for (const m of line.matchAll(tokenRe))
4778 {
4779 const i = m.index == null ? 0 : m.index;
4780 if (i > last)
4781 {
4782 const plain = line.slice(last, i);
4783 ctx.fillStyle = '#dce4ff';
4784 ctx.fillText(plain, cursor, y);
4785 cursor += ctx.measureText(plain).width;
4786 }
4787
4788 const tok = m[0];
4789 if (/^\/\//.test(tok) || /^\/\*/.test(tok)) ctx.fillStyle = '#6f7f9a';
4790 else if (/^['"`]/.test(tok)) ctx.fillStyle = '#9ee37d';
4791 else if (/^\d/.test(tok)) ctx.fillStyle = '#f8c46a';
4792 else ctx.fillStyle = '#8bb4ff';
4793
4794 ctx.fillText(tok, cursor, y);
4795 cursor += ctx.measureText(tok).width;
4796 last = i + tok.length;
4797 }
4798
4799 if (last < line.length)
4800 {
4801 const tail = line.slice(last);
4802 ctx.fillStyle = '#dce4ff';
4803 ctx.fillText(tail, cursor, y);
4804 }
4805}
4806
4807function textThumbnailDataUrl (text)
4808{
4809 const canvas = document.createElement('canvas');
4810 canvas.width = 160;
4811 canvas.height = 200;
4812 const ctx = canvas.getContext('2d');
4813 if (!ctx) return null;
4814
4815 ctx.fillStyle = '#0d111a';
4816 ctx.fillRect(0, 0, canvas.width, canvas.height);
4817 ctx.font = '8px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace';
4818 ctx.textBaseline = 'top';
4819
4820 const lines = String(text || '')
4821 .replace(/\r\n/g, '\n')
4822 .split('\n')
4823 .slice(0, 17);
4824
4825 let y = 8;
4826 for (const line of lines)
4827 {
4828 drawTokenizedLine(ctx, line.slice(0, 42), 6, y);
4829 y += 11;
4830 if (y > 190) break;
4831 }
4832 return canvas.toDataURL('image/png');
4833}
4834
4835function badgeThumbnailDataUrl (name, kind)
4836{
4837 const canvas = document.createElement('canvas');
4838 canvas.width = 160;
4839 canvas.height = 200;
4840 const ctx = canvas.getContext('2d');
4841 if (!ctx) return null;
4842
4843 const ext = (extOf(name || '') || 'file').toUpperCase().slice(0, 5);
4844 const color = '#5b7fff';
4845
4846 ctx.fillStyle = '#111826';
4847 ctx.fillRect(0, 0, 160, 200);
4848 ctx.fillStyle = color;
4849 ctx.fillRect(0, 0, 160, 28);
4850 ctx.fillStyle = '#ffffff';
4851 ctx.font = 'bold 12px sans-serif';
4852 ctx.textAlign = 'center';
4853 ctx.fillText(ext, 80, 8);
4854 ctx.textAlign = 'left';
4855 ctx.fillStyle = '#9fb1d8';
4856 ctx.font = '10px sans-serif';
4857 ctx.fillText('Preview', 8, 48);
4858 ctx.fillStyle = '#dce4ff';
4859 ctx.font = 'bold 11px sans-serif';
4860 ctx.fillText(ext, 8, 66);
4861 return canvas.toDataURL('image/png');
4862}
4863
4864async function buildThumbnailSource (item, blob, kind)
4865{
4866 if (kind === 'text') return textThumbnailDataUrl(await blob.text());
4867 return badgeThumbnailDataUrl(item.name, kind);
4868}
4869
4870function observeThumbnailIcon (iconEl)
4871{
4872 if (!iconEl || !iconEl.isConnected) return;
4873 if (iconEl.dataset.thumbReady === '1') return;
4874
4875 if (!('IntersectionObserver' in window))
4876 {
4877 void loadOneThumbnail(iconEl);
4878 return;
4879 }
4880
4881 if (!STATE.thumbnailObserver)
4882 {
4883 STATE.thumbnailObserver = new IntersectionObserver((entries) =>
4884 {
4885 for (const entry of entries)
4886 {
4887 if (!entry.isIntersecting) continue;
4888 const icon = entry.target;
4889 STATE.thumbnailObserver.unobserve(icon);
4890 void loadOneThumbnail(icon);
4891 }
4892 }, { root: null, rootMargin: THUMB_OBSERVER_ROOT_MARGIN, threshold: 0.01 });
4893 }
4894
4895 STATE.thumbnailObserver.observe(iconEl);
4896}
4897
4898async function loadThumbnails ()
4899{
4900 const icons = Array.from(document.querySelectorAll('.icon[data-preview-path]'));
4901 for (const icon of icons)
4902 {
4903 observeThumbnailIcon(icon);
4904 }
4905
4906 const folderIcons = Array.from(document.querySelectorAll('.icon[data-folder-path]'));
4907 for (const icon of folderIcons)
4908 {
4909 observeFolderIcon(icon);
4910 }
4911}
4912
4913async function loadOneThumbnail (iconEl)
4914{
4915 if (!iconEl.isConnected || !STATE.token) return;
4916 if (iconEl.dataset.thumbReady === '1') return;
4917 const filePath = iconEl.dataset.previewPath;
4918 const item = STATE.items.find(i => i.path === filePath);
4919 if (!item) return;
4920
4921 const kind = getThumbnailKind(item.name);
4922 let srcUrl = null;
4923
4924 if (kind === 'badge')
4925 {
4926 setThumbnailPending(iconEl, false);
4927 srcUrl = badgeThumbnailDataUrl(item.name, kind);
4928 }
4929 else if (kind === 'image')
4930 {
4931 const ext = extOf(item.name || '');
4932 const useDirectSource =
4933 ext === 'ico' ||
4934 (
4935 ext === 'svg' &&
4936 typeof item.size === 'number' &&
4937 item.size > 0 &&
4938 item.size <= MAX_DIRECT_SVG_THUMB_BYTES
4939 );
4940
4941 const url = useDirectSource
4942 ? `/api/files/download?file=${encodeURIComponent(filePath)}`
4943 : `/api/files/thumbnail?file=${encodeURIComponent(filePath)}`;
4944
4945 let res;
4946 try
4947 {
4948 res = await fetch(url, {
4949 headers: {
4950 Authorization: `Bearer ${STATE.token}`,
4951 'X-Fp': getFingerprint(),
4952 },
4953 });
4954 } catch
4955 {
4956 return;
4957 }
4958
4959 if (!useDirectSource && res.status === 404)
4960 {
4961 setThumbnailPending(iconEl, true);
4962 return;
4963 }
4964
4965 if (!res.ok || !iconEl.isConnected) return;
4966 setThumbnailPending(iconEl, false);
4967
4968 const blob = await res.blob();
4969 srcUrl = URL.createObjectURL(blob);
4970 STATE.thumbnailUrls.push(srcUrl);
4971 }
4972 else
4973 {
4974 setThumbnailPending(iconEl, false);
4975 const maxBytes = maxThumbBytesForKind(kind);
4976 if (maxBytes > 0 && typeof item.size === 'number' && item.size > maxBytes)
4977 {
4978 srcUrl = badgeThumbnailDataUrl(item.name, kind);
4979 } else
4980 {
4981 const url = `/api/files/download?file=${encodeURIComponent(filePath)}`;
4982
4983 let res;
4984 try
4985 {
4986 res = await fetch(url, {
4987 headers: {
4988 Authorization: `Bearer ${STATE.token}`,
4989 'X-Fp': getFingerprint(),
4990 },
4991 });
4992 } catch { return; }
4993 if (!res.ok || !iconEl.isConnected) return;
4994
4995 const blob = await res.blob();
4996 srcUrl = await buildThumbnailSource(item, blob, kind);
4997 }
4998 }
4999 if (!srcUrl || !iconEl.isConnected) return;
5000
5001 const svg = iconEl.querySelector('svg');
5002 if (!svg)
5003 {
5004 if (srcUrl.startsWith('blob:')) URL.revokeObjectURL(srcUrl);
5005 return;
5006 }
5007
5008 const NS = 'http://www.w3.org/2000/svg';
5009 const id = `fcp-${Math.random().toString(36).slice(2, 9)}`;
5010
5011 // clipPath matches the main file body outline exactly (viewBox 0 0 24 24)
5012 const defs = document.createElementNS(NS, 'defs');
5013 const clipPath = document.createElementNS(NS, 'clipPath');
5014 clipPath.setAttribute('id', id);
5015 clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
5016 const clipShape = document.createElementNS(NS, 'path');
5017 clipShape.setAttribute('d', 'M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z');
5018 clipPath.appendChild(clipShape);
5019 defs.appendChild(clipPath);
5020
5021 // Image fills the file bounding box; clip keeps it inside the outline
5022 const img = document.createElementNS(NS, 'image');
5023 img.setAttribute('href', srcUrl);
5024 img.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', srcUrl);
5025 img.setAttribute('x', '4');
5026 img.setAttribute('y', '2');
5027 img.setAttribute('width', '16');
5028 img.setAttribute('height', '20');
5029 img.setAttribute('clip-path', `url(#${id})`);
5030 img.setAttribute('preserveAspectRatio', 'xMidYMid slice');
5031
5032 // Prepend so existing path/polyline elements (the outline) render on top
5033 svg.prepend(img);
5034 svg.prepend(defs);
5035 iconEl.dataset.thumbReady = '1';
5036}
5037
5038// ───────────────────────────────────────────────────────────────────────────
5039// FOLDER ICON THUMBNAILS
5040// ───────────────────────────────────────────────────────────────────────────
5041
5042function observeFolderIcon (iconEl)
5043{
5044 if (!iconEl || !iconEl.isConnected) return;
5045 if (iconEl.dataset.thumbReady === '1') return;
5046
5047 if (!('IntersectionObserver' in window))
5048 {
5049 void loadOneFolderIcon(iconEl);
5050 return;
5051 }
5052
5053 if (!STATE.folderIconObserver)
5054 {
5055 STATE.folderIconObserver = new IntersectionObserver((entries) =>
5056 {
5057 for (const entry of entries)
5058 {
5059 if (!entry.isIntersecting) continue;
5060 const icon = entry.target;
5061 STATE.folderIconObserver.unobserve(icon);
5062 void loadOneFolderIcon(icon);
5063 }
5064 }, { root: null, rootMargin: THUMB_OBSERVER_ROOT_MARGIN, threshold: 0.01 });
5065 }
5066
5067 STATE.folderIconObserver.observe(iconEl);
5068}
5069
5070async function loadOneFolderIcon (iconEl)
5071{
5072 if (!iconEl.isConnected || !STATE.token) return;
5073 if (iconEl.dataset.thumbReady === '1') return;
5074
5075 const folderPath = iconEl.dataset.folderPath;
5076 if (!folderPath) return;
5077
5078 let res;
5079 try
5080 {
5081 res = await fetch(`/api/files/folder-icon?dir=${encodeURIComponent(folderPath)}`, {
5082 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
5083 });
5084 } catch { return; }
5085
5086 if (!res.ok || !iconEl.isConnected) return;
5087
5088 const data = await res.json();
5089 if (!data.icon) return; // No icon available — keep plain folder SVG.
5090
5091 // Fetch the thumbnail through the auth-gated endpoint.
5092 let thumbRes;
5093 try
5094 {
5095 thumbRes = await fetch(
5096 `/api/files/thumbnail?file=${encodeURIComponent(data.icon.filePath)}`,
5097 { headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() } },
5098 );
5099 } catch { return; }
5100
5101 if (!thumbRes.ok || !iconEl.isConnected) return;
5102
5103 const blob = await thumbRes.blob();
5104 const srcUrl = URL.createObjectURL(blob);
5105 STATE.thumbnailUrls.push(srcUrl);
5106
5107 applyFolderThumbnail(iconEl, srcUrl);
5108}
5109
5110/**
5111 * Overlays a thumbnail image inside the folder SVG outline.
5112 * The folder viewBox is 0 0 24 24; the folder body covers roughly x=2,y=5 to x=22,y=21.
5113 */
5114function applyFolderThumbnail (iconEl, srcUrl)
5115{
5116 if (!iconEl.isConnected) return;
5117 const svg = iconEl.querySelector('svg');
5118 if (!svg)
5119 {
5120 if (srcUrl.startsWith('blob:')) URL.revokeObjectURL(srcUrl);
5121 return;
5122 }
5123
5124 const NS = 'http://www.w3.org/2000/svg';
5125 const id = `fcp-${Math.random().toString(36).slice(2, 9)}`;
5126
5127 const defs = document.createElementNS(NS, 'defs');
5128 const clipPath = document.createElementNS(NS, 'clipPath');
5129 clipPath.setAttribute('id', id);
5130 clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
5131 const clipShape = document.createElementNS(NS, 'path');
5132 // Folder outline path (same as iconFolder SVG path)
5133 clipShape.setAttribute('d', 'M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z');
5134 clipPath.appendChild(clipShape);
5135 defs.appendChild(clipPath);
5136
5137 // Image covers the folder body area; clip keeps it inside the outline.
5138 const img = document.createElementNS(NS, 'image');
5139 img.setAttribute('href', srcUrl);
5140 img.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', srcUrl);
5141 img.setAttribute('x', '2');
5142 img.setAttribute('y', '3');
5143 img.setAttribute('width', '20');
5144 img.setAttribute('height', '18');
5145 img.setAttribute('clip-path', `url(#${id})`);
5146 img.setAttribute('preserveAspectRatio', 'xMidYMid slice');
5147
5148 // Prepend so the folder outline strokes render on top.
5149 svg.prepend(img);
5150 svg.prepend(defs);
5151 iconEl.dataset.thumbReady = '1';
5152}
5153
5154function wireEvents ()
5155{
5156 // Auth form
5157 document.getElementById('auth-form').addEventListener('submit', async (e) =>
5158 {
5159 e.preventDefault();
5160 const username = document.getElementById('auth-username').value.trim();
5161 const password = document.getElementById('auth-password').value;
5162 const isSetup = e.target.dataset.mode === 'setup';
5163 const errEl = document.getElementById('auth-error');
5164 const btn = document.getElementById('auth-submit');
5165 btn.disabled = true;
5166 btn.textContent = 'Please wait…';
5167 const err = await doLogin(username, password, isSetup);
5168 if (err)
5169 {
5170 errEl.textContent = err;
5171 errEl.classList.remove('hidden');
5172 btn.disabled = false;
5173 btn.textContent = isSetup ? 'Create Account' : 'Sign In';
5174 }
5175 });
5176
5177 // Logout
5178 document.getElementById('btn-logout').addEventListener('click', logout);
5179
5180 // Hard refresh while keeping auth/session state.
5181 document.getElementById('btn-refresh').addEventListener('click', () =>
5182 {
5183 saveSessionState();
5184 location.reload();
5185 });
5186
5187 // Upload button
5188 document.getElementById('btn-upload').addEventListener('click', () =>
5189 {
5190 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5191 if (!canWrite()) { toast('No write access.', 'err'); return; }
5192 document.getElementById('file-input').click();
5193 });
5194
5195 document.getElementById('file-input').addEventListener('change', async (e) =>
5196 {
5197 if (e.target.files.length) await uploadFiles(e.target.files);
5198 e.target.value = '';
5199 });
5200
5201 document.getElementById('btn-upload-folder').addEventListener('click', () =>
5202 {
5203 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5204 if (!canWrite()) { toast('No write access.', 'err'); return; }
5205 document.getElementById('folder-input').click();
5206 });
5207
5208 document.getElementById('folder-input').addEventListener('change', async (e) =>
5209 {
5210 if (e.target.files.length) await uploadFolderInputFiles(e.target.files);
5211 e.target.value = '';
5212 });
5213
5214 document.getElementById('btn-new-folder').addEventListener('click', async () =>
5215 {
5216 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5217 if (!canWrite()) { toast('No write access.', 'err'); return; }
5218
5219 const name = await showPrompt('New Folder', 'Enter a name for the new folder:');
5220 if (name == null) return;
5221 const folderName = name.trim();
5222 if (!folderName)
5223 {
5224 toast('Folder name is required.', 'err');
5225 return;
5226 }
5227
5228 try
5229 {
5230 await api('POST', '/files/mkdir', { dir: STATE.currentDir, name: folderName });
5231 toast('Folder created.', 'ok');
5232 await navigateTo(STATE.currentDir, STATE.currentRoot);
5233 } catch (err)
5234 {
5235 toast(err.message, 'err');
5236 }
5237 });
5238
5239 document.getElementById('sidebar-close').addEventListener('click', (e) =>
5240 {
5241 e.stopPropagation();
5242 hideSidebarPanel();
5243 });
5244
5245 const mobileQuery = window.matchMedia(MOBILE_BREAKPOINT_QUERY);
5246 const syncSidebarForViewport = () =>
5247 {
5248 if (isMobileViewport())
5249 {
5250 hideSidebarPanel();
5251 return;
5252 }
5253
5254 if (!STATE.selectedItem) openFolderSidebar();
5255 };
5256
5257 if (typeof mobileQuery.addEventListener === 'function')
5258 {
5259 mobileQuery.addEventListener('change', syncSidebarForViewport);
5260 } else if (typeof mobileQuery.addListener === 'function')
5261 {
5262 mobileQuery.addListener(syncSidebarForViewport);
5263 }
5264
5265 // Click outside grid clears selection and returns to folder sidebar info.
5266 document.getElementById('main-content').addEventListener('click', (e) =>
5267 {
5268 if (!e.target.closest('.file-item')) closeSidebar();
5269 });
5270
5271 // Admin panel
5272 document.getElementById('btn-admin').addEventListener('click', openAdminModal);
5273 document.getElementById('admin-modal-close').addEventListener('click', () =>
5274 document.getElementById('admin-modal').classList.add('hidden'));
5275
5276 // Add path
5277 document.getElementById('admin-add-path').addEventListener('click', () =>
5278 {
5279 const val = document.getElementById('admin-new-path').value.trim();
5280 if (!val) return;
5281 const row = document.createElement('div');
5282 row.className = 'path-row';
5283 row.innerHTML = `<span>${val}</span><button title="Remove">✕</button>`;
5284 row.querySelector('button').addEventListener('click', () => row.remove());
5285 document.getElementById('admin-paths').appendChild(row);
5286 document.getElementById('admin-new-path').value = '';
5287 });
5288
5289 // Save paths
5290 document.getElementById('admin-save-paths').addEventListener('click', async () =>
5291 {
5292 const rows = document.querySelectorAll('#admin-paths .path-row span');
5293 const paths = [...rows].map(s => s.textContent.trim()).filter(Boolean);
5294 try
5295 {
5296 await api('PUT', '/admin/config', { paths });
5297 toast('Paths saved.', 'ok');
5298 await loadRoots();
5299 } catch (err) { toast(err.message, 'err'); }
5300 });
5301
5302 const sizeInput = document.getElementById('admin-user-size-limit');
5303 if (sizeInput)
5304 {
5305 sizeInput.addEventListener('input', () =>
5306 {
5307 updateAdminSizeFeedback(sizeInput.value);
5308 });
5309 }
5310
5311 document.getElementById('admin-save-userpath').addEventListener('click', async () =>
5312 {
5313 const rows = document.querySelectorAll('#admin-paths .path-row span');
5314 const paths = [...rows].map(s => s.textContent.trim()).filter(Boolean);
5315 const userPath = document.getElementById('admin-user-path').value.trim();
5316 const rawLimit = document.getElementById('admin-user-size-limit').value.trim();
5317 const parsed = updateAdminSizeFeedback(rawLimit);
5318 if (!parsed.valid)
5319 {
5320 toast('Please enter a valid user size limit.', 'err');
5321 return;
5322 }
5323
5324 try
5325 {
5326 await api('PUT', '/admin/config', {
5327 paths,
5328 userPath: userPath || null,
5329 userFolderSizeLimit: rawLimit ? parsed.bytes : null,
5330 });
5331 toast('User folder settings saved.', 'ok');
5332 await loadRoots();
5333 await refreshAdminConfig();
5334 }
5335 catch (err)
5336 {
5337 toast(err.message, 'err');
5338 }
5339 });
5340
5341 // Shutdown / restart server
5342 document.getElementById('admin-shutdown-btn').addEventListener('click', async () =>
5343 {
5344 const status = _adminUpdateStatus;
5345
5346 if (!status || !status.underSystemd)
5347 {
5348 // Not running under systemd — plain shutdown (manual restart required).
5349 if (!await showConfirm('Shut down server', 'Shut down the server? You will lose access until it is restarted manually.')) return;
5350 }
5351 else if (status.commitsAhead.length === 0)
5352 {
5353 // Under systemd, no updates — restart only.
5354 if (!await showConfirm('Restart server', 'No update available. Would you like to restart?', { okLabel: 'Restart' })) return;
5355 }
5356 else
5357 {
5358 // Under systemd, updates available.
5359 const commitList = status.commitsAhead.map(c => escHtml(c)).join('<br/>');
5360 const msg = `Updates available:<br/><br/>${commitList}<br/><br/>Update now?`;
5361 if (!await showConfirm('Restart &amp; Update', msg, { html: true, okLabel: 'Update now' })) return;
5362 }
5363
5364 try
5365 {
5366 await api('POST', '/admin/shutdown');
5367 const toastMsg = (!status || !status.underSystemd)
5368 ? 'Server is shutting down\u2026'
5369 : status.commitsAhead.length > 0
5370 ? 'Server is updating and restarting\u2026'
5371 : 'Server is restarting\u2026';
5372 toast(toastMsg, 'ok');
5373 document.getElementById('admin-modal').classList.add('hidden');
5374 } catch
5375 {
5376 // Fetch may throw because the connection closes before a response arrives.
5377 const toastMsg = (!status || !status.underSystemd)
5378 ? 'Server is shutting down\u2026'
5379 : status.commitsAhead.length > 0
5380 ? 'Server is updating and restarting\u2026'
5381 : 'Server is restarting\u2026';
5382 toast(toastMsg, 'ok');
5383 document.getElementById('admin-modal').classList.add('hidden');
5384 }
5385 setTimeout(() => location.reload(), 3000);
5386 });
5387
5388 // New user
5389 document.getElementById('admin-new-user-btn').addEventListener('click', async () =>
5390 {
5391 const cfg = await api('GET', '/admin/config');
5392 const paths = cfg ? (cfg.effectivePaths || []) : [];
5393 openUserModal(null, paths);
5394 });
5395
5396 // User modal close
5397 document.getElementById('user-modal-close').addEventListener('click', () =>
5398 document.getElementById('user-modal').classList.add('hidden'));
5399
5400 // Rename modal close
5401 document.getElementById('rename-modal-close').addEventListener('click', () =>
5402 document.getElementById('rename-modal').classList.add('hidden'));
5403
5404 // Close modals on backdrop click
5405 document.querySelectorAll('.modal-overlay').forEach(overlay =>
5406 {
5407 overlay.addEventListener('click', e =>
5408 {
5409 if (e.target === overlay) overlay.classList.add('hidden');
5410 });
5411 });
5412}
5413
5414// ───────────────────────────────────────────────────────────────────────────
5415// BOOT
5416// ───────────────────────────────────────────────────────────────────────────
5417
5418(async function boot ()
5419{
5420 wireEvents();
5421 initDragDrop();
5422 window.addEventListener('beforeunload', () =>
5423 {
5424 saveSessionState();
5425 releaseActivePreviewVideoStreamSession({ keepalive: true });
5426 });
5427 window.addEventListener('pagehide', () =>
5428 {
5429 releaseActivePreviewVideoStreamSession({ keepalive: true });
5430 });
5431 await initAuth();
5432})();