BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

app.js 215.5 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 // Cross-root file search mode (null = regular folder browsing).
68 searchQuery: null,
69
70 // Bust cache when favicon changes.
71 faviconVersion: Date.now(),
72};
73
74const SESSION_KEY = 'filemanager.session.v1';
75const SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
76const CLIENT_BINDING_KEY = 'filemanager.client-binding-id.v1';
77const MOBILE_BREAKPOINT_QUERY = '(max-width: 600px)';
78const MOBILE_LONG_PRESS_MS = 420;
79const MOBILE_LONG_PRESS_MOVE_THRESHOLD = 10;
80const THUMB_OBSERVER_ROOT_MARGIN = '120px';
81const VIDEO_PREFS_KEY_PREFIX = 'filemanager.video-prefs.v1.';
82const FOLDER_VIEW_PREFS_KEY_PREFIX = 'filemanager.folder-view-prefs.v1.';
83const VIDEO_TEXT_TRACK_SETTINGS_KEY = 'vjs-text-track-settings';
84const VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW = JSON.stringify({
85 backgroundOpacity: '0',
86 edgeStyle: 'uniform',
87});
88const DEFAULT_FOLDER_VIEW_PREFS = {
89 sortBy: 'alphabetical',
90 groupBy: 'none',
91 foldersFirst: true,
92 ascending: true,
93};
94const FOLDER_SORT_OPTIONS = [
95 { value: 'alphabetical', label: 'Alphabetically' },
96 { value: 'fileType', label: 'File type' },
97 { value: 'lastChanged', label: 'Last changed' },
98 { value: 'timeUploaded', label: 'Time uploaded' },
99 { value: 'size', label: 'Size' },
100];
101const FOLDER_GROUP_OPTIONS = [
102 { value: 'none', label: 'None' },
103 { value: 'alphabetical', label: 'Alphabetically' },
104 { value: 'fileType', label: 'File type' },
105 { value: 'lastChangedDate', label: 'Last changed date' },
106 { value: 'timeUploadedDate', label: 'Upload date' },
107 { value: 'size', label: 'Size' },
108];
109const VIDEO_FORWARD_BUFFER_SECONDS = 60 * 60;
110const VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED = false;
111let videoJsLoaderPromise = null;
112let threePreviewModulesPromise = null;
113
114// ───────────────────────────────────────────────────────────────────────────
115// CRYPTO HELPERS (Web Crypto API)
116// ───────────────────────────────────────────────────────────────────────────
117
118async function generateClientKeyPair ()
119{
120 if (!hasWebCrypto()) return;
121 const kp = await crypto.subtle.generateKey(
122 { name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
123 true,
124 ['encrypt', 'decrypt'],
125 );
126 STATE.clientPrivateKey = kp.privateKey;
127 STATE.clientPublicKeyJwk = await crypto.subtle.exportKey('jwk', kp.publicKey);
128}
129
130/**
131 * Hybrid-encrypt a JS object using the server's RSA public key.
132 * Returns { encryptedKey, iv, ciphertext, tag } all as base64 strings.
133 */
134async function hybridEncryptForServer (obj)
135{
136 if (!hasWebCrypto() || !STATE.serverPublicKeyJwk)
137 {
138 return { plaintext: obj };
139 }
140
141 const serverPub = await crypto.subtle.importKey(
142 'jwk', STATE.serverPublicKeyJwk,
143 { name: 'RSA-OAEP', hash: 'SHA-256' },
144 false, ['encrypt'],
145 );
146
147 const plaintext = new TextEncoder().encode(JSON.stringify(obj));
148 const aesKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
149 const iv = crypto.getRandomValues(new Uint8Array(12));
150 const gcmResult = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, aesKey, plaintext);
151
152 // gcmResult = ciphertext || tag (last 16 bytes are auth tag)
153 const gcmBytes = new Uint8Array(gcmResult);
154 const ciphertext = gcmBytes.slice(0, gcmBytes.length - 16);
155 const tag = gcmBytes.slice(gcmBytes.length - 16);
156
157 const rawAes = await crypto.subtle.exportKey('raw', aesKey);
158 const encryptedKey = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, serverPub, rawAes);
159
160 return {
161 encryptedKey: b64(encryptedKey),
162 iv: b64(iv),
163 ciphertext: b64(ciphertext),
164 tag: b64(tag),
165 };
166}
167
168/**
169 * Hybrid-decrypt a payload encrypted by the server for us (using our public key).
170 */
171async function hybridDecryptFromServer (payload)
172{
173 if (!payload) return null;
174 if (payload.token) return payload.token;
175 if (!hasWebCrypto()) return null;
176
177 const encryptedKey = unb64(payload.encryptedKey);
178 const iv = unb64(payload.iv);
179 const ciphertext = unb64(payload.ciphertext);
180 const tag = unb64(payload.tag);
181
182 const rawAes = await crypto.subtle.decrypt(
183 { name: 'RSA-OAEP' }, STATE.clientPrivateKey, encryptedKey,
184 );
185
186 const aesKey = await crypto.subtle.importKey('raw', rawAes, { name: 'AES-GCM' }, false, ['decrypt']);
187
188 // Recombine ciphertext + tag for AES-GCM
189 const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
190 combined.set(new Uint8Array(ciphertext));
191 combined.set(new Uint8Array(tag), ciphertext.byteLength);
192
193 const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, aesKey, combined);
194 return new TextDecoder().decode(plain);
195}
196
197// ───────────────────────────────────────────────────────────────────────────
198// UTIL
199// ───────────────────────────────────────────────────────────────────────────
200
201function b64 (buf)
202{
203 return btoa(String.fromCharCode(...new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer)));
204}
205
206function hasWebCrypto ()
207{
208 return !!(window.crypto && window.crypto.subtle);
209}
210
211function unb64 (str)
212{
213 const binary = atob(str);
214 const buf = new Uint8Array(binary.length);
215 for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
216 return buf.buffer;
217}
218
219/** Stable browser fingerprint (not stored, derived fresh each load) */
220function getFingerprint ()
221{
222 const binding = getOrCreateClientBindingId();
223 const nav = navigator;
224
225 // Keep this stable: avoid viewport/screen metrics that can change when
226 // devtools opens, orientation changes, or window state changes.
227 return [
228 binding,
229 nav.userAgent || '',
230 nav.language,
231 nav.platform || nav.userAgentData?.platform || '',
232 Intl.DateTimeFormat().resolvedOptions().timeZone,
233 ].join('|');
234}
235
236function randomIdHex (bytes = 16)
237{
238 const arr = new Uint8Array(bytes);
239 if (window.crypto && typeof window.crypto.getRandomValues === 'function')
240 {
241 window.crypto.getRandomValues(arr);
242 } else
243 {
244 for (let i = 0; i < arr.length; i++) arr[i] = Math.floor(Math.random() * 256);
245 }
246 return Array.from(arr).map(n => n.toString(16).padStart(2, '0')).join('');
247}
248
249function userVideoPrefsKey ()
250{
251 const name = String(STATE.username || 'anonymous').trim().toLowerCase() || 'anonymous';
252 return VIDEO_PREFS_KEY_PREFIX + name;
253}
254
255function loadUserVideoPrefs ()
256{
257 try
258 {
259 const raw = localStorage.getItem(userVideoPrefsKey());
260 const parsed = raw ? JSON.parse(raw) : {};
261 if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
262 return parsed;
263 } catch
264 {
265 return {};
266 }
267}
268
269function saveUserVideoPrefs (patch)
270{
271 try
272 {
273 const current = loadUserVideoPrefs();
274 localStorage.setItem(userVideoPrefsKey(), JSON.stringify({ ...current, ...(patch || {}) }));
275 } catch
276 {
277 // Ignore localStorage failures.
278 }
279}
280
281function userFolderViewPrefsKey ()
282{
283 const name = String(STATE.username || 'anonymous').trim().toLowerCase() || 'anonymous';
284 return FOLDER_VIEW_PREFS_KEY_PREFIX + name;
285}
286
287function normaliseFolderViewPrefs (value)
288{
289 const input = value && typeof value === 'object' ? value : {};
290 const sortBy = ['alphabetical', 'fileType', 'lastChanged', 'timeUploaded', 'size'].includes(input.sortBy)
291 ? input.sortBy
292 : DEFAULT_FOLDER_VIEW_PREFS.sortBy;
293 const groupBy = ['none', 'alphabetical', 'fileType', 'lastChangedDate', 'timeUploadedDate', 'size'].includes(input.groupBy)
294 ? input.groupBy
295 : DEFAULT_FOLDER_VIEW_PREFS.groupBy;
296
297 return {
298 sortBy,
299 groupBy,
300 foldersFirst: input.foldersFirst !== undefined ? !!input.foldersFirst : DEFAULT_FOLDER_VIEW_PREFS.foldersFirst,
301 ascending: input.ascending !== undefined ? !!input.ascending : DEFAULT_FOLDER_VIEW_PREFS.ascending,
302 };
303}
304
305function loadFolderViewPrefsMap ()
306{
307 try
308 {
309 const raw = localStorage.getItem(userFolderViewPrefsKey());
310 const parsed = raw ? JSON.parse(raw) : {};
311 if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
312
313 const out = {};
314 for (const [dirPath, prefs] of Object.entries(parsed))
315 {
316 out[String(dirPath)] = normaliseFolderViewPrefs(prefs);
317 }
318 return out;
319 } catch
320 {
321 return {};
322 }
323}
324
325function saveFolderViewPrefsMap (prefsByPath)
326{
327 try
328 {
329 localStorage.setItem(userFolderViewPrefsKey(), JSON.stringify(prefsByPath || {}));
330 } catch
331 {
332 // Ignore localStorage failures.
333 }
334}
335
336function folderViewPrefsForDir (dirPath)
337{
338 if (!dirPath) return { ...DEFAULT_FOLDER_VIEW_PREFS };
339 const prefsByPath = loadFolderViewPrefsMap();
340 return normaliseFolderViewPrefs(prefsByPath[String(dirPath)] || DEFAULT_FOLDER_VIEW_PREFS);
341}
342
343function saveFolderViewPrefsForDir (dirPath, patch)
344{
345 if (!dirPath) return;
346 const key = String(dirPath);
347 const prefsByPath = loadFolderViewPrefsMap();
348 const current = normaliseFolderViewPrefs(prefsByPath[key] || DEFAULT_FOLDER_VIEW_PREFS);
349 prefsByPath[key] = normaliseFolderViewPrefs({ ...current, ...(patch || {}) });
350 saveFolderViewPrefsMap(prefsByPath);
351}
352
353function buildAuthHeaders ()
354{
355 const headers = {};
356 if (STATE.token)
357 {
358 headers.Authorization = 'Bearer ' + STATE.token;
359 try
360 {
361 const fp = getFingerprint();
362 if (fp) headers['X-Fp'] = fp;
363 } catch
364 {
365 // Continue without a fingerprint header in constrained test/runtime contexts.
366 }
367 }
368 return headers;
369}
370
371function applyUserVideoTextTrackPrefs ()
372{
373 try
374 {
375 // Only override the two requested defaults and leave other settings at Video.js defaults.
376 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
377 } catch
378 {
379 // Ignore localStorage failures.
380 }
381}
382
383function normaliseTrackName (name)
384{
385 return String(name || '').trim().toLowerCase();
386}
387
388function getTrackName (track)
389{
390 if (!track || typeof track !== 'object') return '';
391 const label = String(track.label || '').trim();
392 if (label) return label;
393 const name = String(track.name || '').trim();
394 if (name) return name;
395 const language = String(track.language || '').trim();
396 if (language) return language;
397 const id = String(track.id || '').trim();
398 if (id) return id;
399 return '';
400}
401
402function trackListToArray (trackList)
403{
404 if (!trackList || typeof trackList.length !== 'number') return [];
405 const out = [];
406 for (let i = 0; i < trackList.length; i++)
407 {
408 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
409 if (track) out.push(track);
410 }
411 return out;
412}
413
414function subtitleTracksFromPlayer (player)
415{
416 if (!player || typeof player.textTracks !== 'function') return [];
417 return trackListToArray(player.textTracks()).filter((track) =>
418 {
419 const kind = String(track.kind || '').toLowerCase();
420 return kind === 'subtitles' || kind === 'captions';
421 });
422}
423
424function audioTracksFromPlayer (player)
425{
426 if (!player || typeof player.audioTracks !== 'function') return [];
427 return trackListToArray(player.audioTracks());
428}
429
430function applySavedSubtitleTrack (player, savedName)
431{
432 if (typeof savedName !== 'string') return;
433 const tracks = subtitleTracksFromPlayer(player);
434 if (!tracks.length) return;
435
436 const wanted = normaliseTrackName(savedName);
437 if (!wanted)
438 {
439 for (const track of tracks) track.mode = 'disabled';
440 return;
441 }
442
443 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
444 if (!match) return;
445
446 for (const track of tracks)
447 {
448 track.mode = track === match ? 'showing' : 'disabled';
449 }
450}
451
452function applySavedAudioTrack (player, savedName)
453{
454 if (typeof savedName !== 'string') return;
455 const tracks = audioTracksFromPlayer(player);
456 if (!tracks.length) return;
457
458 const wanted = normaliseTrackName(savedName);
459 if (!wanted) return;
460
461 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
462 if (!match) return;
463
464 for (const track of tracks)
465 {
466 track.enabled = track === match;
467 }
468}
469
470function getSelectedSubtitleTrackName (player)
471{
472 const tracks = subtitleTracksFromPlayer(player);
473 if (!tracks.length) return null;
474 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
475 return active ? getTrackName(active) : '';
476}
477
478function getSelectedAudioTrackName (player)
479{
480 const tracks = audioTracksFromPlayer(player);
481 if (!tracks.length) return null;
482 const active = tracks.find((track) => !!track.enabled);
483 return active ? getTrackName(active) : '';
484}
485
486function bindUserVideoTrackPrefs (player, prefs)
487{
488 const applySavedTracks = () =>
489 {
490 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
491 applySavedAudioTrack(player, prefs.audioTrackName);
492 };
493
494 const captureSelectedTracks = () =>
495 {
496 const subtitleTrackName = getSelectedSubtitleTrackName(player);
497 const audioTrackName = getSelectedAudioTrackName(player);
498 const patch = {};
499
500 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
501 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
502
503 if (Object.keys(patch).length) saveUserVideoPrefs(patch);
504 };
505
506 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
507 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
508 const onTrackListChange = () => captureSelectedTracks();
509
510 if (textTrackList && typeof textTrackList.addEventListener === 'function')
511 {
512 textTrackList.addEventListener('change', onTrackListChange);
513 }
514
515 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
516 {
517 audioTrackList.addEventListener('change', onTrackListChange);
518 }
519
520 return {
521 applySavedTracks,
522 captureSelectedTracks,
523 detach: () =>
524 {
525 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
526 {
527 textTrackList.removeEventListener('change', onTrackListChange);
528 }
529 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
530 {
531 audioTrackList.removeEventListener('change', onTrackListChange);
532 }
533 },
534 };
535}
536
537function bindImageSubtitleOverlay (player, videojs, prefs, session, item)
538{
539 const imageTracks = Array.isArray(session.imageSubtitleTracks)
540 ? session.imageSubtitleTracks.map((track) => ({
541 label: String(track.label || '').trim() || `Subtitle ${Number(track.streamIndex || 0) + 1}`,
542 language: String(track.language || '').trim(),
543 isDefault: !!track.default,
544 streamIndex: Number(track.streamIndex),
545 })).filter((track) => Number.isInteger(track.streamIndex) && track.streamIndex >= 0)
546 : [];
547
548 if (!imageTracks.length) return null;
549
550 const trackByStreamIndex = new Map(imageTracks.map((track) => [track.streamIndex, track]));
551 let selectedStreamIndex = null;
552 let menuOpen = false;
553 let requestToken = 0;
554 let activeBucket = -1;
555 let activeObjectUrl = null;
556 let overlayEl = null;
557 let overlayImgEl = null;
558 let menuEl = null;
559 let buttonEl = null;
560 let trackDisabled = false;
561 let failureNotified = false;
562
563 const closeObjectUrl = () =>
564 {
565 if (activeObjectUrl)
566 {
567 URL.revokeObjectURL(activeObjectUrl);
568 activeObjectUrl = null;
569 }
570 };
571
572 const hideOverlay = () =>
573 {
574 if (overlayEl) overlayEl.style.display = 'none';
575 if (overlayImgEl) overlayImgEl.removeAttribute('src');
576 closeObjectUrl();
577 };
578
579 const updateButtonState = () =>
580 {
581 if (!buttonEl) return;
582 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
583 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
584 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
585 };
586
587 const updateMenuState = () =>
588 {
589 if (!menuEl) return;
590 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
591 for (const itemEl of items)
592 {
593 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
594 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
595 itemEl.classList.toggle('is-selected', isSelected);
596 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
597 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
598 itemEl.style.fontWeight = isSelected ? '600' : '400';
599 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
600 }
601 };
602
603 const closeMenu = () =>
604 {
605 menuOpen = false;
606 if (menuEl) menuEl.style.display = 'none';
607 };
608
609 const openMenu = () =>
610 {
611 menuOpen = true;
612 if (menuEl)
613 {
614 updateMenuState();
615 menuEl.style.display = 'block';
616 }
617 };
618
619 const toggleMenu = () =>
620 {
621 if (menuOpen) closeMenu();
622 else openMenu();
623 };
624
625 const saveSelection = () =>
626 {
627 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
628 saveUserVideoPrefs({
629 imageSubtitleTrackStreamIndex: selectedStreamIndex,
630 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
631 });
632 };
633
634 const disableTrack = () =>
635 {
636 trackDisabled = true;
637 selectedStreamIndex = null;
638 activeBucket = -1;
639 hideOverlay();
640 updateButtonState();
641 updateMenuState();
642 saveSelection();
643
644 if (!failureNotified)
645 {
646 failureNotified = true;
647 toast('Image subtitles could not be rendered for this file.', 'err');
648 }
649 };
650
651 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
652 {
653 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
654 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
655
656 trackDisabled = false;
657 failureNotified = false;
658 selectedStreamIndex = nextStreamIndex;
659 activeBucket = -1;
660 hideOverlay();
661 updateButtonState();
662 updateMenuState();
663 if (persist) saveSelection();
664
665 if (selectedStreamIndex !== null)
666 {
667 void refreshFrame(true);
668 }
669 };
670
671 const refreshFrame = async (force = false) =>
672 {
673 if (selectedStreamIndex === null) return;
674 if (!overlayEl || !overlayImgEl) return;
675 if (trackDisabled) return;
676
677 const currentTime = Number(player.currentTime());
678 if (!Number.isFinite(currentTime) || currentTime < 0) return;
679
680 const bucket = Math.floor(currentTime * 4);
681 if (!force && bucket === activeBucket) return;
682 activeBucket = bucket;
683
684 const token = ++requestToken;
685 const headers = buildAuthHeaders();
686 const url = `/api/files/video-stream-subtitle-frame?filePath=${encodeURIComponent(item.path)}&streamIndex=${selectedStreamIndex}&timeSeconds=${encodeURIComponent(String(currentTime))}&videoWidth=${encodeURIComponent(String(session.videoWidth || ''))}&videoHeight=${encodeURIComponent(String(session.videoHeight || ''))}`;
687
688 try
689 {
690 const res = await fetch(url, {
691 method: 'GET',
692 headers,
693 credentials: 'same-origin',
694 });
695
696 if (token !== requestToken) return;
697
698 if (res.status === 204)
699 {
700 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
701 hideOverlay();
702 if (frameStatus === 'error') disableTrack();
703 return;
704 }
705
706 if (!res.ok)
707 {
708 disableTrack();
709 return;
710 }
711
712 const blob = await res.blob();
713 if (token !== requestToken) return;
714
715 if (!blob || blob.size === 0)
716 {
717 disableTrack();
718 return;
719 }
720
721 closeObjectUrl();
722 activeObjectUrl = URL.createObjectURL(blob);
723 overlayImgEl.src = activeObjectUrl;
724
725 // Apply placement from headers when available
726 const frameLeft = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Left') || ''), 10);
727 const frameTop = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Top') || ''), 10);
728 const frameWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Width') || ''), 10);
729 const frameHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Height') || ''), 10);
730 const canvasWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Width') || ''), 10);
731 const canvasHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Height') || ''), 10);
732
733 if (frameWidth > 0 && frameHeight > 0 && canvasWidth > 0 && canvasHeight > 0)
734 {
735 // Apply percentage-based sizing to scale the downscaled image properly
736 const widthPercent = (frameWidth / canvasWidth) * 100;
737 const heightPercent = (frameHeight / canvasHeight) * 100;
738 overlayImgEl.style.width = `${widthPercent}%`;
739 overlayImgEl.style.height = `${heightPercent}%`;
740 overlayImgEl.style.maxWidth = 'none';
741 overlayImgEl.style.maxHeight = 'none';
742 }
743 else
744 {
745 // Fallback: use auto sizing with max constraints
746 overlayImgEl.style.width = 'auto';
747 overlayImgEl.style.height = 'auto';
748 overlayImgEl.style.maxWidth = '100%';
749 overlayImgEl.style.maxHeight = '100%';
750 }
751
752 overlayEl.style.display = 'block';
753 overlayImgEl.style.display = 'block';
754 } catch
755 {
756 if (token === requestToken) disableTrack();
757 }
758 };
759
760 const dispose = () =>
761 {
762 requestToken++;
763 closeMenu();
764 hideOverlay();
765 if (overlayEl) overlayEl.remove();
766 if (menuEl) menuEl.remove();
767 player.imageSubtitleOverlayController = null;
768 buttonEl = null;
769 };
770
771 overlayEl = document.createElement('div');
772 overlayEl.className = 'video-subtitle-overlay';
773 overlayEl.style.position = 'absolute';
774 overlayEl.style.left = '0';
775 overlayEl.style.right = '0';
776 overlayEl.style.bottom = '3rem';
777 overlayEl.style.display = 'none';
778 overlayEl.style.zIndex = '3';
779 overlayEl.style.pointerEvents = 'none';
780 overlayEl.style.textAlign = 'center';
781 overlayEl.style.padding = '0 0.75rem';
782 overlayEl.style.maxHeight = '70%';
783 overlayEl.style.overflow = 'hidden';
784
785 overlayImgEl = document.createElement('img');
786 overlayImgEl.alt = 'Image subtitles';
787 overlayImgEl.style.display = 'none';
788 overlayImgEl.style.margin = '0 auto';
789 overlayImgEl.style.objectFit = 'contain';
790 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
791 overlayImgEl.style.maxWidth = '100%';
792 overlayImgEl.style.height = 'auto';
793 overlayEl.appendChild(overlayImgEl);
794
795 menuEl = document.createElement('div');
796 menuEl.className = 'video-subtitle-overlay-menu';
797 menuEl.style.position = 'absolute';
798 menuEl.style.right = '0.75rem';
799 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
800 menuEl.style.minWidth = '14rem';
801 menuEl.style.maxWidth = '20rem';
802 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
803 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
804 menuEl.style.borderRadius = '0.5rem';
805 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
806 menuEl.style.padding = '0.35rem';
807 menuEl.style.display = 'none';
808 menuEl.style.zIndex = '4';
809
810 const buildMenuItem = (label, streamIndex, isSelected) =>
811 {
812 const itemEl = document.createElement('button');
813 itemEl.type = 'button';
814 itemEl.className = 'video-subtitle-overlay-menu-item';
815 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
816 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
817 itemEl.style.display = 'block';
818 itemEl.style.width = '100%';
819 itemEl.style.margin = '0';
820 itemEl.style.padding = '0.5rem 0.75rem';
821 itemEl.style.border = '0';
822 itemEl.style.borderRadius = '0.35rem';
823 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
824 itemEl.style.color = '#fff';
825 itemEl.style.textAlign = 'left';
826 itemEl.style.cursor = 'pointer';
827 itemEl.textContent = label;
828 itemEl.addEventListener('click', () =>
829 {
830 setSelectedStreamIndex(streamIndex);
831 closeMenu();
832 });
833 return itemEl;
834 };
835
836 menuEl.appendChild(buildMenuItem('Off', null, false));
837 for (const track of imageTracks)
838 {
839 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
840 }
841
842 const registerButton = () =>
843 {
844 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
845 if (videojs.getComponent('ImageSubtitleButton')) return;
846
847 const Button = videojs.getComponent('Button');
848 class ImageSubtitleButton extends Button
849 {
850 buildCSSClass ()
851 {
852 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
853 }
854
855 createEl ()
856 {
857 const el = super.createEl();
858 el.type = 'button';
859 el.setAttribute('title', 'Image subtitles');
860 el.setAttribute('aria-label', 'Image subtitles');
861 el.innerHTML = '<span aria-hidden="true">IM</span>';
862 return el;
863 }
864
865 handleClick ()
866 {
867 const controller = this.player().imageSubtitleOverlayController;
868 if (controller) controller.toggleMenu();
869 }
870 }
871
872 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
873 };
874
875 const attachUi = () =>
876 {
877 if (!player.el()) return;
878 registerButton();
879 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
880 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
881 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
882 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
883 {
884 const button = controlBar.addChild('ImageSubtitleButton', {});
885 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
886 updateButtonState();
887 }
888 };
889
890 const applySavedTracks = () =>
891 {
892 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
893 if (savedName)
894 {
895 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
896 if (savedByName)
897 {
898 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
899 return;
900 }
901 }
902
903 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
904 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
905 {
906 setSelectedStreamIndex(savedIndex, { persist: false });
907 return;
908 }
909
910 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
911 if (defaultTrack)
912 {
913 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
914 return;
915 }
916
917 setSelectedStreamIndex(null, { persist: false });
918 };
919
920 player.imageSubtitleOverlayController = {
921 toggleMenu,
922 closeMenu,
923 applySavedTracks,
924 captureSelectedTracks: saveSelection,
925 detach: dispose,
926 };
927
928 player.on('timeupdate', () => { void refreshFrame(); });
929 player.on('seeking', () => { void refreshFrame(true); });
930 player.on('play', () => { void refreshFrame(true); });
931 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
932 player.on('dispose', dispose);
933 player.ready(() =>
934 {
935 attachUi();
936 updateMenuState();
937 updateButtonState();
938 applySavedTracks();
939 if (menuOpen) openMenu();
940 });
941
942 return player.imageSubtitleOverlayController;
943}
944
945function normaliseVideoDuration (player, durationSeconds)
946{
947 const duration = Number(durationSeconds);
948 if (!player || !Number.isFinite(duration) || duration <= 0) return;
949
950 let originalDuration = null;
951 let durationWasChanged = false;
952 try
953 {
954 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
955 installDurationFallback(player, originalDuration, duration);
956 if (player.__filemanagerDurationApplied) return;
957
958 const current = originalDuration ? Number(originalDuration()) : NaN;
959 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
960 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
961 if (withinTolerance)
962 {
963 player.__filemanagerDurationApplied = true;
964 return;
965 }
966
967 if (originalDuration)
968 {
969 durationWasChanged = true;
970 originalDuration(duration);
971 }
972 } catch
973 {
974 // Ignore players that do not support setting duration.
975 }
976
977 try
978 {
979 const updated = originalDuration ? Number(originalDuration()) : NaN;
980 if (Number.isFinite(updated) && updated >= duration * 0.95)
981 {
982 player.__filemanagerDurationApplied = true;
983 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
984 return;
985 }
986
987 player.__filemanagerDurationApplied = true;
988 if (typeof player.trigger === 'function') player.trigger('durationchange');
989 } catch
990 {
991 // Ignore duration fallback failures.
992 }
993}
994
995function installDurationFallback (player, originalDuration, duration)
996{
997 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
998
999 player.__filemanagerDurationFallback = true;
1000 player.duration = function durationWithFallback (...args)
1001 {
1002 if (args.length) return originalDuration(...args);
1003 const current = Number(originalDuration());
1004 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1005 };
1006}
1007
1008function formatDurationForDebug (seconds)
1009{
1010 const value = Number(seconds);
1011 if (!Number.isFinite(value) || value < 0) return 'unknown';
1012
1013 const totalSeconds = Math.floor(value);
1014 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1015 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1016 const ss = String(totalSeconds % 60).padStart(2, '0');
1017 return `${hh}:${mm}:${ss}`;
1018}
1019
1020function ensureVideoPlaybackUi (player, durationSeconds)
1021{
1022 if (!player || typeof player.on !== 'function') return;
1023
1024 const forceVodUi = () =>
1025 {
1026 normaliseVideoDuration(player, durationSeconds);
1027
1028 try
1029 {
1030 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1031 {
1032 player.liveTracker.stopTracking();
1033 }
1034 } catch
1035 {
1036 // Ignore live tracker availability issues.
1037 }
1038
1039 try
1040 {
1041 if (typeof player.removeClass === 'function')
1042 {
1043 player.removeClass('vjs-live');
1044 }
1045 } catch
1046 {
1047 // Ignore class update failures.
1048 }
1049
1050 try
1051 {
1052 const display = player.el() && player.el().querySelector('.vjs-live-display');
1053 if (display) display.style.display = 'none';
1054 } catch
1055 {
1056 // Ignore missing DOM.
1057 }
1058 };
1059
1060 player.ready(forceVodUi);
1061 player.on('loadedmetadata', forceVodUi);
1062 player.on('durationchange', forceVodUi);
1063 player.on('loadedplaylist', forceVodUi);
1064}
1065
1066async function reportWatchProgress (filePath, progress)
1067{
1068 if (!filePath || !Number.isFinite(progress)) return;
1069 await api('POST', '/files/watch-progress', {
1070 filePath,
1071 progress,
1072 }).catch(() => null);
1073
1074 const nextStatus = progress >= 0.7 ? 'fully' : progress >= 0.1 ? 'partway' : null;
1075 if (!nextStatus) return;
1076
1077 const prev = STATE.watchedStatusByPath[filePath];
1078 if (prev === 'fully') return;
1079 STATE.watchedStatusByPath[filePath] = nextStatus;
1080
1081 const iconEl = findTileIconByPath(filePath);
1082 renderWatchedOverlayOnIcon(iconEl, nextStatus);
1083}
1084
1085function getOrCreateClientBindingId ()
1086{
1087 if (STATE.clientBindingId) return STATE.clientBindingId;
1088
1089 try
1090 {
1091 const existing = localStorage.getItem(CLIENT_BINDING_KEY);
1092 if (existing && typeof existing === 'string')
1093 {
1094 STATE.clientBindingId = existing;
1095 return existing;
1096 }
1097 } catch
1098 {
1099 // Ignore storage read errors.
1100 }
1101
1102 const created = randomIdHex(16);
1103 STATE.clientBindingId = created;
1104
1105 try
1106 {
1107 localStorage.setItem(CLIENT_BINDING_KEY, created);
1108 } catch
1109 {
1110 // Ignore storage write errors; in-memory fallback still keeps this stable
1111 // for the current page session.
1112 }
1113
1114 return created;
1115}
1116
1117function formatBytes (bytes)
1118{
1119 if (bytes == null) return '—';
1120 if (bytes < 1024) return bytes + ' B';
1121 if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
1122 if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
1123 return (bytes / 1073741824).toFixed(2) + ' GB';
1124}
1125
1126function parseHumanSize (input)
1127{
1128 const raw = String(input || '').trim();
1129 if (!raw) return null;
1130
1131 const m = raw.match(/^(\d+(?:\.\d+)?)\s*([kmgt]?)(?:i?b)?$/i);
1132 if (!m) return null;
1133
1134 const value = Number(m[1]);
1135 if (!Number.isFinite(value) || value <= 0) return null;
1136
1137 const unit = String(m[2] || '').toLowerCase();
1138 const multipliers = {
1139 '': 1,
1140 k: 1024,
1141 m: 1024 * 1024,
1142 g: 1024 * 1024 * 1024,
1143 t: 1024 * 1024 * 1024 * 1024,
1144 };
1145 return Math.floor(value * (multipliers[unit] || 1));
1146}
1147
1148function updateAdminSizeFeedback (rawValue)
1149{
1150 const feedback = document.getElementById('admin-user-size-feedback');
1151 if (!feedback) return { bytes: null, valid: true };
1152
1153 const trimmed = String(rawValue || '').trim();
1154 if (!trimmed)
1155 {
1156 feedback.textContent = '';
1157 feedback.classList.add('hidden');
1158 feedback.classList.remove('ok', 'err');
1159 return { bytes: null, valid: true };
1160 }
1161
1162 const bytes = parseHumanSize(trimmed);
1163 feedback.classList.remove('hidden', 'ok', 'err');
1164 if (bytes == null)
1165 {
1166 feedback.textContent = 'Invalid size. Use formats like 25 MB, 1 GB, or 500 KB.';
1167 feedback.classList.add('err');
1168 return { bytes: null, valid: false };
1169 }
1170
1171 feedback.textContent = `Valid size: ${formatBytes(bytes)}`;
1172 feedback.classList.add('ok');
1173 return { bytes, valid: true };
1174}
1175
1176function extOf (name)
1177{
1178 const i = name.lastIndexOf('.');
1179 return i >= 0 ? name.slice(i + 1).toLowerCase() : '';
1180}
1181
1182function getPathSep (basePath)
1183{
1184 return basePath && basePath.includes('\\') ? '\\' : '/';
1185}
1186
1187function joinServerPath (basePath, segment)
1188{
1189 const sep = getPathSep(basePath);
1190 const base = String(basePath || '').replace(/[\\/]+$/, '');
1191 return base + sep + segment;
1192}
1193
1194function samePath (a, b)
1195{
1196 if (!a || !b) return false;
1197 return String(a).toLowerCase() === String(b).toLowerCase();
1198}
1199
1200function pathInside (child, root)
1201{
1202 if (!child || !root) return false;
1203 if (samePath(child, root)) return true;
1204 const sep = getPathSep(root);
1205 return String(child).toLowerCase().startsWith((String(root) + sep).toLowerCase());
1206}
1207
1208function relativePathFromRoot (targetPath, rootPath)
1209{
1210 if (!targetPath || !rootPath) return String(targetPath || '');
1211 if (samePath(targetPath, rootPath)) return '.';
1212
1213 const prefix = String(rootPath).replace(/[\\/]+$/, '');
1214 const rel = String(targetPath).slice(prefix.length).replace(/^[\\/]+/, '');
1215 if (!rel) return '.';
1216 return rel;
1217}
1218
1219function displayPathWithRootLabel (targetPath, rootPath, rootLabel)
1220{
1221 const rel = relativePathFromRoot(targetPath, rootPath);
1222 const safeRoot = String(rootLabel || '').replace(/^\/+|\/+$/g, '');
1223 if (!safeRoot) return '/';
1224 if (rel === '.') return `/${safeRoot}`;
1225 return `/${safeRoot}/${String(rel).replace(/\\/g, '/')}`;
1226}
1227
1228function splitNameExt (name)
1229{
1230 const dot = String(name || '').lastIndexOf('.');
1231 if (dot <= 0) return { stem: String(name || ''), ext: '' };
1232 return {
1233 stem: String(name).slice(0, dot),
1234 ext: String(name).slice(dot),
1235 };
1236}
1237
1238function nextAvailableName (requestedName, existingNames)
1239{
1240 const set = existingNames instanceof Set ? existingNames : new Set(existingNames || []);
1241 if (!set.has(requestedName)) return requestedName;
1242
1243 const { stem, ext } = splitNameExt(requestedName);
1244 let n = 1;
1245 while (n <= 10000)
1246 {
1247 const candidate = `${stem || 'file'} (${n})${ext}`;
1248 if (!set.has(candidate)) return candidate;
1249 n++;
1250 }
1251
1252 return requestedName;
1253}
1254
1255async function listDirNameSet (dir)
1256{
1257 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dir)}`);
1258 const names = new Set();
1259 for (const it of ((data && data.items) || [])) names.add(it.name);
1260 return names;
1261}
1262
1263function cloneFileWithName (file, newName)
1264{
1265 return new File([file], newName, {
1266 type: file.type,
1267 lastModified: file.lastModified,
1268 });
1269}
1270
1271function saveSessionState ()
1272{
1273 if (!STATE.token) return;
1274 const now = Date.now();
1275 STATE.lastOperationAt = now;
1276 const payload = {
1277 token: STATE.token,
1278 dir: STATE.currentDir || null,
1279 rootPath: STATE.currentRoot ? STATE.currentRoot.path : null,
1280 lastOperationAt: STATE.lastOperationAt,
1281 };
1282 try
1283 {
1284 localStorage.setItem(SESSION_KEY, JSON.stringify(payload));
1285 } catch
1286 {
1287 // Ignore storage errors (private mode/full quota).
1288 }
1289}
1290
1291function loadSessionState ()
1292{
1293 try
1294 {
1295 const raw = localStorage.getItem(SESSION_KEY);
1296 if (!raw) return null;
1297 const parsed = JSON.parse(raw);
1298 if (!parsed || typeof parsed.token !== 'string') return null;
1299 if (!Number.isFinite(parsed.lastOperationAt)) return null;
1300
1301 if (Date.now() - parsed.lastOperationAt > SESSION_IDLE_TIMEOUT_MS)
1302 {
1303 clearSessionState();
1304 return null;
1305 }
1306
1307 return parsed;
1308 } catch
1309 {
1310 return null;
1311 }
1312}
1313
1314function clearSessionState ()
1315{
1316 try { localStorage.removeItem(SESSION_KEY); } catch { /* ignore */ }
1317}
1318
1319// ───────────────────────────────────────────────────────────────────────────
1320// API
1321// ───────────────────────────────────────────────────────────────────────────
1322
1323async function api (method, path, body, opts = {})
1324{
1325 const headers = { 'Content-Type': 'application/json' };
1326 const noAutoLogout = !!opts.noAutoLogout;
1327 if (STATE.token)
1328 {
1329 headers['Authorization'] = 'Bearer ' + STATE.token;
1330 try
1331 {
1332 const fp = getFingerprint();
1333 if (fp) headers['X-Fp'] = fp;
1334 } catch
1335 {
1336 // Continue without a fingerprint header in constrained test/runtime contexts.
1337 }
1338 }
1339 const fetchOpts = { ...opts };
1340 delete fetchOpts.noAutoLogout;
1341 const res = await fetch('/api' + path, {
1342 method,
1343 headers,
1344 body: body != null ? JSON.stringify(body) : undefined,
1345 ...fetchOpts,
1346 });
1347 if (!res.ok)
1348 {
1349 const j = await res.json().catch(() => ({}));
1350 // Session-expired → force re-login
1351 if (res.status === 401)
1352 {
1353 if (!noAutoLogout) logout();
1354 return null;
1355 }
1356 throw new Error(j.error || res.statusText);
1357 }
1358 if (STATE.token && !path.startsWith('/auth/server-key') && !path.startsWith('/auth/setup-needed'))
1359 {
1360 saveSessionState();
1361 }
1362 return res.json();
1363}
1364
1365// ───────────────────────────────────────────────────────────────────────────
1366// TOAST
1367// ───────────────────────────────────────────────────────────────────────────
1368
1369function toast (msg, type = '')
1370{
1371 const el = document.createElement('div');
1372 el.className = 'toast-msg' + (type ? ' ' + type : '');
1373 el.textContent = msg;
1374 document.getElementById('toast').appendChild(el);
1375 setTimeout(() => el.remove(), 3500);
1376}
1377
1378// ───────────────────────────────────────────────────────────────────────────
1379// DIALOG MODALS — centralised replacements for alert / confirm / prompt
1380// ───────────────────────────────────────────────────────────────────────────
1381
1382/**
1383 * Show a confirmation dialog.
1384 * @param {string} title
1385 * @param {string} message
1386 * @returns {Promise<boolean>} true = OK, false = Cancel
1387 */
1388function showConfirm (title, message, { html = false, okLabel = null, modalClass = '' } = {})
1389{
1390 return new Promise((resolve) =>
1391 {
1392 const overlay = document.getElementById('confirm-modal');
1393 const dialogEl = overlay ? overlay.querySelector('.modal') : null;
1394 const className = typeof modalClass === 'string' ? modalClass.trim() : '';
1395 document.getElementById('confirm-modal-title').textContent = title;
1396 const msgEl = document.getElementById('confirm-modal-message');
1397 if (html) msgEl.innerHTML = message;
1398 else msgEl.textContent = message;
1399 if (dialogEl && className) dialogEl.classList.add(className);
1400 overlay.classList.remove('hidden');
1401
1402 const ok = document.getElementById('confirm-modal-ok');
1403 const prevOkLabel = ok.textContent;
1404 if (okLabel != null) ok.textContent = okLabel;
1405
1406 const cancel = document.getElementById('confirm-modal-cancel');
1407
1408 function finish (result)
1409 {
1410 overlay.classList.add('hidden');
1411 if (dialogEl && className) dialogEl.classList.remove(className);
1412 ok.textContent = prevOkLabel;
1413 ok.removeEventListener('click', onOk);
1414 cancel.removeEventListener('click', onCancel);
1415 resolve(result);
1416 }
1417 function onOk () { finish(true); }
1418 function onCancel () { finish(false); }
1419
1420 ok.addEventListener('click', onOk);
1421 cancel.addEventListener('click', onCancel);
1422 ok.focus();
1423 });
1424}
1425
1426function escHtml (s)
1427{
1428 return String(s || '')
1429 .replace(/&/g, '&amp;')
1430 .replace(/</g, '&lt;')
1431 .replace(/>/g, '&gt;')
1432 .replace(/"/g, '&quot;');
1433}
1434
1435function normaliseUpdateCommits (commitsAhead)
1436{
1437 if (!Array.isArray(commitsAhead)) return [];
1438
1439 const out = [];
1440 for (const raw of commitsAhead)
1441 {
1442 if (typeof raw === 'string')
1443 {
1444 const line = raw.trim();
1445 if (!line) continue;
1446 const match = line.match(/^([0-9a-f]{7,40})\s+(.+)$/i);
1447 out.push({
1448 hash: match ? match[1] : '',
1449 subject: match ? match[2].trim() : line,
1450 body: '',
1451 });
1452 continue;
1453 }
1454
1455 if (!raw || typeof raw !== 'object') continue;
1456 const subject = String(raw.subject || '').trim();
1457 if (!subject) continue;
1458 out.push({
1459 hash: String(raw.hash || '').trim(),
1460 subject,
1461 body: String(raw.body || '').trim(),
1462 });
1463 }
1464
1465 return out;
1466}
1467
1468function renderUpdateCommitListHtml (commitsAhead)
1469{
1470 const commits = normaliseUpdateCommits(commitsAhead);
1471 if (!commits.length) return '';
1472
1473 const commitItems = commits.map((commit) =>
1474 {
1475 const hashLabel = commit.hash
1476 ? `<span class="update-commit-hash">${escHtml(commit.hash.slice(0, 7))}</span>`
1477 : '';
1478 const subjectLabel = `<span class="update-commit-subject">${escHtml(commit.subject)}</span>`;
1479
1480 const bodyHtml = commit.body
1481 ? `<p class="update-commit-body">${escHtml(commit.body).replace(/\n/g, '<br/>')}</p>`
1482 : '';
1483
1484 return `<article class="update-commit-item"><h3>${hashLabel}${hashLabel ? ' ' : ''}${subjectLabel}</h3>${bodyHtml}</article>`;
1485 }).join('');
1486
1487 return `<div class="update-commit-list">${commitItems}</div>`;
1488}
1489
1490/**
1491 * Show a text-input dialog.
1492 * @param {string} title
1493 * @param {string} [message] — optional helper text shown above the input
1494 * @param {string} [defaultValue] — pre-filled value
1495 * @returns {Promise<string|null>} string = submitted value, null = cancelled
1496 */
1497function showPrompt (title, message = '', defaultValue = '')
1498{
1499 return new Promise((resolve) =>
1500 {
1501 const overlay = document.getElementById('prompt-modal');
1502 const msgEl = document.getElementById('prompt-modal-message');
1503 const input = document.getElementById('prompt-modal-input');
1504 const errorEl = document.getElementById('prompt-modal-error');
1505 const form = document.getElementById('prompt-modal-form');
1506 const cancel = document.getElementById('prompt-modal-cancel');
1507
1508 document.getElementById('prompt-modal-title').textContent = title;
1509 msgEl.textContent = message;
1510 msgEl.classList.toggle('hidden', !message);
1511 input.value = defaultValue;
1512 errorEl.classList.add('hidden');
1513 overlay.classList.remove('hidden');
1514 input.focus();
1515 input.select();
1516
1517 function finish (result)
1518 {
1519 overlay.classList.add('hidden');
1520 form.removeEventListener('submit', onSubmit);
1521 cancel.removeEventListener('click', onCancel);
1522 resolve(result);
1523 }
1524 function onSubmit (e)
1525 {
1526 e.preventDefault();
1527 finish(input.value);
1528 }
1529 function onCancel () { finish(null); }
1530
1531 form.addEventListener('submit', onSubmit);
1532 cancel.addEventListener('click', onCancel);
1533 });
1534}
1535
1536/**
1537 * Show an overwrite-decision dialog for a single file conflict.
1538 * @param {string} filename
1539 * @returns {Promise<'yes'|'no'|'all'|'none'>}
1540 */
1541function showOverwrite (filename)
1542{
1543 return new Promise((resolve) =>
1544 {
1545 const overlay = document.getElementById('overwrite-modal');
1546 document.getElementById('overwrite-modal-filename').textContent = filename;
1547 overlay.classList.remove('hidden');
1548
1549 const btnYes = document.getElementById('overwrite-modal-yes');
1550 const btnNo = document.getElementById('overwrite-modal-no');
1551 const btnAll = document.getElementById('overwrite-modal-all');
1552 const btnSkipAll = document.getElementById('overwrite-modal-skip-all');
1553
1554 function finish (result)
1555 {
1556 overlay.classList.add('hidden');
1557 btnYes.removeEventListener('click', onYes);
1558 btnNo.removeEventListener('click', onNo);
1559 btnAll.removeEventListener('click', onAll);
1560 btnSkipAll.removeEventListener('click', onSkipAll);
1561 resolve(result);
1562 }
1563 function onYes () { finish('yes'); }
1564 function onNo () { finish('no'); }
1565 function onAll () { finish('all'); }
1566 function onSkipAll () { finish('none'); }
1567
1568 btnYes.addEventListener('click', onYes);
1569 btnNo.addEventListener('click', onNo);
1570 btnAll.addEventListener('click', onAll);
1571 btnSkipAll.addEventListener('click', onSkipAll);
1572 btnNo.focus();
1573 });
1574}
1575
1576/**
1577 * Show single-file conflict options.
1578 * @param {string} filename
1579 * @param {string} renameTo
1580 * @param {string} mode - upload|move
1581 * @returns {Promise<'overwrite'|'rename'|'cancel'>}
1582 */
1583function showFileConflictChoice (filename, renameTo, mode = 'upload')
1584{
1585 return new Promise((resolve) =>
1586 {
1587 const overlay = document.getElementById('file-conflict-modal');
1588 const title = document.getElementById('file-conflict-title');
1589 const fileEl = document.getElementById('file-conflict-filename');
1590 const renameEl = document.getElementById('file-conflict-rename');
1591 const btnOverwrite = document.getElementById('file-conflict-overwrite');
1592 const btnRename = document.getElementById('file-conflict-rename-btn');
1593 const btnCancel = document.getElementById('file-conflict-cancel');
1594
1595 title.textContent = mode === 'move' ? 'Move file' : 'Upload file';
1596 fileEl.textContent = filename;
1597 renameEl.textContent = renameTo;
1598 btnRename.textContent = `Rename (${renameTo})`;
1599
1600 overlay.classList.remove('hidden');
1601
1602 function finish (result)
1603 {
1604 overlay.classList.add('hidden');
1605 btnOverwrite.removeEventListener('click', onOverwrite);
1606 btnRename.removeEventListener('click', onRename);
1607 btnCancel.removeEventListener('click', onCancel);
1608 resolve(result);
1609 }
1610
1611 function onOverwrite () { finish('overwrite'); }
1612 function onRename () { finish('rename'); }
1613 function onCancel () { finish('cancel'); }
1614
1615 btnOverwrite.addEventListener('click', onOverwrite);
1616 btnRename.addEventListener('click', onRename);
1617 btnCancel.addEventListener('click', onCancel);
1618 btnCancel.focus();
1619 });
1620}
1621
1622// ───────────────────────────────────────────────────────────────────────────
1623// SHARE MODAL
1624// ───────────────────────────────────────────────────────────────────────────
1625
1626async function openShareModal (item)
1627{
1628 const overlay = document.getElementById('share-modal');
1629 const urlInput = document.getElementById('share-url-input');
1630 const copyBtn = document.getElementById('share-copy-btn');
1631 const okBtn = document.getElementById('share-modal-ok');
1632 const closeBtn = document.getElementById('share-modal-close');
1633 const msgEl = document.getElementById('share-modal-msg');
1634
1635 urlInput.value = 'Creating link...';
1636 copyBtn.disabled = true;
1637 msgEl.textContent = 'This link is valid for 24 hours.';
1638 overlay.classList.remove('hidden');
1639
1640 let data;
1641 try
1642 {
1643 data = await api('POST', '/share/create', { filePath: item.path });
1644 } catch (err)
1645 {
1646 msgEl.textContent = 'Error: ' + (err.message || 'Could not create link.');
1647 urlInput.value = '';
1648 return;
1649 }
1650
1651 if (!data || !data.token)
1652 {
1653 msgEl.textContent = 'Unknown error while creating link.';
1654 urlInput.value = '';
1655 return;
1656 }
1657
1658 const shareUrl = `${location.origin}/share/${data.token}`;
1659 urlInput.value = shareUrl;
1660 copyBtn.disabled = false;
1661
1662 function close ()
1663 {
1664 overlay.classList.add('hidden');
1665 okBtn.removeEventListener('click', close);
1666 closeBtn.removeEventListener('click', close);
1667 copyBtn.removeEventListener('click', onCopy);
1668 }
1669
1670 function onCopy ()
1671 {
1672 navigator.clipboard.writeText(shareUrl).then(() =>
1673 {
1674 const orig = copyBtn.textContent;
1675 copyBtn.textContent = 'Copied!';
1676 setTimeout(() => { copyBtn.textContent = orig; }, 1500);
1677 }).catch(() =>
1678 {
1679 // Fallback: select the text
1680 urlInput.select();
1681 });
1682 }
1683
1684 okBtn.addEventListener('click', close);
1685 closeBtn.addEventListener('click', close);
1686 copyBtn.addEventListener('click', onCopy);
1687 okBtn.focus();
1688}
1689
1690// ───────────────────────────────────────────────────────────────────────────
1691// AUTH FLOW
1692// ───────────────────────────────────────────────────────────────────────────
1693
1694function showAuthOverlay (setupMode = false)
1695{
1696 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1697 document.getElementById('app').classList.add('hidden');
1698 const overlay = document.getElementById('auth-overlay');
1699 const usernameInput = document.getElementById('auth-username');
1700 const passwordInput = document.getElementById('auth-password');
1701 overlay.classList.remove('hidden');
1702 document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
1703 document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
1704 const submitBtn = document.getElementById('auth-submit');
1705 submitBtn.disabled = false;
1706 submitBtn.textContent = setupMode ? 'Create Account' : 'Sign In';
1707 document.getElementById('auth-error').classList.add('hidden');
1708 usernameInput.value = '';
1709 passwordInput.value = '';
1710 usernameInput.autocomplete = 'username';
1711 passwordInput.autocomplete = setupMode ? 'new-password' : 'current-password';
1712 usernameInput.focus();
1713 document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
1714}
1715
1716function showApp ()
1717{
1718 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1719 document.getElementById('auth-overlay').classList.add('hidden');
1720 document.getElementById('app').classList.remove('hidden');
1721 if (isMobileViewport())
1722 {
1723 hideSidebarPanel();
1724 } else
1725 {
1726 openFolderSidebar();
1727 }
1728 document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
1729 const userLabel = document.getElementById('user-menu-label');
1730 if (userLabel) userLabel.textContent = STATE.username || 'User';
1731 void refreshGlobalFavicon();
1732 if (STATE.isAdmin)
1733 {
1734 void refreshAdminUpdateStatus();
1735 }
1736 else
1737 {
1738 setAdminUpdateBadge(0);
1739 }
1740 startAutoRefresh();
1741}
1742
1743async function initAuth ()
1744{
1745 // Generate a fresh key pair in the background; login falls back gracefully
1746 // while this is still in progress.
1747 generateClientKeyPair().catch(() =>
1748 {
1749 toast('Secure crypto unavailable in this browser context; using compatibility login mode.', 'err');
1750 });
1751
1752 // Fetch server public key
1753 const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
1754 if (publicKey) STATE.serverPublicKeyJwk = publicKey;
1755 if (!publicKey && hasWebCrypto()) { toast('Could not reach server.', 'err'); return; }
1756 STATE.serverPublicKeyJwk = publicKey;
1757
1758 // Check whether first-run setup is needed
1759 const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
1760
1761 if (!needed)
1762 {
1763 const saved = loadSessionState();
1764 if (saved && saved.token)
1765 {
1766 STATE.token = saved.token;
1767 STATE.restoreDir = saved.dir || null;
1768 STATE.restoreRootPath = saved.rootPath || null;
1769 STATE.lastOperationAt = saved.lastOperationAt;
1770
1771 const me = await api('GET', '/auth/me', null, { noAutoLogout: true }).catch(() => null);
1772 if (me)
1773 {
1774 STATE.username = me.username;
1775 STATE.isAdmin = me.isAdmin;
1776 STATE.permissions = me.permissions;
1777 showApp();
1778 await loadRoots({
1779 preferredDir: STATE.restoreDir,
1780 preferredRootPath: STATE.restoreRootPath,
1781 });
1782 return;
1783 }
1784
1785 STATE.token = null;
1786 clearSessionState();
1787 }
1788 }
1789
1790 showAuthOverlay(needed);
1791}
1792
1793async function doLogin (username, password, isSetup)
1794{
1795 const encrypted = await hybridEncryptForServer({ username, password });
1796 const endpoint = isSetup ? '/auth/setup' : '/auth/login';
1797
1798 let data;
1799 try
1800 {
1801 data = await api('POST', endpoint, {
1802 encrypted,
1803 clientPublicKey: STATE.clientPublicKeyJwk,
1804 fingerprint: getFingerprint(),
1805 });
1806 } catch (err)
1807 {
1808 return err.message;
1809 }
1810
1811 if (!data) return 'Login failed.';
1812
1813 // Decrypt the token sent back by the server
1814 const token = await hybridDecryptFromServer(data.encrypted || data);
1815 if (!token) return 'Login failed.';
1816 STATE.token = token;
1817
1818 // Load user info
1819 const me = await api('GET', '/auth/me');
1820 if (!me) return 'Session error.';
1821
1822 STATE.username = me.username;
1823 STATE.isAdmin = me.isAdmin;
1824 STATE.permissions = me.permissions;
1825
1826 saveSessionState();
1827 showApp();
1828 await loadRoots();
1829 return null; // no error
1830}
1831
1832function logout ()
1833{
1834 void performLogout();
1835}
1836
1837function openChangePasswordModal ()
1838{
1839 const modal = document.getElementById('change-password-modal');
1840 const form = document.getElementById('change-password-form');
1841 const currentInput = document.getElementById('change-password-current');
1842 const nextInput = document.getElementById('change-password-next');
1843 const confirmInput = document.getElementById('change-password-confirm');
1844 const errorEl = document.getElementById('change-password-error');
1845
1846 function hide ()
1847 {
1848 modal.classList.add('hidden');
1849 form.onsubmit = null;
1850 }
1851
1852 currentInput.value = '';
1853 nextInput.value = '';
1854 confirmInput.value = '';
1855 errorEl.textContent = '';
1856 errorEl.classList.add('hidden');
1857 modal.classList.remove('hidden');
1858 currentInput.focus();
1859
1860 form.onsubmit = async (e) =>
1861 {
1862 e.preventDefault();
1863 const currentPassword = currentInput.value;
1864 const newPassword = nextInput.value;
1865 const confirmPassword = confirmInput.value;
1866
1867 if (newPassword !== confirmPassword)
1868 {
1869 errorEl.textContent = 'New passwords do not match.';
1870 errorEl.classList.remove('hidden');
1871 return;
1872 }
1873
1874 if (newPassword.length < 8)
1875 {
1876 errorEl.textContent = 'New password must be at least 8 characters.';
1877 errorEl.classList.remove('hidden');
1878 return;
1879 }
1880
1881 try
1882 {
1883 await api('POST', '/auth/change-password', {
1884 currentPassword,
1885 newPassword,
1886 });
1887 hide();
1888 toast('Password changed.', 'ok');
1889 }
1890 catch (err)
1891 {
1892 errorEl.textContent = err.message || 'Failed to change password.';
1893 errorEl.classList.remove('hidden');
1894 }
1895 };
1896}
1897
1898async function performLogout ()
1899{
1900 const tokenAtStart = STATE.token;
1901 stopAutoRefresh();
1902
1903 if (tokenAtStart)
1904 {
1905 try
1906 {
1907 await api('POST', '/auth/logout', {}, { noAutoLogout: true });
1908 } catch
1909 {
1910 // Ignore network errors while logging out locally.
1911 }
1912 }
1913
1914 STATE.token = null;
1915 STATE.username = null;
1916 STATE.isAdmin = false;
1917 STATE.permissions = {};
1918 STATE.currentDir = null;
1919 STATE.currentRoot = null;
1920 STATE.items = [];
1921 STATE.restoreDir = null;
1922 STATE.restoreRootPath = null;
1923 STATE.lastOperationAt = null;
1924 _adminUpdateStatus = null;
1925 setAdminUpdateBadge(0);
1926 clearSessionState();
1927 closePreview({ force: true });
1928 closeSidebar();
1929 await initAuth();
1930}
1931
1932// ───────────────────────────────────────────────────────────────────────────
1933// NAVIGATION
1934// ───────────────────────────────────────────────────────────────────────────
1935
1936async function loadRoots (opts = {})
1937{
1938 const data = await api('GET', '/files/roots');
1939 if (!data) return;
1940 STATE.roots = data.roots;
1941
1942 const preferredDir = opts.preferredDir || null;
1943 const preferredRootPath = opts.preferredRootPath || null;
1944
1945 if (preferredDir && preferredRootPath)
1946 {
1947 const preferredRoot = STATE.roots.find(r => samePath(r.path, preferredRootPath));
1948 if (preferredRoot && pathInside(preferredDir, preferredRoot.path))
1949 {
1950 try
1951 {
1952 await navigateTo(preferredDir, preferredRoot, { keepSidebar: true });
1953 return;
1954 } catch
1955 {
1956 // Fall back to default root behavior.
1957 }
1958 }
1959 }
1960
1961 if (STATE.roots.length === 1)
1962 {
1963 // Single root → open it directly
1964 await navigateTo(STATE.roots[0].path, STATE.roots[0]);
1965 } else
1966 {
1967 renderRootsView();
1968 }
1969}
1970
1971function renderRootsView ()
1972{
1973 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1974 disconnectThumbnailObserver();
1975 disconnectFolderIconObserver();
1976 revokeThumbnails();
1977
1978 STATE.currentDir = null;
1979 STATE.currentRoot = null;
1980 STATE.searchQuery = null;
1981 saveSessionState();
1982 renderBreadcrumb();
1983 const grid = document.getElementById('file-grid');
1984 grid.innerHTML = '';
1985 document.getElementById('empty-notice').classList.add('hidden');
1986 document.getElementById('folder-stats').classList.add('hidden');
1987 closeSidebar();
1988
1989 for (const root of STATE.roots)
1990 {
1991 const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
1992 grid.appendChild(el);
1993 }
1994
1995 loadThumbnails();
1996}
1997
1998async function navigateTo (absPath, root, opts = {})
1999{
2000 STATE.searchQuery = null;
2001 if (root) STATE.currentRoot = root;
2002 STATE.currentDir = absPath;
2003
2004 const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
2005 if (!data) return;
2006
2007 STATE.items = data.items;
2008 saveSessionState();
2009 renderBreadcrumb();
2010 renderFileGrid();
2011 await refreshFolderStats();
2012 closeSidebar();
2013}
2014
2015async function runGlobalFileSearch ()
2016{
2017 const input = document.getElementById('top-search-input');
2018 if (!input) return;
2019
2020 const query = String(input.value || '').trim();
2021 if (!query)
2022 {
2023 toast('Enter a search term first.', 'err');
2024 return;
2025 }
2026
2027 let data;
2028 try
2029 {
2030 data = await api('GET', `/files/search?query=${encodeURIComponent(query)}&limit=250`);
2031 }
2032 catch (err)
2033 {
2034 toast('Search failed: ' + err.message, 'err');
2035 return;
2036 }
2037
2038 STATE.searchQuery = query;
2039 STATE.currentDir = null;
2040 STATE.currentRoot = null;
2041 STATE.items = Array.isArray(data && data.results)
2042 ? data.results.map((it) => ({
2043 name: it.name,
2044 path: it.path,
2045 dir: it.dir,
2046 isDir: false,
2047 size: it.size,
2048 mtime: it.mtime,
2049 }))
2050 : [];
2051
2052 renderBreadcrumb();
2053 renderFileGrid();
2054 closeSidebar();
2055
2056 const stats = document.getElementById('folder-stats');
2057 if (stats)
2058 {
2059 const n = STATE.items.length;
2060 stats.textContent = n === 1
2061 ? `1 file found for "${query}".`
2062 : `${n} files found for "${query}".`;
2063 stats.classList.remove('hidden');
2064 }
2065}
2066
2067function renderBreadcrumb ()
2068{
2069 if (typeof document === 'undefined') return;
2070 const nav = document.getElementById('breadcrumb');
2071 if (!nav) return;
2072 nav.innerHTML = '';
2073
2074 // "Home" crumb
2075 const home = document.createElement('span');
2076 home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
2077 home.textContent = 'Home';
2078 home.addEventListener('click', () =>
2079 {
2080 if (STATE.roots.length === 1)
2081 {
2082 navigateTo(STATE.roots[0].path, STATE.roots[0]);
2083 } else
2084 {
2085 renderRootsView();
2086 }
2087 });
2088 nav.appendChild(home);
2089
2090 if (STATE.searchQuery)
2091 {
2092 const sep = document.createElement('span');
2093 sep.className = 'sep';
2094 sep.textContent = ' / ';
2095 nav.appendChild(sep);
2096
2097 const searchCrumb = document.createElement('span');
2098 searchCrumb.className = 'crumb active';
2099 searchCrumb.textContent = `Search: ${STATE.searchQuery}`;
2100 nav.appendChild(searchCrumb);
2101 return;
2102 }
2103
2104 if (!STATE.currentDir || !STATE.currentRoot) return;
2105
2106 // Build path segments relative to the root.
2107 const rootPath = STATE.currentRoot.path;
2108 const relative = relativePathFromRoot(STATE.currentDir, rootPath);
2109 const segments = relative === '.' ? [] : relative.split(/[\\/]/).filter(Boolean);
2110 const parts = [STATE.currentRoot.label, ...segments];
2111
2112 for (let i = 0; i < parts.length; i++)
2113 {
2114 const sep = document.createElement('span');
2115 sep.className = 'sep';
2116 sep.textContent = ' / ';
2117 nav.appendChild(sep);
2118
2119 const crumb = document.createElement('span');
2120 crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
2121 crumb.textContent = parts[i];
2122
2123 // Root crumb points to rootPath; segment crumbs point to their folder.
2124 const capturedPath = i === 0
2125 ? rootPath
2126 : joinServerPath(rootPath, segments.slice(0, i).join('/'));
2127 crumb.classList.add('crumb-drop-target');
2128 crumb.dataset.path = capturedPath;
2129 if (i < parts.length - 1)
2130 {
2131 crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
2132 }
2133
2134 nav.appendChild(crumb);
2135 }
2136}
2137
2138async function refreshFolderStats ()
2139{
2140 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
2141 const el = document.getElementById('folder-stats');
2142 if (!STATE.currentDir || STATE.searchQuery)
2143 {
2144 el.classList.add('hidden');
2145 return;
2146 }
2147
2148 const data = await api('GET', `/files/space?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
2149 if (!data)
2150 {
2151 el.classList.add('hidden');
2152 return;
2153 }
2154
2155 const used = formatBytes(data.usedBytes);
2156 if (data.userFreeBytes != null)
2157 {
2158 el.textContent = `Folder usage: ${used} | Free space remaining: ${formatBytes(data.userFreeBytes)}`;
2159 } else
2160 {
2161 const free = data.freeBytes == null ? 'unknown' : formatBytes(data.freeBytes);
2162 el.textContent = `Folder usage: ${used} | Free on disk: ${free}`;
2163 }
2164 el.classList.remove('hidden');
2165}
2166
2167function itemsSignature (items)
2168{
2169 return JSON.stringify(
2170 (items || []).map(it => [it.path, it.mtime, it.uploadedAt, it.size, it.isDir])
2171 .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
2172 );
2173}
2174
2175async function incrementalRefreshCurrentDir ()
2176{
2177 if (STATE.previewExpandState) return;
2178 if (STATE.searchQuery) return;
2179 if (!STATE.currentDir || STATE.uploadInProgress) return;
2180
2181 const data = await api('GET', `/files/list?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
2182 if (!data) return;
2183
2184 const oldSig = itemsSignature(STATE.items);
2185 const newSig = itemsSignature(data.items);
2186 if (oldSig !== newSig)
2187 {
2188 const selectedPath = STATE.selectedItem ? STATE.selectedItem.path : null;
2189 STATE.items = data.items;
2190 renderFileGrid();
2191
2192 if (selectedPath)
2193 {
2194 const match = STATE.items.find(i => i.path === selectedPath);
2195 if (match)
2196 {
2197 const selectedEl = Array.from(document.querySelectorAll('.file-item'))
2198 .find(el => el.dataset.path === selectedPath);
2199 if (selectedEl) selectItem(selectedEl, match);
2200 } else
2201 {
2202 closeSidebar();
2203 }
2204 }
2205 }
2206 else
2207 {
2208 loadThumbnails();
2209 void loadWatchedStatusesForCurrentDir();
2210 }
2211
2212 await refreshFolderStats();
2213}
2214
2215function startAutoRefresh ()
2216{
2217 stopAutoRefresh();
2218 STATE.autoRefreshTimer = setInterval(() =>
2219 {
2220 if (document.hidden) return;
2221 incrementalRefreshCurrentDir();
2222 }, 5000);
2223}
2224
2225function stopAutoRefresh ()
2226{
2227 if (STATE.autoRefreshTimer)
2228 {
2229 clearInterval(STATE.autoRefreshTimer);
2230 STATE.autoRefreshTimer = null;
2231 }
2232}
2233
2234// ───────────────────────────────────────────────────────────────────────────
2235// FILE GRID RENDERING
2236// ───────────────────────────────────────────────────────────────────────────
2237
2238function parseItemTimestampMs (value)
2239{
2240 if (value == null || value === '') return null;
2241 const asNumber = Number(value);
2242 if (Number.isFinite(asNumber) && asNumber > 0) return asNumber;
2243 const asDate = Date.parse(String(value));
2244 return Number.isFinite(asDate) ? asDate : null;
2245}
2246
2247function dayStartMsFromTimestamp (value)
2248{
2249 const ts = parseItemTimestampMs(value);
2250 if (!Number.isFinite(ts)) return null;
2251 const d = new Date(ts);
2252 return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
2253}
2254
2255function dayCountWord (count)
2256{
2257 const words = {
2258 2: 'two',
2259 3: 'three',
2260 4: 'four',
2261 5: 'five',
2262 6: 'six',
2263 };
2264 return words[count] || String(count);
2265}
2266
2267function groupDateLabel (dayStartMs)
2268{
2269 if (!Number.isFinite(dayStartMs)) return 'Unknown date';
2270
2271 const now = new Date();
2272 const todayStartMs = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
2273 const diffDays = Math.floor((todayStartMs - dayStartMs) / (24 * 60 * 60 * 1000));
2274
2275 if (diffDays === 0) return 'today';
2276 if (diffDays === 1) return 'yesterday';
2277 if (diffDays >= 2 && diffDays <= 6) return `${dayCountWord(diffDays)} days ago`;
2278 if (diffDays === 7) return 'one week ago';
2279
2280 return new Date(dayStartMs).toLocaleDateString('en-GB', {
2281 day: '2-digit',
2282 month: 'short',
2283 year: 'numeric',
2284 });
2285}
2286
2287function itemFileTypeLabel (item)
2288{
2289 if (item.isDir) return 'Folder';
2290 const ext = extOf(item.name);
2291 return ext ? `.${ext}` : 'No extension';
2292}
2293
2294function itemAlphabeticalGroupLabel (item)
2295{
2296 const first = String(item.name || '').trim().charAt(0).toUpperCase();
2297 if (!first) return '#';
2298 return /[A-Z0-9]/.test(first) ? first : '#';
2299}
2300
2301function itemSizeGroupInfo (item)
2302{
2303 if (item.isDir) return { id: 'folder', label: 'Folder', rank: -1 };
2304 const size = Number(item.size);
2305 if (!Number.isFinite(size) || size < 0) return { id: 'unknown', label: 'Unknown size', rank: 999 };
2306 if (size === 0) return { id: 'empty', label: 'Empty', rank: 0 };
2307 if (size < (1024 * 1024)) return { id: 'small', label: 'Smaller than 1 MB', rank: 1 };
2308 if (size < (100 * 1024 * 1024)) return { id: 'medium', label: '1 MB to 100 MB', rank: 2 };
2309 if (size < (1024 * 1024 * 1024)) return { id: 'large', label: '100 MB to 1 GB', rank: 3 };
2310 return { id: 'huge', label: 'Larger than 1 GB', rank: 4 };
2311}
2312
2313function itemGroupInfo (item, groupBy)
2314{
2315 if (groupBy === 'alphabetical')
2316 {
2317 const label = itemAlphabeticalGroupLabel(item);
2318 return { id: `alpha:${label}`, label, rank: label.charCodeAt(0) || 999 };
2319 }
2320
2321 if (groupBy === 'fileType')
2322 {
2323 const label = itemFileTypeLabel(item);
2324 return { id: `type:${label.toLowerCase()}`, label, rank: 0 };
2325 }
2326
2327 if (groupBy === 'lastChangedDate')
2328 {
2329 const dayStart = dayStartMsFromTimestamp(item.mtime);
2330 return {
2331 id: `mtime:${dayStart == null ? 'unknown' : dayStart}`,
2332 label: groupDateLabel(dayStart),
2333 rank: dayStart == null ? Number.NEGATIVE_INFINITY : dayStart,
2334 };
2335 }
2336
2337 if (groupBy === 'timeUploadedDate')
2338 {
2339 const dayStart = dayStartMsFromTimestamp(item.uploadedAt != null ? item.uploadedAt : item.mtime);
2340 return {
2341 id: `uploaded:${dayStart == null ? 'unknown' : dayStart}`,
2342 label: groupDateLabel(dayStart),
2343 rank: dayStart == null ? Number.NEGATIVE_INFINITY : dayStart,
2344 };
2345 }
2346
2347 if (groupBy === 'size')
2348 {
2349 const sizeGroup = itemSizeGroupInfo(item);
2350 return {
2351 id: `size:${sizeGroup.id}`,
2352 label: sizeGroup.label,
2353 rank: sizeGroup.rank,
2354 };
2355 }
2356
2357 return { id: 'none', label: '', rank: 0 };
2358}
2359
2360function compareText (a, b)
2361{
2362 return String(a || '').localeCompare(String(b || ''), undefined, { numeric: true, sensitivity: 'base' });
2363}
2364
2365function compareNullableNumber (a, b, ascending)
2366{
2367 const hasA = Number.isFinite(a);
2368 const hasB = Number.isFinite(b);
2369 if (!hasA && !hasB) return 0;
2370 if (!hasA) return 1;
2371 if (!hasB) return -1;
2372 const diff = a - b;
2373 return ascending ? diff : -diff;
2374}
2375
2376function compareBySortMode (a, b, sortBy, ascending)
2377{
2378 if (sortBy === 'fileType')
2379 {
2380 const extA = itemFileTypeLabel(a.item).toLowerCase();
2381 const extB = itemFileTypeLabel(b.item).toLowerCase();
2382 const byType = compareText(extA, extB);
2383 if (byType !== 0) return ascending ? byType : -byType;
2384 const byName = compareText(a.item.name, b.item.name);
2385 return ascending ? byName : -byName;
2386 }
2387
2388 if (sortBy === 'lastChanged')
2389 {
2390 return compareNullableNumber(parseItemTimestampMs(a.item.mtime), parseItemTimestampMs(b.item.mtime), ascending);
2391 }
2392
2393 if (sortBy === 'timeUploaded')
2394 {
2395 const uploadedA = parseItemTimestampMs(a.item.uploadedAt != null ? a.item.uploadedAt : a.item.mtime);
2396 const uploadedB = parseItemTimestampMs(b.item.uploadedAt != null ? b.item.uploadedAt : b.item.mtime);
2397 return compareNullableNumber(uploadedA, uploadedB, ascending);
2398 }
2399
2400 if (sortBy === 'size')
2401 {
2402 const sizeA = Number.isFinite(Number(a.item.size)) ? Number(a.item.size) : null;
2403 const sizeB = Number.isFinite(Number(b.item.size)) ? Number(b.item.size) : null;
2404 return compareNullableNumber(sizeA, sizeB, ascending);
2405 }
2406
2407 const byName = compareText(a.item.name, b.item.name);
2408 return ascending ? byName : -byName;
2409}
2410
2411function buildFileGridRows (items, prefs)
2412{
2413 const list = Array.isArray(items) ? items : [];
2414 const groupBy = prefs.groupBy || 'none';
2415 const sortBy = prefs.sortBy || 'alphabetical';
2416 const descriptors = list.map((item) => ({
2417 item,
2418 group: itemGroupInfo(item, groupBy),
2419 }));
2420
2421 descriptors.sort((a, b) =>
2422 {
2423 if (groupBy !== 'none')
2424 {
2425 const dateGrouping = groupBy === 'lastChangedDate' || groupBy === 'timeUploadedDate';
2426 if (a.group.rank !== b.group.rank)
2427 {
2428 const byRank = dateGrouping ? (b.group.rank - a.group.rank) : (a.group.rank - b.group.rank);
2429 if (byRank !== 0) return byRank;
2430 }
2431 const byGroupLabel = compareText(a.group.label, b.group.label);
2432 if (byGroupLabel !== 0) return dateGrouping ? byGroupLabel : (prefs.ascending ? byGroupLabel : -byGroupLabel);
2433 }
2434
2435 if (prefs.foldersFirst && a.item.isDir !== b.item.isDir)
2436 {
2437 return a.item.isDir ? -1 : 1;
2438 }
2439
2440 const bySort = compareBySortMode(a, b, sortBy, !!prefs.ascending);
2441 if (bySort !== 0) return bySort;
2442
2443 return compareText(a.item.name, b.item.name);
2444 });
2445
2446 const rows = [];
2447 let previousGroupId = null;
2448 for (const descriptor of descriptors)
2449 {
2450 if (groupBy !== 'none' && descriptor.group.id !== previousGroupId)
2451 {
2452 rows.push({ type: 'group', label: descriptor.group.label });
2453 previousGroupId = descriptor.group.id;
2454 }
2455 rows.push({ type: 'item', item: descriptor.item });
2456 }
2457
2458 return rows;
2459}
2460
2461function makeGroupSeparator (label)
2462{
2463 const el = document.createElement('div');
2464 el.className = 'file-group-separator';
2465
2466 const text = document.createElement('span');
2467 text.textContent = String(label || 'Other');
2468 el.appendChild(text);
2469 return el;
2470}
2471
2472function renderFileItemName (targetEl, fileName)
2473{
2474 if (!targetEl) return;
2475
2476 const rawName = String(fileName || '');
2477 targetEl.textContent = '';
2478 if (!rawName) return;
2479
2480 const segments = rawName.split(/([\-.,])/);
2481 for (const segment of segments)
2482 {
2483 if (!segment) continue;
2484 targetEl.appendChild(document.createTextNode(segment));
2485
2486 if (segment === '-' || segment === ',' || segment === '.')
2487 {
2488 targetEl.appendChild(document.createElement('wbr'));
2489 }
2490 }
2491}
2492
2493function renderFileGrid ()
2494{
2495 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
2496 disconnectThumbnailObserver();
2497 disconnectFolderIconObserver();
2498 revokeThumbnails();
2499 const grid = document.getElementById('file-grid');
2500 grid.innerHTML = '';
2501 const empty = document.getElementById('empty-notice');
2502
2503 const prefs = (!STATE.searchQuery && STATE.currentDir)
2504 ? folderViewPrefsForDir(STATE.currentDir)
2505 : { ...DEFAULT_FOLDER_VIEW_PREFS };
2506 const rows = buildFileGridRows(STATE.items, prefs);
2507
2508 empty.classList.toggle('hidden', STATE.items.length > 0);
2509
2510 for (const row of rows)
2511 {
2512 if (row.type === 'group')
2513 {
2514 grid.appendChild(makeGroupSeparator(row.label));
2515 continue;
2516 }
2517 grid.appendChild(makeFileItem(row.item));
2518 }
2519
2520 loadThumbnails();
2521 void loadWatchedStatusesForCurrentDir();
2522}
2523
2524function makeFileItem (item)
2525{
2526 const el = document.createElement('div');
2527 el.className = 'file-item';
2528 el.dataset.path = item.path;
2529 if (item.isDir) el.dataset.isdir = '1';
2530
2531 const icon = document.createElement('div');
2532 icon.className = 'icon';
2533 icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
2534 if (!item.isDir)
2535 {
2536 icon.dataset.previewPath = item.path;
2537 renderWatchedOverlayOnIcon(icon, watchStatusForTile(item));
2538 } else
2539 {
2540 icon.dataset.folderPath = item.path;
2541 }
2542 el.appendChild(icon);
2543
2544 const name = document.createElement('div');
2545 name.className = 'name';
2546 renderFileItemName(name, item.name);
2547 el.appendChild(name);
2548
2549 if (!item._root) makeDraggable(el, item);
2550 attachMobileLongPress(el, item);
2551
2552 el.addEventListener('contextmenu', (e) =>
2553 {
2554 e.preventDefault();
2555 e.stopPropagation();
2556
2557 if (isMobileViewport()) return;
2558 if (el.classList.contains('file-item--preview')) return;
2559
2560 document.querySelectorAll('.file-item.selected').forEach(node => node.classList.remove('selected'));
2561 el.classList.add('selected');
2562 STATE.selectedItem = item;
2563 openItemContextMenu(item, e.clientX, e.clientY);
2564 });
2565
2566 // Single-click: open sidebar
2567 el.addEventListener('click', (e) =>
2568 {
2569 e.stopPropagation();
2570 closeCustomContextMenu();
2571 if (el.classList.contains('file-item--preview')) return;
2572 if (isMobileViewport())
2573 {
2574 if (el.dataset.longPressTriggered === '1')
2575 {
2576 el.dataset.longPressTriggered = '0';
2577 return;
2578 }
2579
2580 if (item.isDir)
2581 {
2582 navigateTo(item.path, item._root || STATE.currentRoot);
2583 } else
2584 {
2585 downloadOrView(item, icon.querySelector('svg'));
2586 }
2587 return;
2588 }
2589
2590 selectItem(el, item);
2591 });
2592
2593 // Double-click: enter folder or view/download file
2594 el.addEventListener('dblclick', (e) =>
2595 {
2596 e.stopPropagation();
2597 if (el.classList.contains('file-item--preview')) return;
2598 if (item.isDir)
2599 {
2600 navigateTo(item.path, item._root || STATE.currentRoot);
2601 } else
2602 {
2603 downloadOrView(item, icon.querySelector('svg'));
2604 }
2605 });
2606
2607 return el;
2608}
2609
2610function attachMobileLongPress (el, item)
2611{
2612 if (item._root) return;
2613
2614 let pressTimer = null;
2615 let startX = 0;
2616 let startY = 0;
2617
2618 function clearPress ()
2619 {
2620 if (!pressTimer) return;
2621 clearTimeout(pressTimer);
2622 pressTimer = null;
2623 }
2624
2625 function cancelPress ()
2626 {
2627 clearPress();
2628 }
2629
2630 el.addEventListener('pointerdown', (e) =>
2631 {
2632 if (!isMobileViewport()) return;
2633 if (e.button !== undefined && e.button !== 0) return;
2634 if (e.pointerType && e.pointerType === 'mouse') return;
2635
2636 startX = e.clientX;
2637 startY = e.clientY;
2638 clearPress();
2639
2640 pressTimer = setTimeout(() =>
2641 {
2642 pressTimer = null;
2643 el.dataset.longPressTriggered = '1';
2644 selectItem(el, item);
2645 }, MOBILE_LONG_PRESS_MS);
2646 });
2647
2648 el.addEventListener('pointermove', (e) =>
2649 {
2650 if (!pressTimer) return;
2651 if (Math.hypot(e.clientX - startX, e.clientY - startY) > MOBILE_LONG_PRESS_MOVE_THRESHOLD)
2652 {
2653 clearPress();
2654 }
2655 });
2656
2657 el.addEventListener('pointerup', cancelPress);
2658 el.addEventListener('pointercancel', cancelPress);
2659 el.addEventListener('pointerleave', cancelPress);
2660}
2661
2662function selectItem (el, item)
2663{
2664 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
2665 el.classList.add('selected');
2666 STATE.selectedItem = item;
2667 openSidebar(item);
2668}
2669
2670function isAbortError (err)
2671{
2672 if (!err) return false;
2673 return err.name === 'AbortError' || /abort/i.test(String(err.message || ''));
2674}
2675
2676function beginSidebarLoad ()
2677{
2678 if (STATE.sidebarAbortController && typeof STATE.sidebarAbortController.abort === 'function')
2679 {
2680 try { STATE.sidebarAbortController.abort(); } catch { /* ignore */ }
2681 }
2682
2683 STATE.sidebarLoadId += 1;
2684 STATE.sidebarAbortController = null;
2685
2686 return {
2687 id: STATE.sidebarLoadId,
2688 };
2689}
2690
2691function isSidebarLoadStale (item, sidebarLoadId)
2692{
2693 if (sidebarLoadId !== STATE.sidebarLoadId) return true;
2694 if (!STATE.selectedItem) return true;
2695 return STATE.selectedItem !== item && STATE.selectedItem.path !== item.path;
2696}
2697
2698// ───────────────────────────────────────────────────────────────────────────
2699// SIDEBAR
2700// ───────────────────────────────────────────────────────────────────────────
2701
2702/**
2703 * Renders (or clears) the duplicates panel at the bottom of the sidebar.
2704 * @param {object|null} item — the item whose duplicates are shown; null = clear
2705 * @param {Array|null} duplicates — array of {path, name, dir, relativePath}; null = loading state
2706 */
2707function renderSidebarDuplicates (item, duplicates)
2708{
2709 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
2710 const panel = document.getElementById('sidebar-duplicates');
2711 if (!panel) return;
2712
2713 // Clear / hide when no item or no duplicates.
2714 if (!item || (Array.isArray(duplicates) && duplicates.length === 0))
2715 {
2716 panel.classList.add('hidden');
2717 panel.innerHTML = '';
2718 return;
2719 }
2720
2721 // Loading state.
2722 if (duplicates === null)
2723 {
2724 panel.classList.add('hidden');
2725 panel.innerHTML = '';
2726 return;
2727 }
2728
2729 panel.innerHTML = '';
2730 const heading = document.createElement('p');
2731 heading.className = 'sidebar-duplicates-heading';
2732 heading.textContent = `Duplicates (${duplicates.length})`;
2733 panel.appendChild(heading);
2734
2735 const list = document.createElement('ul');
2736 list.className = 'sidebar-duplicates-list';
2737
2738 for (const dup of duplicates)
2739 {
2740 const li = document.createElement('li');
2741 const btn = document.createElement('button');
2742 btn.className = 'sidebar-duplicate-entry';
2743 btn.title = dup.path;
2744 // Show path relative to its root; keep absolute path in the tooltip.
2745 btn.textContent = dup.relativePath || dup.path;
2746 btn.addEventListener('click', () => navigateToDuplicate(dup));
2747 li.appendChild(btn);
2748 list.appendChild(li);
2749 }
2750
2751 panel.appendChild(list);
2752 panel.classList.remove('hidden');
2753}
2754
2755/**
2756 * Navigates to the folder containing a duplicate file and then auto-opens it.
2757 * @param {{ path: string, name: string, dir: string }} dup
2758 */
2759async function navigateToDuplicate (dup)
2760{
2761 // If the duplicate lives in the folder already shown, just select it.
2762 if (STATE.currentDir && samePath(dup.dir, STATE.currentDir))
2763 {
2764 const tile = Array.from(document.querySelectorAll('.file-item'))
2765 .find((el) => el.dataset.path === dup.path);
2766 const dupItem = STATE.items.find((i) => i.path === dup.path);
2767 if (tile && dupItem)
2768 {
2769 selectItem(tile, dupItem);
2770 }
2771 return;
2772 }
2773
2774 // Find the root that contains the duplicate.
2775 const root = STATE.roots.find(
2776 (r) => dup.dir === r.path || dup.dir.startsWith(r.path + '/') || dup.dir.startsWith(r.path + '\\'),
2777 );
2778 if (!root)
2779 {
2780 toast('Cannot navigate to duplicate: root not accessible.', 'err');
2781 return;
2782 }
2783
2784 await navigateTo(dup.dir, root);
2785
2786 // After navigation, find and select the file tile to open it.
2787 const tile = Array.from(document.querySelectorAll('.file-item'))
2788 .find((el) => el.dataset.path === dup.path);
2789 const dupItem = STATE.items.find((i) => i.path === dup.path);
2790
2791 if (tile && dupItem)
2792 {
2793 selectItem(tile, dupItem);
2794 }
2795}
2796
2797function renderItemActionButtons (actions, item)
2798{
2799 if (!actions || !item) return;
2800 actions.innerHTML = '';
2801
2802 if (!item.isDir)
2803 {
2804 const btnDl = document.createElement('button');
2805 btnDl.textContent = 'View / Download';
2806 btnDl.addEventListener('click', () =>
2807 {
2808 const tile = Array.from(document.querySelectorAll('.file-item')).find(node => node.dataset.path === item.path);
2809 const source = (tile ? tile.querySelector('.icon svg') : null) || document.querySelector('#sidebar-icon svg');
2810 downloadOrView(item, source);
2811 });
2812 actions.appendChild(btnDl);
2813
2814 const btnShareFile = document.createElement('button');
2815 btnShareFile.textContent = 'Share';
2816 btnShareFile.addEventListener('click', () => openShareModal(item));
2817 actions.appendChild(btnShareFile);
2818 }
2819 else
2820 {
2821 const btnOpen = document.createElement('button');
2822 btnOpen.textContent = 'Open folder';
2823 btnOpen.addEventListener('click', () => navigateTo(item.path, item._root || STATE.currentRoot));
2824 actions.appendChild(btnOpen);
2825
2826 const btnZip = document.createElement('button');
2827 btnZip.textContent = 'Download as zip';
2828 btnZip.addEventListener('click', () =>
2829 {
2830 btnZip.disabled = true;
2831 btnZip.textContent = 'Working...';
2832 const url = `/api/files/download-zip?dir=${encodeURIComponent(item.path)}`;
2833 const headers = {
2834 Authorization: 'Bearer ' + STATE.token,
2835 'X-Fp': getFingerprint(),
2836 };
2837 fetch(url, { headers })
2838 .then(res =>
2839 {
2840 if (!res.ok) throw new Error('Download mislukt');
2841 return res.blob();
2842 })
2843 .then(blob =>
2844 {
2845 const blobUrl = URL.createObjectURL(blob);
2846 const a = document.createElement('a');
2847 a.href = blobUrl;
2848 a.download = item.name + '.zip';
2849 a.click();
2850 setTimeout(() => URL.revokeObjectURL(blobUrl), 10000);
2851 })
2852 .catch((err) => toast(err.message || 'Download mislukt', 'err'))
2853 .finally(() =>
2854 {
2855 btnZip.disabled = false;
2856 btnZip.textContent = 'Download as zip';
2857 });
2858 });
2859 actions.appendChild(btnZip);
2860
2861 const btnShareFolder = document.createElement('button');
2862 btnShareFolder.textContent = 'Share';
2863 btnShareFolder.addEventListener('click', () => openShareModal(item));
2864 actions.appendChild(btnShareFolder);
2865 }
2866
2867 if (!canWrite(item)) return;
2868
2869 if (item.isDir)
2870 {
2871 const btnSetIcon = document.createElement('button');
2872 btnSetIcon.textContent = 'Set icon';
2873 btnSetIcon.addEventListener('click', () => openFolderIconPicker(item));
2874 actions.appendChild(btnSetIcon);
2875 }
2876
2877 if (!item._root)
2878 {
2879 const btnMove = document.createElement('button');
2880 btnMove.textContent = 'Move to';
2881 btnMove.addEventListener('click', () => openMovePicker(item));
2882 actions.appendChild(btnMove);
2883
2884 if (!item.isDir)
2885 {
2886 const btnCopy = document.createElement('button');
2887 btnCopy.textContent = 'Copy to';
2888 btnCopy.addEventListener('click', () => openCopyPicker(item));
2889 actions.appendChild(btnCopy);
2890 }
2891 }
2892
2893 const btnRen = document.createElement('button');
2894 btnRen.textContent = 'Rename';
2895 btnRen.addEventListener('click', () => openRenameModal(item));
2896 actions.appendChild(btnRen);
2897
2898 if (!item._root)
2899 {
2900 const btnDel = document.createElement('button');
2901 btnDel.textContent = 'Delete';
2902 btnDel.className = 'danger';
2903 btnDel.addEventListener('click', () => deleteItem(item));
2904 actions.appendChild(btnDel);
2905 }
2906}
2907
2908function closeCustomContextMenu ()
2909{
2910 const menu = document.getElementById('custom-context-menu');
2911 if (!menu) return;
2912 menu.classList.add('hidden');
2913 menu.innerHTML = '';
2914}
2915
2916function ensureCustomContextMenu ()
2917{
2918 let menu = document.getElementById('custom-context-menu');
2919 if (menu) return menu;
2920
2921 menu = document.createElement('div');
2922 menu.id = 'custom-context-menu';
2923 menu.className = 'custom-context-menu hidden';
2924 menu.setAttribute('role', 'menu');
2925 menu.setAttribute('aria-label', 'Context menu');
2926 menu.addEventListener('click', (e) => e.stopPropagation());
2927 document.body.appendChild(menu);
2928 return menu;
2929}
2930
2931function openCustomContextMenuAt (x, y, build)
2932{
2933 const menu = ensureCustomContextMenu();
2934 menu.innerHTML = '';
2935 build(menu);
2936 if (!menu.childElementCount)
2937 {
2938 closeCustomContextMenu();
2939 return;
2940 }
2941
2942 menu.classList.remove('hidden');
2943 menu.style.left = '0px';
2944 menu.style.top = '0px';
2945
2946 const maxLeft = Math.max(6, window.innerWidth - menu.offsetWidth - 6);
2947 const maxTop = Math.max(6, window.innerHeight - menu.offsetHeight - 6);
2948 menu.style.left = `${Math.min(Math.max(6, x), maxLeft)}px`;
2949 menu.style.top = `${Math.min(Math.max(6, y), maxTop)}px`;
2950}
2951
2952function addContextMenuButton (menu, label, onClick, { danger = false, checked = null, hasSubmenu = false } = {})
2953{
2954 const btn = document.createElement('button');
2955 btn.type = 'button';
2956 btn.className = 'custom-context-menu-item';
2957 if (danger) btn.classList.add('danger');
2958 if (checked !== null) btn.classList.add('custom-context-menu-item--check');
2959 if (hasSubmenu) btn.classList.add('custom-context-menu-item--submenu');
2960
2961 const labelEl = document.createElement('span');
2962 if (checked === true) labelEl.textContent = '✓ ' + label;
2963 else if (checked === false) labelEl.textContent = '□ ' + label;
2964 else labelEl.textContent = label;
2965 btn.appendChild(labelEl);
2966
2967 if (hasSubmenu)
2968 {
2969 const arrow = document.createElement('span');
2970 arrow.textContent = '›';
2971 btn.appendChild(arrow);
2972 }
2973
2974 btn.addEventListener('click', async (e) =>
2975 {
2976 e.stopPropagation();
2977 await onClick();
2978 closeCustomContextMenu();
2979 });
2980 menu.appendChild(btn);
2981 return btn;
2982}
2983
2984function addContextMenuSeparator (menu)
2985{
2986 const sep = document.createElement('div');
2987 sep.className = 'custom-context-menu-separator';
2988 menu.appendChild(sep);
2989}
2990
2991function addContextMenuSubmenu (menu, label, options)
2992{
2993 const row = document.createElement('div');
2994 row.className = 'custom-context-menu-row';
2995 const trigger = addContextMenuButton(row, label, () => {}, { hasSubmenu: true });
2996 trigger.addEventListener('click', (e) => e.preventDefault());
2997
2998 const panel = document.createElement('div');
2999 panel.className = 'custom-context-submenu';
3000 for (const option of options)
3001 {
3002 addContextMenuButton(panel, option.label, option.onClick, {
3003 checked: option.checked,
3004 });
3005 }
3006 row.appendChild(panel);
3007 menu.appendChild(row);
3008}
3009
3010function openItemContextMenu (item, x, y)
3011{
3012 openCustomContextMenuAt(x, y, (menu) =>
3013 {
3014 renderItemActionButtons(menu, item);
3015 menu.querySelectorAll('button').forEach((btn) =>
3016 {
3017 if (btn.classList.contains('danger')) btn.classList.add('danger');
3018 btn.addEventListener('click', () => closeCustomContextMenu(), { once: true });
3019 });
3020 });
3021}
3022
3023function openFolderContextMenu (x, y)
3024{
3025 if (!STATE.currentDir)
3026 {
3027 closeCustomContextMenu();
3028 return;
3029 }
3030
3031 const prefs = folderViewPrefsForDir(STATE.currentDir);
3032 const makeOptionHandler = (patch) => async () =>
3033 {
3034 saveFolderViewPrefsForDir(STATE.currentDir, patch);
3035 renderFileGrid();
3036 };
3037
3038 openCustomContextMenuAt(x, y, (menu) =>
3039 {
3040 if (canWrite())
3041 {
3042 addContextMenuButton(menu, 'Create Folder', createFolderInCurrentDir);
3043 addContextMenuSeparator(menu);
3044 }
3045
3046 addContextMenuSubmenu(menu, 'Sort by', FOLDER_SORT_OPTIONS.map((option) => ({
3047 label: option.label,
3048 checked: prefs.sortBy === option.value,
3049 onClick: makeOptionHandler({ sortBy: option.value }),
3050 })));
3051
3052 addContextMenuSubmenu(menu, 'Group by', FOLDER_GROUP_OPTIONS.map((option) => ({
3053 label: option.label,
3054 checked: prefs.groupBy === option.value,
3055 onClick: makeOptionHandler({ groupBy: option.value }),
3056 })));
3057
3058 addContextMenuSeparator(menu);
3059 addContextMenuButton(menu, 'Always keep folders at the top', makeOptionHandler({ foldersFirst: !prefs.foldersFirst }), {
3060 checked: !!prefs.foldersFirst,
3061 });
3062 addContextMenuButton(menu, prefs.ascending ? 'Ascending' : 'Descending', makeOptionHandler({ ascending: !prefs.ascending }), {
3063 checked: !!prefs.ascending,
3064 });
3065 });
3066}
3067// ───────────────────────────────────────────────────────────────────────────
3068
3069async function openSidebar (item)
3070{
3071 const sidebarLoad = beginSidebarLoad();
3072
3073 const sidebar = document.getElementById('sidebar');
3074 sidebar.classList.remove('hidden');
3075 document.getElementById('app').classList.add('sidebar-open');
3076
3077 document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
3078 if (item.isDir)
3079 {
3080 document.getElementById('sidebar-icon').dataset.folderPath = item.path;
3081 } else
3082 {
3083 delete document.getElementById('sidebar-icon').dataset.folderPath;
3084 }
3085 document.getElementById('sidebar-name').textContent = item.name;
3086
3087 // Load metadata
3088 const dl = document.getElementById('sidebar-meta');
3089 dl.innerHTML = '<dt>Loading…</dt><dd></dd>';
3090
3091 const actions = document.getElementById('sidebar-actions');
3092 actions.innerHTML = '';
3093
3094 // Reset duplicates panel whenever a new item is opened.
3095 renderSidebarDuplicates(null, null);
3096
3097 if (!item.isDir)
3098 {
3099 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`).catch((err) =>
3100 {
3101 if (isAbortError(err)) return null;
3102 throw err;
3103 });
3104 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3105
3106 if (meta)
3107 {
3108 const watchedBy = VIDEO_EXTS.has(extOf(item.name))
3109 ? Object.entries(meta.watchedBy || {})
3110 .map(([user, status]) => `${String(user)}: ${String(status)}`)
3111 .sort((a, b) => a.localeCompare(b))
3112 : [];
3113
3114 dl.innerHTML = `
3115 <dt>Size</dt> <dd>${formatBytes(meta.size)}</dd>
3116 <dt>Modified</dt> <dd>${new Date(meta.mtime).toLocaleString()}</dd>
3117 <dt>Uploaded by</dt><dd>${meta.uploader || '—'}</dd>
3118 <dt>Downloaded by</dt><dd>${meta.downloaders.join(', ') || '—'}</dd>
3119 ${VIDEO_EXTS.has(extOf(item.name)) ? `<dt>Watched by</dt><dd>${watchedBy.join(', ') || '—'}</dd>` : ''}
3120 `;
3121 }
3122
3123 // Fetch and render duplicate files.
3124 renderSidebarDuplicates(item, null); // show loading state
3125 const selectedPathAtRequest = item.path;
3126 api('GET', `/files/duplicates?file=${encodeURIComponent(item.path)}`)
3127 .then((data) =>
3128 {
3129 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3130 if (!STATE.selectedItem || STATE.selectedItem.path !== selectedPathAtRequest) return;
3131 renderSidebarDuplicates(item, data ? data.duplicates : []);
3132 })
3133 .catch((err) =>
3134 {
3135 if (isAbortError(err)) return;
3136 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3137 if (!STATE.selectedItem || STATE.selectedItem.path !== selectedPathAtRequest) return;
3138 renderSidebarDuplicates(item, []);
3139 });
3140
3141 } else
3142 {
3143 dl.innerHTML = `<dt>Type</dt><dd>${item._root ? 'Root folder' : 'Folder'}</dd>`;
3144
3145 if (item._root)
3146 {
3147 dl.innerHTML += `
3148 <dt>Alias</dt><dd>${item.name}</dd>
3149 <dt>Original name</dt><dd>${item._root.originalName || basenameOfPath(item.path)}</dd>
3150 `;
3151
3152 const space = await api('GET', `/files/space?dir=${encodeURIComponent(item.path)}`).catch((err) =>
3153 {
3154 if (isAbortError(err)) return null;
3155 return null;
3156 });
3157 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3158
3159 if (space)
3160 {
3161 const used = formatBytes(space.usedBytes);
3162 const free = space.userFreeBytes != null
3163 ? formatBytes(space.userFreeBytes)
3164 : (space.freeBytes == null ? 'unknown' : formatBytes(space.freeBytes));
3165 const freeLabel = space.userFreeBytes != null ? 'Free space remaining' : 'Remaining';
3166 dl.innerHTML += `
3167 <dt>Used</dt><dd>${used}</dd>
3168 <dt>${freeLabel}</dt><dd>${free}</dd>
3169 `;
3170 }
3171
3172 if (item._root.isUserFolder)
3173 {
3174 dl.innerHTML += `
3175 <dt>Access</dt><dd>Private (your folder)</dd>
3176 `;
3177 } else
3178 {
3179 const accessUsers = await fetchRootAccessList(item.path);
3180 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3181 if (accessUsers)
3182 {
3183 dl.innerHTML += `
3184 <dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>
3185 `;
3186 }
3187 }
3188 }
3189 }
3190
3191 renderItemActionButtons(actions, item);
3192
3193 if (item.isDir)
3194 {
3195 // Load folder icon thumbnail into the sidebar icon element.
3196 void loadOneFolderIcon(document.getElementById('sidebar-icon'));
3197 }
3198}
3199
3200function openFolderSidebar ()
3201{
3202 beginSidebarLoad();
3203
3204 const sidebar = document.getElementById('sidebar');
3205 sidebar.classList.remove('hidden');
3206 document.getElementById('app').classList.add('sidebar-open');
3207
3208 document.getElementById('sidebar-icon').innerHTML = iconFolder(64);
3209
3210 const nameEl = document.getElementById('sidebar-name');
3211 const dl = document.getElementById('sidebar-meta');
3212 const actions = document.getElementById('sidebar-actions');
3213 actions.innerHTML = '';
3214 renderSidebarDuplicates(null, null);
3215
3216 if (!STATE.currentDir || !STATE.currentRoot)
3217 {
3218 nameEl.textContent = 'Storage Roots';
3219 dl.innerHTML = `
3220 <dt>Type</dt><dd>Root overview</dd>
3221 <dt>Roots</dt><dd>${STATE.roots.length}</dd>
3222 `;
3223 return;
3224 }
3225
3226 const parts = String(STATE.currentDir).split(/[\\/]/).filter(Boolean);
3227 const fallback = STATE.currentRoot.label || 'Folder';
3228 nameEl.textContent = parts.length ? parts[parts.length - 1] : fallback;
3229
3230 const dirs = STATE.items.filter(i => i.isDir).length;
3231 const files = STATE.items.length - dirs;
3232 const displayPath = displayPathWithRootLabel(STATE.currentDir, STATE.currentRoot.path, STATE.currentRoot.label);
3233 const baseDetails = `
3234 <dt>Path</dt><dd>${displayPath}</dd>
3235 <dt>Folders</dt><dd>${dirs}</dd>
3236 <dt>Files</dt><dd>${files}</dd>
3237 `;
3238 dl.innerHTML = baseDetails;
3239 renderFolderViewControls(actions, STATE.currentDir);
3240
3241 if (samePath(STATE.currentDir, STATE.currentRoot.path))
3242 {
3243 if (STATE.currentRoot.isUserFolder)
3244 {
3245 dl.innerHTML += '<dt>Access</dt><dd>Private (your folder)</dd>';
3246 return;
3247 }
3248
3249 dl.innerHTML += '<dt>Access</dt><dd>Loading…</dd>';
3250 const currentDirAtStart = STATE.currentDir;
3251 const currentRootPathAtStart = STATE.currentRoot.path;
3252 void fetchRootAccessList(currentRootPathAtStart).then((accessUsers) =>
3253 {
3254 if (!accessUsers) return;
3255 if (!STATE.currentRoot) return;
3256 if (!samePath(STATE.currentDir, currentDirAtStart)) return;
3257 if (!samePath(STATE.currentRoot.path, currentRootPathAtStart)) return;
3258 dl.innerHTML = `${baseDetails}<dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>`;
3259 });
3260 }
3261}
3262
3263function renderFolderViewControls (actions, dirPath)
3264{
3265 if (!actions || !dirPath) return;
3266
3267 const prefs = folderViewPrefsForDir(dirPath);
3268
3269 const section = document.createElement('section');
3270 section.className = 'sidebar-view-options';
3271
3272 const heading = document.createElement('h3');
3273 heading.textContent = 'View options';
3274 section.appendChild(heading);
3275
3276 const sortLabel = document.createElement('label');
3277 sortLabel.className = 'sidebar-view-option-label';
3278 sortLabel.textContent = 'Sort by';
3279 const sortSelect = document.createElement('select');
3280 sortSelect.className = 'sidebar-view-option-control';
3281 sortSelect.dataset.viewOption = 'sort';
3282 for (const option of FOLDER_SORT_OPTIONS)
3283 {
3284 const optEl = document.createElement('option');
3285 optEl.value = option.value;
3286 optEl.textContent = option.label;
3287 sortSelect.appendChild(optEl);
3288 }
3289 sortSelect.value = prefs.sortBy;
3290 sortSelect.addEventListener('change', () =>
3291 {
3292 saveFolderViewPrefsForDir(dirPath, { sortBy: sortSelect.value });
3293 renderFileGrid();
3294 });
3295 sortLabel.appendChild(sortSelect);
3296 section.appendChild(sortLabel);
3297
3298 const groupLabel = document.createElement('label');
3299 groupLabel.className = 'sidebar-view-option-label';
3300 groupLabel.textContent = 'Group by';
3301 const groupSelect = document.createElement('select');
3302 groupSelect.className = 'sidebar-view-option-control';
3303 groupSelect.dataset.viewOption = 'group';
3304 for (const option of FOLDER_GROUP_OPTIONS)
3305 {
3306 const optEl = document.createElement('option');
3307 optEl.value = option.value;
3308 optEl.textContent = option.label;
3309 groupSelect.appendChild(optEl);
3310 }
3311 groupSelect.value = prefs.groupBy;
3312 groupSelect.addEventListener('change', () =>
3313 {
3314 saveFolderViewPrefsForDir(dirPath, { groupBy: groupSelect.value });
3315 renderFileGrid();
3316 });
3317 groupLabel.appendChild(groupSelect);
3318 section.appendChild(groupLabel);
3319
3320 const foldersTopLabel = document.createElement('label');
3321 foldersTopLabel.className = 'sidebar-view-toggle';
3322 const foldersTopInput = document.createElement('input');
3323 foldersTopInput.type = 'checkbox';
3324 foldersTopInput.dataset.viewOption = 'folders-first';
3325 foldersTopInput.checked = !!prefs.foldersFirst;
3326 foldersTopInput.addEventListener('change', () =>
3327 {
3328 saveFolderViewPrefsForDir(dirPath, { foldersFirst: foldersTopInput.checked });
3329 renderFileGrid();
3330 });
3331 const foldersTopText = document.createElement('span');
3332 foldersTopText.textContent = 'Always keep folders at the top';
3333 foldersTopLabel.appendChild(foldersTopInput);
3334 foldersTopLabel.appendChild(foldersTopText);
3335 section.appendChild(foldersTopLabel);
3336
3337 const ascLabel = document.createElement('label');
3338 ascLabel.className = 'sidebar-view-toggle';
3339 const ascInput = document.createElement('input');
3340 ascInput.type = 'checkbox';
3341 ascInput.dataset.viewOption = 'ascending';
3342 ascInput.checked = !!prefs.ascending;
3343 ascInput.addEventListener('change', () =>
3344 {
3345 saveFolderViewPrefsForDir(dirPath, { ascending: ascInput.checked });
3346 renderFileGrid();
3347 });
3348 const ascText = document.createElement('span');
3349 ascText.textContent = ascInput.checked ? 'Ascending' : 'Descending';
3350 ascInput.addEventListener('change', () =>
3351 {
3352 ascText.textContent = ascInput.checked ? 'Ascending' : 'Descending';
3353 });
3354 ascLabel.appendChild(ascInput);
3355 ascLabel.appendChild(ascText);
3356 section.appendChild(ascLabel);
3357
3358 actions.appendChild(section);
3359}
3360
3361function closeSidebar ()
3362{
3363 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return;
3364 beginSidebarLoad();
3365 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
3366 STATE.selectedItem = null;
3367
3368 if (isMobileViewport())
3369 {
3370 hideSidebarPanel();
3371 return;
3372 }
3373
3374 openFolderSidebar();
3375}
3376
3377function isMobileViewport ()
3378{
3379 return window.matchMedia(MOBILE_BREAKPOINT_QUERY).matches;
3380}
3381
3382function hideSidebarPanel ()
3383{
3384 const sidebar = document.getElementById('sidebar');
3385 const app = document.getElementById('app');
3386 sidebar.classList.add('hidden');
3387 app.classList.remove('sidebar-open');
3388}
3389
3390function basenameOfPath (p)
3391{
3392 const parts = String(p || '').split(/[\\/]/).filter(Boolean);
3393 return parts.length ? parts[parts.length - 1] : String(p || '');
3394}
3395
3396async function fetchRootAccessList (rootPath)
3397{
3398 if (!rootPath) return null;
3399 const data = await api('GET', `/files/root-access?rootPath=${encodeURIComponent(rootPath)}`).catch((err) =>
3400 {
3401 if (isAbortError(err)) return null;
3402 return null;
3403 });
3404 if (!data || !Array.isArray(data.users)) return null;
3405 return data.users;
3406}
3407
3408function formatRootAccessList (users)
3409{
3410 if (!Array.isArray(users) || users.length === 0) return 'No users';
3411
3412 const sorted = [...users].sort((a, b) =>
3413 {
3414 const modeRank = (mode) => mode === 'R+W' ? 0 : 1;
3415 const byMode = modeRank(a.mode) - modeRank(b.mode);
3416 if (byMode !== 0) return byMode;
3417 return String(a.username).localeCompare(String(b.username));
3418 });
3419
3420 const items = sorted
3421 .map((u) => `<li>${escapeHtml(String(u.username || ''))} ${escapeHtml(String(u.mode || 'R'))}</li>`)
3422 .join('');
3423 return `<ul class="root-access-list">${items}</ul>`;
3424}
3425
3426function rootPermissionLabel (root)
3427{
3428 if (root && root.isUserFolder) return 'My Folder';
3429 return (root && (root.originalName || root.label)) || '';
3430}
3431
3432function resolveRootForPath (targetPath)
3433{
3434 if (!targetPath) return null;
3435 return STATE.roots.find((r) => samePath(targetPath, r.path) || pathInside(targetPath, r.path)) || null;
3436}
3437
3438function writableRoots ()
3439{
3440 if (STATE.isAdmin) return STATE.roots.slice();
3441 return STATE.roots.filter((r) =>
3442 {
3443 if (r.isUserFolder) return true;
3444 const perm = STATE.permissions[rootPermissionLabel(r)];
3445 return !!(perm && perm.write);
3446 });
3447}
3448
3449async function moveWithConflictResolution (item, targetDir)
3450{
3451 try
3452 {
3453 return await api('POST', '/files/move', { from: item.path, toDir: targetDir });
3454 }
3455 catch (err)
3456 {
3457 if (!/already exists/i.test(err.message || '')) throw err;
3458
3459 const existingNames = await listDirNameSet(targetDir);
3460 const desiredName = item.name || basenameOfPath(item.path) || 'file';
3461 const suggestedName = nextAvailableName(desiredName, existingNames);
3462 const decision = await showFileConflictChoice(desiredName, suggestedName, 'move');
3463 if (decision === 'cancel') return null;
3464
3465 if (decision === 'overwrite')
3466 {
3467 return api('POST', '/files/move', {
3468 from: item.path,
3469 toDir: targetDir,
3470 conflict: 'overwrite',
3471 });
3472 }
3473
3474 return api('POST', '/files/move', {
3475 from: item.path,
3476 toDir: targetDir,
3477 conflict: 'rename',
3478 targetName: suggestedName,
3479 });
3480 }
3481}
3482
3483async function copyWithConflictResolution (item, targetDir)
3484{
3485 try
3486 {
3487 return await api('POST', '/files/copy', { from: item.path, toDir: targetDir });
3488 }
3489 catch (err)
3490 {
3491 if (!/already exists/i.test(err.message || '')) throw err;
3492
3493 const existingNames = await listDirNameSet(targetDir);
3494 const desiredName = item.name || basenameOfPath(item.path) || 'file';
3495 const suggestedName = nextAvailableName(desiredName, existingNames);
3496 const decision = await showFileConflictChoice(desiredName, suggestedName, 'copy');
3497 if (decision === 'cancel') return null;
3498
3499 if (decision === 'overwrite')
3500 {
3501 return api('POST', '/files/copy', {
3502 from: item.path,
3503 toDir: targetDir,
3504 conflict: 'overwrite',
3505 });
3506 }
3507
3508 return api('POST', '/files/copy', {
3509 from: item.path,
3510 toDir: targetDir,
3511 conflict: 'rename',
3512 targetName: suggestedName,
3513 });
3514 }
3515}
3516
3517function ensureMoveModal ()
3518{
3519 let overlay = document.getElementById('move-modal');
3520 if (overlay) return overlay;
3521
3522 overlay = document.createElement('div');
3523 overlay.id = 'move-modal';
3524 overlay.className = 'modal-overlay hidden';
3525 overlay.innerHTML = `
3526 <div class="modal move-modal">
3527 <button class="modal-close" id="move-modal-close" aria-label="Close">✕</button>
3528 <h2>Move To</h2>
3529 <p id="move-modal-caption" class="muted"></p>
3530 <div id="move-tree" class="move-tree"></div>
3531 <p id="move-selected" class="muted"></p>
3532 <div class="dialog-actions">
3533 <button id="move-modal-cancel">Cancel</button>
3534 <button id="move-modal-confirm" class="primary">Move</button>
3535 </div>
3536 </div>
3537 `;
3538 document.body.appendChild(overlay);
3539
3540 const closeBtn = overlay.querySelector('#move-modal-close');
3541 const cancelBtn = overlay.querySelector('#move-modal-cancel');
3542 const confirmBtn = overlay.querySelector('#move-modal-confirm');
3543
3544 function hide ()
3545 {
3546 overlay.classList.add('hidden');
3547 STATE.movePicker = null;
3548 }
3549
3550 closeBtn.addEventListener('click', hide);
3551 cancelBtn.addEventListener('click', hide);
3552 overlay.addEventListener('click', (e) =>
3553 {
3554 if (e.target === overlay) hide();
3555 });
3556
3557 confirmBtn.addEventListener('click', async () =>
3558 {
3559 const st = STATE.movePicker;
3560 if (!st || !st.item || !st.selectedPath)
3561 {
3562 toast('Select a destination folder first.', 'err');
3563 return;
3564 }
3565
3566 try
3567 {
3568 if (st.mode === 'copy')
3569 {
3570 const copied = await copyWithConflictResolution(st.item, st.selectedPath);
3571 if (!copied) return;
3572 }
3573 else
3574 {
3575 const moved = await moveWithConflictResolution(st.item, st.selectedPath);
3576 if (!moved) return;
3577 }
3578 }
3579 catch (err)
3580 {
3581 const action = st.mode === 'copy' ? 'Copy' : 'Move';
3582 toast(`${action} failed: ${err.message}`, 'err');
3583 return;
3584 }
3585
3586 hide();
3587 if (st.mode !== 'copy' && STATE.selectedItem && STATE.selectedItem.path === st.item.path) closeSidebar();
3588 navigateTo(STATE.currentDir, STATE.currentRoot);
3589 });
3590
3591 return overlay;
3592}
3593
3594function setMoveSelection (path, buttonEl)
3595{
3596 if (!STATE.movePicker) return;
3597 STATE.movePicker.selectedPath = path;
3598
3599 document.querySelectorAll('.move-node-label.selected').forEach((el) => el.classList.remove('selected'));
3600 if (buttonEl) buttonEl.classList.add('selected');
3601
3602 const selectedEl = document.getElementById('move-selected');
3603 selectedEl.textContent = path ? `Destination: ${path}` : 'Destination: none';
3604}
3605
3606async function loadMoveChildren (containerEl, dirPath)
3607{
3608 if (containerEl.dataset.loaded === '1') return;
3609 containerEl.dataset.loaded = '1';
3610
3611 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dirPath)}`).catch(() => null);
3612 const folders = data ? data.items.filter((it) => it.isDir).sort((a, b) => a.name.localeCompare(b.name)) : [];
3613
3614 if (!folders.length)
3615 {
3616 const empty = document.createElement('div');
3617 empty.className = 'move-empty';
3618 empty.textContent = 'No subfolders';
3619 containerEl.appendChild(empty);
3620 return;
3621 }
3622
3623 for (const child of folders)
3624 {
3625 containerEl.appendChild(createMoveNode(child.path, child.name));
3626 }
3627}
3628
3629function createMoveNode (folderPath, label)
3630{
3631 const node = document.createElement('div');
3632 node.className = 'move-node';
3633
3634 const row = document.createElement('div');
3635 row.className = 'move-node-row';
3636
3637 const toggle = document.createElement('button');
3638 toggle.type = 'button';
3639 toggle.className = 'move-toggle';
3640 toggle.textContent = '▸';
3641
3642 const selectBtn = document.createElement('button');
3643 selectBtn.type = 'button';
3644 selectBtn.className = 'move-node-label';
3645 selectBtn.textContent = label;
3646 selectBtn.addEventListener('click', () => setMoveSelection(folderPath, selectBtn));
3647
3648 const children = document.createElement('div');
3649 children.className = 'move-children hidden';
3650
3651 toggle.addEventListener('click', async () =>
3652 {
3653 if (children.classList.contains('hidden'))
3654 {
3655 await loadMoveChildren(children, folderPath);
3656 children.classList.remove('hidden');
3657 toggle.textContent = '▾';
3658 } else
3659 {
3660 children.classList.add('hidden');
3661 toggle.textContent = '▸';
3662 }
3663 });
3664
3665 row.appendChild(toggle);
3666 row.appendChild(selectBtn);
3667 node.appendChild(row);
3668 node.appendChild(children);
3669 return node;
3670}
3671
3672function openDestinationPicker (item, mode)
3673{
3674 if (!canWrite())
3675 {
3676 toast('No write access.', 'err');
3677 return;
3678 }
3679
3680 const roots = writableRoots();
3681 if (!roots.length)
3682 {
3683 toast('No writable destination roots available.', 'err');
3684 return;
3685 }
3686
3687 const overlay = ensureMoveModal();
3688 const tree = overlay.querySelector('#move-tree');
3689 const caption = overlay.querySelector('#move-modal-caption');
3690 const titleEl = overlay.querySelector('h2');
3691 const confirmBtn = overlay.querySelector('#move-modal-confirm');
3692
3693 const op = mode === 'copy' ? 'copy' : 'move';
3694 STATE.movePicker = { item, selectedPath: null, mode: op };
3695 titleEl.textContent = op === 'copy' ? 'Copy To' : 'Move To';
3696 confirmBtn.textContent = op === 'copy' ? 'Copy' : 'Move';
3697 caption.textContent = `Select destination folder for: ${item.name}`;
3698 tree.innerHTML = '';
3699
3700 for (const root of roots)
3701 {
3702 tree.appendChild(createMoveNode(root.path, root.label));
3703 }
3704
3705 setMoveSelection(null, null);
3706 overlay.classList.remove('hidden');
3707}
3708
3709function openMovePicker (item)
3710{
3711 openDestinationPicker(item, 'move');
3712}
3713
3714function openCopyPicker (item)
3715{
3716 openDestinationPicker(item, 'copy');
3717}
3718
3719// ───────────────────────────────────────────────────────────────────────────
3720// FOLDER ICON PICKER
3721// ───────────────────────────────────────────────────────────────────────────
3722
3723function globalFaviconFallbackMarkup ()
3724{
3725 return iconFile('favicon.png', 18);
3726}
3727
3728function applyGlobalFaviconPreview (hasFavicon)
3729{
3730 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
3731 const preview = document.getElementById('global-favicon-preview');
3732 if (!preview) return;
3733
3734 if (!hasFavicon)
3735 {
3736 preview.innerHTML = globalFaviconFallbackMarkup();
3737 return;
3738 }
3739
3740 const img = document.createElement('img');
3741 img.alt = 'Current favicon';
3742 img.src = `/api/files/global-favicon-image?v=${STATE.faviconVersion}`;
3743 img.addEventListener('error', () =>
3744 {
3745 preview.innerHTML = globalFaviconFallbackMarkup();
3746 }, { once: true });
3747 preview.innerHTML = '';
3748 preview.appendChild(img);
3749}
3750
3751function applyGlobalFaviconLink (hasFavicon)
3752{
3753 if (typeof document === 'undefined' || typeof document.getElementById !== 'function' || !document.head) return;
3754 let link = document.getElementById('global-favicon-link');
3755 if (!link)
3756 {
3757 link = document.createElement('link');
3758 link.id = 'global-favicon-link';
3759 link.rel = 'icon';
3760 document.head.appendChild(link);
3761 }
3762
3763 if (!hasFavicon)
3764 {
3765 link.removeAttribute('href');
3766 return;
3767 }
3768
3769 link.href = `/api/files/global-favicon-image?v=${STATE.faviconVersion}`;
3770}
3771
3772async function refreshGlobalFavicon ()
3773{
3774 const data = await api('GET', '/files/global-favicon').catch(() => null);
3775 const hasFavicon = !!(data && data.favicon && data.favicon.filePath);
3776 applyGlobalFaviconPreview(hasFavicon);
3777 applyGlobalFaviconLink(hasFavicon);
3778}
3779
3780async function openIconPickerModal ({
3781 dirPath,
3782 titleText,
3783 subtitleText,
3784 emptyText,
3785 confirmLabel,
3786 clearLabel,
3787 onSelect,
3788 onClear,
3789})
3790{
3791 if (!dirPath)
3792 {
3793 toast('Open a folder first.', 'err');
3794 return;
3795 }
3796
3797 const data = await api('GET', `/files/folder-images?dir=${encodeURIComponent(dirPath)}`).catch(() => null);
3798 const images = data ? data.images : [];
3799
3800 const existingIconOverlay = document.getElementById('folder-icon-picker');
3801 if (existingIconOverlay) existingIconOverlay.remove();
3802
3803 const overlay = document.createElement('div');
3804 overlay.id = 'folder-icon-picker';
3805 overlay.className = 'modal-overlay';
3806
3807 const modal = document.createElement('div');
3808 modal.className = 'modal folder-icon-modal';
3809
3810 const closeBtn = document.createElement('button');
3811 closeBtn.className = 'modal-close';
3812 closeBtn.setAttribute('aria-label', 'Close');
3813 closeBtn.textContent = '✕';
3814
3815 const title = document.createElement('h2');
3816 title.textContent = titleText;
3817
3818 const filterInput = document.createElement('input');
3819 filterInput.type = 'text';
3820 filterInput.className = 'folder-icon-filter';
3821 filterInput.placeholder = 'Search icons';
3822 filterInput.setAttribute('aria-label', 'Search icons');
3823
3824 const subtitle = document.createElement('p');
3825 subtitle.className = 'muted';
3826 subtitle.textContent = images.length ? subtitleText : emptyText;
3827
3828 const grid = document.createElement('div');
3829 grid.className = 'folder-icon-grid';
3830
3831 for (const { filePath } of images)
3832 {
3833 const name = filePath.split('/').pop();
3834 const cell = document.createElement('div');
3835 cell.className = 'folder-icon-cell';
3836 cell.dataset.path = filePath;
3837 cell.dataset.name = String(name || '').toLowerCase();
3838
3839 const imgEl = document.createElement('img');
3840 imgEl.alt = name;
3841 imgEl.className = 'folder-icon-thumb';
3842 imgEl.dataset.src = filePath;
3843
3844 const label = document.createElement('div');
3845 label.className = 'folder-icon-label';
3846 label.textContent = name;
3847
3848 cell.appendChild(imgEl);
3849 cell.appendChild(label);
3850
3851 cell.addEventListener('click', () =>
3852 {
3853 grid.querySelectorAll('.folder-icon-cell.selected').forEach(el => el.classList.remove('selected'));
3854 cell.classList.add('selected');
3855 confirmBtn.disabled = false;
3856 });
3857
3858 grid.appendChild(cell);
3859 }
3860
3861 function applyFilter ()
3862 {
3863 const needle = String(filterInput.value || '').trim().toLowerCase();
3864 let visible = 0;
3865 for (const cell of grid.querySelectorAll('.folder-icon-cell'))
3866 {
3867 const name = cell.dataset.name || '';
3868 const show = !needle || name.includes(needle);
3869 cell.classList.toggle('hidden', !show);
3870 if (show) visible += 1;
3871 }
3872 subtitle.textContent = visible
3873 ? subtitleText
3874 : 'No matching thumbnails were found.';
3875 }
3876
3877 filterInput.addEventListener('input', applyFilter);
3878
3879 const dialogActions = document.createElement('div');
3880 dialogActions.className = 'dialog-actions';
3881
3882 const clearBtn = document.createElement('button');
3883 clearBtn.textContent = clearLabel;
3884 clearBtn.addEventListener('click', async () =>
3885 {
3886 try
3887 {
3888 await onClear();
3889 }
3890 catch (err)
3891 {
3892 toast('Failed to clear icon: ' + err.message, 'err');
3893 return;
3894 }
3895 hide();
3896 });
3897
3898 const cancelBtn = document.createElement('button');
3899 cancelBtn.textContent = 'Cancel';
3900 cancelBtn.addEventListener('click', () => hide());
3901
3902 const confirmBtn = document.createElement('button');
3903 confirmBtn.className = 'primary';
3904 confirmBtn.textContent = confirmLabel;
3905 confirmBtn.disabled = true;
3906 confirmBtn.addEventListener('click', async () =>
3907 {
3908 const selected = grid.querySelector('.folder-icon-cell.selected');
3909 if (!selected) return;
3910
3911 try
3912 {
3913 await onSelect(selected.dataset.path);
3914 }
3915 catch (err)
3916 {
3917 toast('Failed to set icon: ' + err.message, 'err');
3918 return;
3919 }
3920
3921 hide();
3922 });
3923
3924 dialogActions.appendChild(clearBtn);
3925 dialogActions.appendChild(cancelBtn);
3926 dialogActions.appendChild(confirmBtn);
3927
3928 modal.appendChild(closeBtn);
3929 modal.appendChild(title);
3930 modal.appendChild(filterInput);
3931 modal.appendChild(subtitle);
3932 modal.appendChild(grid);
3933 modal.appendChild(dialogActions);
3934 overlay.appendChild(modal);
3935 document.body.appendChild(overlay);
3936
3937 function hide ()
3938 {
3939 overlay.remove();
3940 grid.querySelectorAll('.folder-icon-thumb[src^="blob:"]').forEach((img) =>
3941 {
3942 URL.revokeObjectURL(img.src);
3943 });
3944 }
3945
3946 closeBtn.addEventListener('click', hide);
3947 overlay.addEventListener('click', (e) => { if (e.target === overlay) hide(); });
3948
3949 for (const cell of grid.querySelectorAll('.folder-icon-cell'))
3950 {
3951 const imgEl = cell.querySelector('.folder-icon-thumb');
3952 const filePath = imgEl.dataset.src;
3953 void fetch(`/api/files/thumbnail?file=${encodeURIComponent(filePath)}`, {
3954 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
3955 }).then(async (r) =>
3956 {
3957 if (!r.ok || !overlay.isConnected) return;
3958 const blob = await r.blob();
3959 const url = URL.createObjectURL(blob);
3960 imgEl.src = url;
3961 }).catch(() => { });
3962 }
3963
3964 filterInput.focus();
3965}
3966
3967async function openFolderIconPicker (item)
3968{
3969 if (!canWrite(item))
3970 {
3971 toast('No write access.', 'err');
3972 return;
3973 }
3974
3975 await openIconPickerModal({
3976 dirPath: item.path,
3977 titleText: 'Set folder icon',
3978 subtitleText: 'Select a file thumbnail to use as the folder icon.',
3979 emptyText: 'No files with cached thumbnails were found inside this folder.',
3980 confirmLabel: 'Set icon',
3981 clearLabel: 'Clear icon',
3982 onSelect: async (imagePath) =>
3983 {
3984 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath });
3985 refreshAfterIconChange(item);
3986 },
3987 onClear: async () =>
3988 {
3989 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath: null });
3990 refreshAfterIconChange(item);
3991 },
3992 });
3993}
3994
3995async function openGlobalFaviconPicker ()
3996{
3997 if (!STATE.isAdmin)
3998 {
3999 toast('Admin access required.', 'err');
4000 return;
4001 }
4002
4003 const existingIconOverlay = document.getElementById('folder-icon-picker');
4004 if (existingIconOverlay) existingIconOverlay.remove();
4005
4006 const overlay = document.createElement('div');
4007 overlay.id = 'folder-icon-picker';
4008 overlay.className = 'modal-overlay';
4009
4010 const modal = document.createElement('div');
4011 modal.className = 'modal folder-icon-modal';
4012
4013 const closeBtn = document.createElement('button');
4014 closeBtn.className = 'modal-close';
4015 closeBtn.setAttribute('aria-label', 'Close');
4016 closeBtn.textContent = '✕';
4017
4018 const title = document.createElement('h2');
4019 title.textContent = 'Set global favicon';
4020
4021 const filterInput = document.createElement('input');
4022 filterInput.type = 'text';
4023 filterInput.className = 'folder-icon-filter';
4024 filterInput.placeholder = 'Search images across all folders';
4025 filterInput.setAttribute('aria-label', 'Search images');
4026
4027 const subtitle = document.createElement('p');
4028 subtitle.className = 'muted';
4029 subtitle.textContent = 'Type at least 2 characters to search accessible images.';
4030
4031 const grid = document.createElement('div');
4032 grid.className = 'folder-icon-grid';
4033
4034 const dialogActions = document.createElement('div');
4035 dialogActions.className = 'dialog-actions';
4036
4037 const clearBtn = document.createElement('button');
4038 clearBtn.textContent = 'Clear favicon';
4039 clearBtn.addEventListener('click', async () =>
4040 {
4041 try
4042 {
4043 await api('POST', '/files/global-favicon', { imagePath: null });
4044 STATE.faviconVersion = Date.now();
4045 await refreshGlobalFavicon();
4046 }
4047 catch (err)
4048 {
4049 toast('Failed to clear icon: ' + err.message, 'err');
4050 return;
4051 }
4052 hide();
4053 });
4054
4055 const cancelBtn = document.createElement('button');
4056 cancelBtn.textContent = 'Cancel';
4057 cancelBtn.addEventListener('click', () => hide());
4058
4059 const confirmBtn = document.createElement('button');
4060 confirmBtn.className = 'primary';
4061 confirmBtn.textContent = 'Set favicon';
4062 confirmBtn.disabled = true;
4063
4064 let selectedPath = null;
4065 let searchToken = 0;
4066 let searchTimer = null;
4067
4068 confirmBtn.addEventListener('click', async () =>
4069 {
4070 if (!selectedPath) return;
4071 try
4072 {
4073 await api('POST', '/files/global-favicon', { imagePath: selectedPath });
4074 STATE.faviconVersion = Date.now();
4075 await refreshGlobalFavicon();
4076 }
4077 catch (err)
4078 {
4079 toast('Failed to set icon: ' + err.message, 'err');
4080 return;
4081 }
4082 hide();
4083 });
4084
4085 function revokeCellThumbs ()
4086 {
4087 grid.querySelectorAll('.folder-icon-thumb[src^="blob:"]').forEach((img) =>
4088 {
4089 URL.revokeObjectURL(img.src);
4090 });
4091 }
4092
4093 function renderResults (items)
4094 {
4095 selectedPath = null;
4096 confirmBtn.disabled = true;
4097 revokeCellThumbs();
4098 grid.innerHTML = '';
4099
4100 for (const { path: filePath, name } of (items || []))
4101 {
4102 const cell = document.createElement('div');
4103 cell.className = 'folder-icon-cell';
4104 cell.dataset.path = filePath;
4105
4106 const imgEl = document.createElement('img');
4107 imgEl.alt = name;
4108 imgEl.className = 'folder-icon-thumb';
4109
4110 const label = document.createElement('div');
4111 label.className = 'folder-icon-label';
4112 label.textContent = name;
4113
4114 cell.appendChild(imgEl);
4115 cell.appendChild(label);
4116
4117 cell.addEventListener('click', () =>
4118 {
4119 grid.querySelectorAll('.folder-icon-cell.selected').forEach(el => el.classList.remove('selected'));
4120 cell.classList.add('selected');
4121 selectedPath = filePath;
4122 confirmBtn.disabled = false;
4123 });
4124
4125 grid.appendChild(cell);
4126
4127 void fetch(`/api/files/thumbnail?file=${encodeURIComponent(filePath)}`, {
4128 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
4129 }).then(async (r) =>
4130 {
4131 if (!r.ok || !overlay.isConnected) return;
4132 const blob = await r.blob();
4133 const url = URL.createObjectURL(blob);
4134 imgEl.src = url;
4135 }).catch(() => { });
4136 }
4137 }
4138
4139 async function runSearchNow ()
4140 {
4141 const query = String(filterInput.value || '').trim();
4142 searchToken += 1;
4143 const token = searchToken;
4144
4145 if (query.length < 2)
4146 {
4147 subtitle.textContent = 'Type at least 2 characters to search accessible images.';
4148 renderResults([]);
4149 return;
4150 }
4151
4152 subtitle.textContent = 'Searching…';
4153 const data = await api('GET', `/files/search-images?query=${encodeURIComponent(query)}&limit=80`).catch(() => null);
4154 if (!overlay.isConnected || token !== searchToken) return;
4155
4156 const results = Array.isArray(data && data.results) ? data.results : [];
4157 renderResults(results);
4158
4159 if (!results.length)
4160 {
4161 subtitle.textContent = 'No matching thumbnails were found.';
4162 return;
4163 }
4164
4165 const suffix = data && data.truncated
4166 ? ` Scanned first ${Number(data.scannedFiles) || 0} files; refine your search for more.`
4167 : '';
4168 subtitle.textContent = `${results.length} matching image${results.length === 1 ? '' : 's'} found.${suffix}`;
4169 }
4170
4171 filterInput.addEventListener('input', () =>
4172 {
4173 if (searchTimer) clearTimeout(searchTimer);
4174 searchTimer = setTimeout(() =>
4175 {
4176 void runSearchNow();
4177 }, 240);
4178 });
4179
4180 dialogActions.appendChild(clearBtn);
4181 dialogActions.appendChild(cancelBtn);
4182 dialogActions.appendChild(confirmBtn);
4183
4184 modal.appendChild(closeBtn);
4185 modal.appendChild(title);
4186 modal.appendChild(filterInput);
4187 modal.appendChild(subtitle);
4188 modal.appendChild(grid);
4189 modal.appendChild(dialogActions);
4190 overlay.appendChild(modal);
4191 document.body.appendChild(overlay);
4192
4193 function hide ()
4194 {
4195 if (searchTimer) clearTimeout(searchTimer);
4196 overlay.remove();
4197 revokeCellThumbs();
4198 }
4199
4200 closeBtn.addEventListener('click', hide);
4201 overlay.addEventListener('click', (e) => { if (e.target === overlay) hide(); });
4202 filterInput.focus();
4203}
4204
4205function refreshAfterIconChange (item)
4206{
4207 // Reset and reload icon in grid tiles.
4208 const gridTile = Array.from(document.querySelectorAll('.icon[data-folder-path]'))
4209 .find(el => el.dataset.folderPath === item.path);
4210 if (gridTile)
4211 {
4212 const svg = gridTile.querySelector('svg');
4213 if (svg)
4214 {
4215 // Rebuild to plain folder SVG, then reload.
4216 gridTile.innerHTML = iconFolder();
4217 delete gridTile.dataset.thumbReady;
4218 gridTile.dataset.folderPath = item.path;
4219 void loadOneFolderIcon(gridTile);
4220 }
4221 }
4222
4223 // Also reset the sidebar icon if it's showing the same folder.
4224 const sidebarIcon = document.getElementById('sidebar-icon');
4225 if (sidebarIcon && sidebarIcon.dataset.folderPath === item.path)
4226 {
4227 sidebarIcon.innerHTML = iconFolder(64);
4228 delete sidebarIcon.dataset.thumbReady;
4229 void loadOneFolderIcon(sidebarIcon);
4230 }
4231}
4232
4233// ───────────────────────────────────────────────────────────────────────────
4234// DOWNLOAD / VIEW
4235// ───────────────────────────────────────────────────────────────────────────
4236
4237function isInlinePreviewableBlob (blob, name)
4238{
4239 const mime = String(blob.type || '').toLowerCase();
4240 if (/^(image|video|audio)\//.test(mime)) return true;
4241 if (/^text\//.test(mime)) return true;
4242 if (mime === 'application/pdf') return true;
4243 if (mime === 'application/json') return true;
4244 if (mime === 'application/xml') return true;
4245 if (mime === 'application/javascript') return true;
4246
4247 // Fallback by extension when MIME is missing or generic.
4248 const ext = extOf(name || '');
4249 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || AUDIO_EXTS.has(ext)) return true;
4250 if (MODEL_EXTS.has(ext)) return true;
4251 if (MODEL_EXTS.has(ext)) return true;
4252 if (CODE_EXTS.has(ext)) return true;
4253 return false;
4254}
4255
4256function isTextLikeBlob (blob, name)
4257{
4258 const mime = String(blob.type || '').toLowerCase();
4259 if (/^text\//.test(mime)) return true;
4260 if (mime === 'application/json' || mime === 'application/xml' || mime === 'application/javascript') return true;
4261 const ext = extOf(name || '');
4262 return CODE_EXTS.has(ext);
4263}
4264
4265function detectCodeLanguage (name, mime)
4266{
4267 const ext = extOf(name || '');
4268 const m = String(mime || '').toLowerCase();
4269 if (m.includes('json') || ext === 'json') return 'json';
4270 if (m.includes('xml') || ext === 'xml') return 'xml';
4271 if (m.includes('html') || ext === 'html' || ext === 'htm') return 'html';
4272 if (m.includes('css') || ext === 'css') return 'css';
4273 if (m.includes('javascript') || ['js', 'jsx', 'mjs', 'cjs'].includes(ext)) return 'js';
4274 if (m.includes('typescript') || ['ts', 'tsx'].includes(ext)) return 'ts';
4275 if (['sh', 'bash', 'zsh'].includes(ext)) return 'sh';
4276 if (['md', 'txt', 'log', 'ini', 'toml', 'yaml', 'yml'].includes(ext)) return 'plain';
4277 return CODE_EXTS.has(ext) ? 'js' : 'plain';
4278}
4279
4280function prettyPrintMarkup (raw)
4281{
4282 const src = String(raw || '')
4283 .replace(/>\s+</g, '><')
4284 .replace(/\r\n/g, '\n');
4285
4286 const lines = src.replace(/></g, '>\n<').split('\n');
4287 let indent = 0;
4288 const out = [];
4289
4290 for (const ln of lines)
4291 {
4292 const line = ln.trim();
4293 if (!line) continue;
4294 const isClose = /^<\//.test(line);
4295 const isSelf = /\/>$/.test(line) || /^<[^!?][^>]*>[^<]*<\/[^>]+>$/.test(line);
4296 const isOpen = /^<[^!?/][^>]*>$/.test(line);
4297
4298 if (isClose) indent = Math.max(0, indent - 1);
4299 out.push(' '.repeat(indent) + line);
4300 if (isOpen && !isSelf) indent += 1;
4301 }
4302
4303 return out.join('\n');
4304}
4305
4306function prettyPrintBraces (raw)
4307{
4308 const lines = String(raw || '')
4309 .replace(/\r\n/g, '\n')
4310 .split('\n');
4311 let indent = 0;
4312 const out = [];
4313
4314 for (const ln of lines)
4315 {
4316 const line = ln.trim();
4317 if (!line)
4318 {
4319 out.push('');
4320 continue;
4321 }
4322 if (/^[}\])]/.test(line)) indent = Math.max(0, indent - 1);
4323 out.push(' '.repeat(indent) + line);
4324 if (/[{[(]$/.test(line) || /[{[(]\s*(\/\/.*)?$/.test(line)) indent += 1;
4325 }
4326 return out.join('\n');
4327}
4328
4329function prettyPrintCode (raw, lang)
4330{
4331 const text = String(raw || '').replace(/\r\n/g, '\n');
4332 if (lang === 'json')
4333 {
4334 try { return JSON.stringify(JSON.parse(text), null, 2); } catch { return text; }
4335 }
4336 if (lang === 'xml' || lang === 'html') return prettyPrintMarkup(text);
4337 if (lang === 'js' || lang === 'ts' || lang === 'css') return prettyPrintBraces(text);
4338 return text;
4339}
4340
4341function escapeHtml (s)
4342{
4343 return String(s)
4344 .replace(/&/g, '&amp;')
4345 .replace(/</g, '&lt;')
4346 .replace(/>/g, '&gt;');
4347}
4348
4349function highlightCode (raw, lang)
4350{
4351 if (lang === 'plain') return escapeHtml(raw);
4352
4353 let html = escapeHtml(raw);
4354 const stash = [];
4355 const keep = (regex, cls) =>
4356 {
4357 html = html.replace(regex, (m) =>
4358 {
4359 const idx = stash.push(`<span class="tok-${cls}">${m}</span>`) - 1;
4360 return `@@TOK${idx}@@`;
4361 });
4362 };
4363
4364 if (lang === 'json')
4365 {
4366 html = html
4367 .replace(/("(?:\\.|[^"\\])*")\s*:/g, '<span class="tok-key">$1</span>:')
4368 .replace(/: ("(?:\\.|[^"\\])*")/g, ': <span class="tok-string">$1</span>')
4369 .replace(/\b(true|false|null)\b/g, '<span class="tok-keyword">$1</span>')
4370 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
4371 return html;
4372 }
4373
4374 if (lang === 'xml' || lang === 'html')
4375 {
4376 html = html
4377 .replace(/(&lt;\/?)([a-zA-Z0-9:_-]+)/g, '$1<span class="tok-keyword">$2</span>')
4378 .replace(/([a-zA-Z0-9:_-]+)=(&quot;[^&]*&quot;|"[^"]*")/g, '<span class="tok-key">$1</span>=<span class="tok-string">$2</span>');
4379 return html;
4380 }
4381
4382 if (lang === 'sh') keep(/(^|\s)#.*$/gm, 'comment');
4383 else keep(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, 'comment');
4384 keep(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, 'string');
4385
4386 html = html
4387 .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>')
4388 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
4389
4390 html = html.replace(/@@TOK(\d+)@@/g, (_, idx) => stash[Number(idx)] || '');
4391 return html;
4392}
4393
4394function clearPreviewObjectUrl ()
4395{
4396 if (typeof STATE.previewCleanup === 'function')
4397 {
4398 try { STATE.previewCleanup(); } catch { /* ignore */ }
4399 }
4400 STATE.previewCleanup = null;
4401 STATE.previewDownloadAction = null;
4402 if (!STATE.previewObjectUrl) return;
4403 if (String(STATE.previewObjectUrl).startsWith('blob:'))
4404 {
4405 URL.revokeObjectURL(STATE.previewObjectUrl);
4406 }
4407 STATE.previewObjectUrl = null;
4408}
4409
4410function ensureStylesheet (id, href)
4411{
4412 let link = document.getElementById(id);
4413 if (link) return Promise.resolve(link);
4414
4415 link = document.createElement('link');
4416 link.id = id;
4417 link.rel = 'stylesheet';
4418 link.href = href;
4419
4420 return new Promise((resolve, reject) =>
4421 {
4422 link.addEventListener('load', () => resolve(link), { once: true });
4423 link.addEventListener('error', () => reject(new Error('Failed to load video player styles.')), { once: true });
4424 document.head.appendChild(link);
4425 });
4426}
4427
4428function ensureScript (id, src)
4429{
4430 let script = document.getElementById(id);
4431 if (script && window.videojs) return Promise.resolve(window.videojs);
4432
4433 if (!script)
4434 {
4435 script = document.createElement('script');
4436 script.id = id;
4437 script.src = src;
4438 }
4439
4440 return new Promise((resolve, reject) =>
4441 {
4442 script.addEventListener('load', () => resolve(window.videojs), { once: true });
4443 script.addEventListener('error', () => reject(new Error('Failed to load video player script.')), { once: true });
4444 if (!script.isConnected) document.head.appendChild(script);
4445 });
4446}
4447
4448async function ensureVideoJsLoaded ()
4449{
4450 if (window.videojs)
4451 {
4452 configureVideoJsBuffering(window.videojs);
4453 return window.videojs;
4454 }
4455 if (!videoJsLoaderPromise)
4456 {
4457 videoJsLoaderPromise = Promise.all([
4458 ensureStylesheet('videojs-styles', '/vendor/video.js/video-js.css'),
4459 ensureScript('videojs-script', '/vendor/video.js/video.min.js'),
4460 ]).then(() =>
4461 {
4462 configureVideoJsBuffering(window.videojs);
4463 return window.videojs;
4464 });
4465 }
4466 return videoJsLoaderPromise;
4467}
4468
4469function configureVideoJsBuffering (videojs)
4470{
4471 if (!VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED)
4472 return;
4473
4474 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
4475 videojs.__filemanagerBufferingConfigured = true;
4476
4477 try
4478 {
4479 videojs.Vhs.GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
4480 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
4481 } catch
4482 {
4483 // Ignore builds that do not expose VHS buffer configuration.
4484 }
4485}
4486
4487async function createVideoStreamSessionForItem (item)
4488{
4489 return api('POST', '/files/video-stream', { filePath: item.path });
4490}
4491
4492async function releaseVideoStreamSession (sessionId, opts = {})
4493{
4494 const id = String(sessionId || '').trim();
4495 if (!id) return;
4496
4497 await api('DELETE', `/files/video-stream/${encodeURIComponent(id)}`, null, {
4498 keepalive: !!opts.keepalive,
4499 noAutoLogout: true,
4500 }).catch(() => null);
4501}
4502
4503function releaseActivePreviewVideoStreamSession (opts = {})
4504{
4505 const sessionId = String(STATE.previewVideoStreamSessionId || '').trim();
4506 if (!sessionId) return;
4507 STATE.previewVideoStreamSessionId = null;
4508 void releaseVideoStreamSession(sessionId, opts);
4509}
4510
4511async function preparePreviewDownload (item)
4512{
4513 const blob = await fetchFileBlob(item);
4514 if (!blob)
4515 {
4516 toast('Download failed.', 'err');
4517 return;
4518 }
4519
4520 const objectUrl = URL.createObjectURL(blob);
4521 triggerDownload(item.name, objectUrl);
4522 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
4523}
4524
4525async function renderStreamedVideoPreview (item, targetEl)
4526{
4527 const videojs = await ensureVideoJsLoaded();
4528 const session = await createVideoStreamSessionForItem(item);
4529 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
4530 const prefs = loadUserVideoPrefs();
4531 applyUserVideoTextTrackPrefs();
4532
4533 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
4534 {
4535 toast('Some subtitle tracks could not be converted for web playback.', 'err');
4536 }
4537
4538 STATE.previewDownloadAction = () => preparePreviewDownload(item);
4539
4540 const video = document.createElement('video');
4541 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
4542 video.controls = true;
4543 video.preload = 'auto';
4544 video.playsInline = true;
4545 targetEl.classList.add('preview-expand-content--video');
4546 targetEl.appendChild(video);
4547
4548 const player = videojs(video, {
4549 controls: true,
4550 fluid: false,
4551 fill: true,
4552 responsive: false,
4553 preload: 'auto',
4554 controlBar: {
4555 currentTimeDisplay: true,
4556 timeDivider: true,
4557 durationDisplay: true,
4558 remainingTimeDisplay: false,
4559 },
4560 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
4561 tracks: (session.subtitleTracks || []).map((track) => ({
4562 kind: 'subtitles',
4563 src: track.src,
4564 srclang: track.language || 'und',
4565 label: track.label,
4566 default: !!track.default,
4567 })),
4568 });
4569
4570 const trackPrefs = bindUserVideoTrackPrefs(player, prefs);
4571
4572 ensureVideoPlaybackUi(player, session.durationSeconds);
4573 const imageSubtitleController = bindImageSubtitleOverlay(player, videojs, prefs, session, item);
4574
4575 // -------------------------------------------------------------------------
4576
4577 let sentPartway = false;
4578 let sentFully = false;
4579 const markWatch = async () =>
4580 {
4581 let ratio = 0;
4582 try
4583 {
4584 const duration = Number(player.duration());
4585 const current = Number(player.currentTime());
4586 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
4587 {
4588 ratio = current / duration;
4589 }
4590 } catch
4591 {
4592 return;
4593 }
4594
4595 if (ratio >= 0.7)
4596 {
4597 if (sentFully) return;
4598 sentPartway = true;
4599 sentFully = true;
4600 void reportWatchProgress(item.path, ratio);
4601 return;
4602 }
4603
4604 if (ratio >= 0.05)
4605 {
4606 if (sentPartway) return;
4607 sentPartway = true;
4608 void reportWatchProgress(item.path, ratio);
4609 }
4610 };
4611
4612 player.ready(() =>
4613 {
4614 const volume = Number(prefs.volume);
4615 if (Number.isFinite(volume))
4616 {
4617 player.volume(Math.max(0, Math.min(1, volume)));
4618 }
4619
4620 const settings = player && player.textTrackSettings;
4621 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
4622 {
4623 settings.setValues({
4624 backgroundColor: '#000',
4625 backgroundOpacity: '0',
4626 edgeStyle: 'uniform',
4627 });
4628 settings.updateDisplay();
4629 }
4630
4631 trackPrefs.applySavedTracks();
4632 });
4633
4634 player.on('loadedmetadata', trackPrefs.applySavedTracks);
4635 player.on('loadedplaylist', trackPrefs.applySavedTracks);
4636 player.on('timeupdate', markWatch);
4637 player.on('ended', () =>
4638 {
4639 sentPartway = true;
4640 sentFully = true;
4641 void reportWatchProgress(item.path, 1);
4642 });
4643 player.on('volumechange', () =>
4644 {
4645 const v = Number(player.volume());
4646 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
4647 });
4648
4649 STATE.previewCleanup = () =>
4650 {
4651 if (imageSubtitleController)
4652 {
4653 try { imageSubtitleController.captureSelectedTracks(); } catch { /* ignore */ }
4654 try { imageSubtitleController.detach(); } catch { /* ignore */ }
4655 }
4656 releaseActivePreviewVideoStreamSession();
4657 try { markWatch(); } catch { /* ignore */ }
4658 try { trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
4659 try { trackPrefs.detach(); } catch { /* ignore */ }
4660 try { player.dispose(); } catch { /* ignore */ }
4661 };
4662}
4663
4664function fileAccentColor (name)
4665{
4666 const ext = extOf(name || '');
4667 if (IMAGE_EXTS.has(ext)) return '#3fcf8e';
4668 if (VIDEO_EXTS.has(ext)) return '#e05c6e';
4669 if (AUDIO_EXTS.has(ext)) return '#c084fc';
4670 if (MODEL_EXTS.has(ext)) return '#2f6dff';
4671 if (DOC_EXTS.has(ext)) return '#f97316';
4672 if (CODE_EXTS.has(ext)) return '#38bdf8';
4673 if (ARCHIVE_EXTS.has(ext)) return '#facc15';
4674 return '#7880a0';
4675}
4676
4677function animateRect (el, fromRect, toRect, opts = {})
4678{
4679 const duration = opts.duration == null ? 260 : opts.duration;
4680 const easeOut = (t) => 1 - Math.pow(1 - t, 3);
4681
4682 el.style.left = `${fromRect.left}px`;
4683 el.style.top = `${fromRect.top}px`;
4684 el.style.width = `${fromRect.width}px`;
4685 el.style.height = `${fromRect.height}px`;
4686
4687 return new Promise((resolve) =>
4688 {
4689 const t0 = performance.now();
4690
4691 function frame (now)
4692 {
4693 const raw = Math.min((now - t0) / duration, 1);
4694 const t = easeOut(raw);
4695
4696 const left = fromRect.left + (toRect.left - fromRect.left) * t;
4697 const top = fromRect.top + (toRect.top - fromRect.top) * t;
4698 const width = fromRect.width + (toRect.width - fromRect.width) * t;
4699 const height = fromRect.height + (toRect.height - fromRect.height) * t;
4700
4701 el.style.left = `${left}px`;
4702 el.style.top = `${top}px`;
4703 el.style.width = `${width}px`;
4704 el.style.height = `${height}px`;
4705
4706 if (raw < 1)
4707 {
4708 requestAnimationFrame(frame);
4709 } else
4710 {
4711 resolve();
4712 }
4713 }
4714
4715 requestAnimationFrame(frame);
4716 });
4717}
4718
4719async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewContent)
4720{
4721 if (!tileEl || !sourceSvgEl) return false;
4722
4723 if (STATE.previewExpandState)
4724 {
4725 await closeExpandedTilePreview();
4726 }
4727
4728 const iconEl = tileEl.querySelector('.icon');
4729 const nameEl = tileEl.querySelector('.name');
4730 if (!iconEl) return false;
4731
4732 const startRect = tileEl.getBoundingClientRect();
4733 const targetW = Math.min(window.innerWidth * 0.94, 1100);
4734 const targetH = Math.min(window.innerHeight * 0.9, 860);
4735 const targetRect = {
4736 left: (window.innerWidth - targetW) / 2,
4737 top: (window.innerHeight - targetH) / 2,
4738 width: targetW,
4739 height: targetH,
4740 };
4741
4742 const backdrop = document.createElement('div');
4743 backdrop.className = 'preview-backdrop';
4744 document.body.appendChild(backdrop);
4745
4746 const parent = tileEl.parentNode;
4747 const nextSibling = tileEl.nextSibling;
4748 const iconHtml = iconEl.innerHTML;
4749 const originalIconSvg = iconEl.querySelector('svg');
4750 const placeholder = document.createElement('div');
4751 placeholder.className = 'file-item file-item--preview-placeholder';
4752 placeholder.style.width = `${startRect.width}px`;
4753 placeholder.style.height = `${startRect.height}px`;
4754
4755 if (parent)
4756 {
4757 parent.insertBefore(placeholder, tileEl);
4758 }
4759
4760 tileEl.remove();
4761 document.body.appendChild(tileEl);
4762 tileEl.classList.add('file-item--preview');
4763 tileEl.style.setProperty('--preview-accent', fileAccentColor(item.name));
4764 tileEl.style.position = 'fixed';
4765 tileEl.style.left = `${startRect.left}px`;
4766 tileEl.style.top = `${startRect.top}px`;
4767 tileEl.style.width = `${startRect.width}px`;
4768 tileEl.style.height = `${startRect.height}px`;
4769 tileEl.style.margin = '0';
4770 tileEl.style.zIndex = '10000';
4771
4772 if (nameEl) nameEl.style.display = 'none';
4773
4774 const titleEl = document.createElement('div');
4775 titleEl.className = 'preview-expand-title';
4776 titleEl.textContent = item.name;
4777
4778 const closeBtn = document.createElement('button');
4779 closeBtn.className = 'preview-expand-close';
4780 closeBtn.type = 'button';
4781 closeBtn.textContent = '×';
4782 closeBtn.setAttribute('aria-label', 'Close preview');
4783
4784 const dlBtn = document.createElement('button');
4785 dlBtn.className = 'preview-expand-download';
4786 dlBtn.type = 'button';
4787 dlBtn.textContent = 'Download';
4788 dlBtn.addEventListener('click', async (e) =>
4789 {
4790 e.stopPropagation();
4791 if (STATE.previewDownloadAction)
4792 {
4793 await STATE.previewDownloadAction();
4794 return;
4795 }
4796 if (!STATE.previewObjectUrl)
4797 {
4798 toast('Preview still loading.', 'err');
4799 return;
4800 }
4801 triggerDownload(item.name, STATE.previewObjectUrl);
4802 });
4803
4804 const shareBtn = document.createElement('button');
4805 shareBtn.className = 'preview-expand-share';
4806 shareBtn.type = 'button';
4807 shareBtn.textContent = 'Share';
4808 shareBtn.addEventListener('click', (e) =>
4809 {
4810 e.stopPropagation();
4811 openShareModal(item);
4812 });
4813
4814 const actionsEl = document.createElement('div');
4815 actionsEl.className = 'preview-expand-actions';
4816 actionsEl.appendChild(shareBtn);
4817 actionsEl.appendChild(dlBtn);
4818
4819 iconEl.innerHTML = '';
4820
4821 if (originalIconSvg)
4822 {
4823 const outline = originalIconSvg.cloneNode(true);
4824 outline.classList.add('preview-expand-outline');
4825 iconEl.appendChild(outline);
4826 }
4827
4828 const previewMount = document.createElement('div');
4829 previewMount.className = 'preview-expand-content';
4830 iconEl.appendChild(previewMount);
4831
4832 // Show spinner during expansion animation; content loads after it finishes
4833 const spinner = document.createElement('div');
4834 spinner.className = 'preview-loading-spinner';
4835 previewMount.appendChild(spinner);
4836
4837 tileEl.insertBefore(titleEl, tileEl.firstChild);
4838 tileEl.appendChild(closeBtn);
4839 tileEl.appendChild(actionsEl);
4840
4841 STATE.previewExpandState = {
4842 item,
4843 requireExplicitClose: VIDEO_EXTS.has(extOf(item.name)),
4844 tileEl,
4845 sourceSvgEl,
4846 parent,
4847 nextSibling,
4848 iconEl,
4849 iconHtml,
4850 nameEl,
4851 backdrop,
4852 placeholder,
4853 closeBtn,
4854 dlBtn,
4855 shareBtn,
4856 actionsEl,
4857 titleEl,
4858 previewMount,
4859 startRect,
4860 };
4861
4862 const onBackdrop = (e) =>
4863 {
4864 if (e.target === backdrop) closePreview();
4865 };
4866 const onClose = () => closePreview({ force: true });
4867 backdrop.addEventListener('click', onBackdrop);
4868 closeBtn.addEventListener('click', onClose);
4869 STATE.previewExpandState.onBackdrop = onBackdrop;
4870 STATE.previewExpandState.onClose = onClose;
4871
4872 requestAnimationFrame(() => backdrop.classList.add('visible'));
4873 await animateRect(tileEl, startRect, targetRect);
4874
4875 tileEl.style.left = `${targetRect.left}px`;
4876 tileEl.style.top = `${targetRect.top}px`;
4877 tileEl.style.width = `${targetRect.width}px`;
4878 tileEl.style.height = `${targetRect.height}px`;
4879
4880 try
4881 {
4882 await loadPreviewContent(previewMount);
4883 } catch
4884 {
4885 if (previewMount.isConnected)
4886 {
4887 previewMount.innerHTML = '';
4888 const msg = document.createElement('p');
4889 msg.className = 'preview-unsupported';
4890 msg.textContent = 'Preview failed to load. You can try again.';
4891 previewMount.appendChild(msg);
4892 }
4893 }
4894
4895 return true;
4896}
4897
4898async function closeExpandedTilePreview ()
4899{
4900 const st = STATE.previewExpandState;
4901 if (!st) return;
4902
4903 st.backdrop.classList.remove('visible');
4904 if (st.backdrop && st.onBackdrop) st.backdrop.removeEventListener('click', st.onBackdrop);
4905 if (st.closeBtn && st.onClose) st.closeBtn.removeEventListener('click', st.onClose);
4906
4907 const fromRect = st.tileEl.getBoundingClientRect();
4908 await animateRect(st.tileEl, fromRect, st.startRect, { duration: 220 });
4909
4910 st.tileEl.classList.remove('file-item--preview');
4911 st.tileEl.style.position = '';
4912 st.tileEl.style.left = '';
4913 st.tileEl.style.top = '';
4914 st.tileEl.style.width = '';
4915 st.tileEl.style.height = '';
4916 st.tileEl.style.margin = '';
4917 st.tileEl.style.zIndex = '';
4918
4919 if (st.titleEl) st.titleEl.remove();
4920 if (st.closeBtn) st.closeBtn.remove();
4921 if (st.actionsEl) st.actionsEl.remove();
4922 if (st.iconEl) st.iconEl.innerHTML = st.iconHtml;
4923 if (st.nameEl) st.nameEl.style.display = '';
4924
4925 if (st.placeholder && st.placeholder.parentNode)
4926 {
4927 st.placeholder.parentNode.insertBefore(st.tileEl, st.placeholder);
4928 st.placeholder.remove();
4929 } else if (st.parent)
4930 {
4931 if (st.nextSibling && st.nextSibling.parentNode === st.parent)
4932 {
4933 st.parent.insertBefore(st.tileEl, st.nextSibling);
4934 } else
4935 {
4936 st.parent.appendChild(st.tileEl);
4937 }
4938 }
4939
4940 if (st.backdrop) st.backdrop.remove();
4941 STATE.previewExpandState = null;
4942}
4943
4944async function closePreview (opts = {})
4945{
4946 if (STATE.previewClosing) return;
4947 if (STATE.previewExpandState)
4948 {
4949 if (STATE.previewExpandState.requireExplicitClose && !opts.force)
4950 {
4951 return;
4952 }
4953
4954 STATE.previewClosing = true;
4955 clearPreviewObjectUrl();
4956 try
4957 {
4958 await closeExpandedTilePreview();
4959 STATE.previewSourceEl = null;
4960 } finally
4961 {
4962 STATE.previewClosing = false;
4963 }
4964 }
4965}
4966
4967async function fetchFileBlob (item)
4968{
4969 const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
4970 try
4971 {
4972 const res = await fetch(url, {
4973 headers: {
4974 Authorization: 'Bearer ' + STATE.token,
4975 'X-Fp': getFingerprint(),
4976 },
4977 });
4978 if (!res.ok) throw new Error('Download failed.');
4979 return await res.blob();
4980 } catch
4981 {
4982 return null;
4983 }
4984}
4985
4986function triggerDownload (filename, objectUrl)
4987{
4988 const a = document.createElement('a');
4989 a.href = objectUrl;
4990 a.download = filename;
4991 a.click();
4992}
4993
4994function modelPreviewType (name)
4995{
4996 const ext = extOf(name || '');
4997 if (MODEL_EXTS.has(ext)) return ext;
4998 return null;
4999}
5000
5001async function loadThreePreviewModules ()
5002{
5003 if (!threePreviewModulesPromise)
5004 {
5005 threePreviewModulesPromise = Promise.all([
5006 import('/vendor/three/three.module.js'),
5007 import('/vendor/three/addons/controls/OrbitControls.js'),
5008 import('/vendor/three/addons/loaders/STLLoader.js'),
5009 import('/vendor/three/addons/loaders/OBJLoader.js'),
5010 ]).then(([THREE, controlsMod, stlMod, objMod]) =>
5011 {
5012 return {
5013 THREE,
5014 OrbitControls: controlsMod.OrbitControls,
5015 STLLoader: stlMod.STLLoader,
5016 OBJLoader: objMod.OBJLoader,
5017 };
5018 });
5019 }
5020
5021 return threePreviewModulesPromise;
5022}
5023
5024function disposeObject3D (root)
5025{
5026 if (!root || typeof root.traverse !== 'function') return;
5027 root.traverse((node) =>
5028 {
5029 if (node.geometry && typeof node.geometry.dispose === 'function')
5030 {
5031 node.geometry.dispose();
5032 }
5033
5034 if (!node.material) return;
5035 if (Array.isArray(node.material))
5036 {
5037 node.material.forEach((material) =>
5038 {
5039 if (material && typeof material.dispose === 'function') material.dispose();
5040 });
5041 return;
5042 }
5043
5044 if (typeof node.material.dispose === 'function') node.material.dispose();
5045 });
5046}
5047
5048async function buildModelObjectFromBlob (blob, type, modules)
5049{
5050 const { THREE, STLLoader, OBJLoader } = modules;
5051 const sharedMaterial = new THREE.MeshStandardMaterial({
5052 color: 0x2f6dff,
5053 metalness: 0.08,
5054 roughness: 0.72,
5055 });
5056
5057 if (type === 'stl')
5058 {
5059 const arr = await blob.arrayBuffer();
5060 const geometry = new STLLoader().parse(arr);
5061 geometry.computeVertexNormals();
5062 return new THREE.Mesh(geometry, sharedMaterial);
5063 }
5064
5065 if (type === 'obj')
5066 {
5067 const text = await blob.text();
5068 const obj = new OBJLoader().parse(text);
5069 obj.traverse((node) =>
5070 {
5071 if (!node || !node.isMesh) return;
5072 node.material = sharedMaterial.clone();
5073 });
5074 sharedMaterial.dispose();
5075 return obj;
5076 }
5077
5078 throw new Error('Unsupported 3D model format.');
5079}
5080
5081function setModelPreviewMessage (wrap, text)
5082{
5083 wrap.innerHTML = '';
5084 const msg = document.createElement('p');
5085 msg.className = 'preview-unsupported';
5086 msg.textContent = text;
5087 wrap.appendChild(msg);
5088}
5089
5090async function renderModelPreview (item, blob, targetEl)
5091{
5092 const type = modelPreviewType(item && item.name);
5093 if (!type)
5094 {
5095 const msg = document.createElement('p');
5096 msg.className = 'preview-unsupported';
5097 msg.textContent = 'This 3D file type is not supported yet.';
5098 targetEl.appendChild(msg);
5099 return;
5100 }
5101
5102 const wrap = document.createElement('div');
5103 wrap.className = 'preview-model-wrap';
5104 targetEl.appendChild(wrap);
5105
5106 const canvas = document.createElement('canvas');
5107 canvas.className = 'preview-model-canvas';
5108 canvas.style.touchAction = 'none';
5109 wrap.appendChild(canvas);
5110
5111 const hint = document.createElement('p');
5112 hint.className = 'preview-model-hint';
5113 hint.textContent = 'Drag to rotate. Use the scroll wheel to zoom.';
5114 wrap.appendChild(hint);
5115
5116 const gl =
5117 canvas.getContext('webgl2', { antialias: true, alpha: true }) ||
5118 canvas.getContext('webgl', { antialias: true, alpha: true });
5119 if (!gl)
5120 {
5121 setModelPreviewMessage(wrap, '3D preview is not available in this browser. You can still download this file.');
5122 return;
5123 }
5124
5125 let modules;
5126 try
5127 {
5128 modules = await loadThreePreviewModules();
5129 } catch
5130 {
5131 setModelPreviewMessage(wrap, '3D preview dependencies failed to load. You can still download this file.');
5132 return;
5133 }
5134
5135 if (!wrap.isConnected) return;
5136
5137 const { THREE, OrbitControls } = modules;
5138 const scene = new THREE.Scene();
5139 scene.background = new THREE.Color(0x0d111a);
5140
5141 const camera = new THREE.PerspectiveCamera(50, 1, 0.01, 5000);
5142 const renderer = new THREE.WebGLRenderer({ canvas, context: gl, antialias: true, alpha: true });
5143 renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
5144
5145 const ambient = new THREE.AmbientLight(0xffffff, 0.9);
5146 const key = new THREE.DirectionalLight(0xffffff, 0.95);
5147 key.position.set(1.2, 1.6, 1.1);
5148 scene.add(ambient);
5149 scene.add(key);
5150
5151 let modelRoot;
5152 try
5153 {
5154 modelRoot = await buildModelObjectFromBlob(blob, type, modules);
5155 } catch
5156 {
5157 renderer.dispose();
5158 setModelPreviewMessage(wrap, 'This 3D file could not be parsed. You can still download it.');
5159 return;
5160 }
5161
5162 if (!wrap.isConnected)
5163 {
5164 disposeObject3D(modelRoot);
5165 renderer.dispose();
5166 return;
5167 }
5168
5169 scene.add(modelRoot);
5170
5171 const box = new THREE.Box3().setFromObject(modelRoot);
5172 if (box.isEmpty())
5173 {
5174 disposeObject3D(modelRoot);
5175 renderer.dispose();
5176 setModelPreviewMessage(wrap, 'This 3D file has no visible geometry to preview.');
5177 return;
5178 }
5179
5180 const size = new THREE.Vector3();
5181 const center = new THREE.Vector3();
5182 box.getSize(size);
5183 box.getCenter(center);
5184 modelRoot.position.sub(center);
5185
5186 const maxDim = Math.max(size.x, size.y, size.z) || 1;
5187 const camDistance = maxDim * 1.8;
5188 camera.position.set(camDistance, camDistance * 0.75, camDistance);
5189 camera.near = Math.max(0.001, maxDim / 2000);
5190 camera.far = Math.max(1000, maxDim * 2000);
5191 camera.updateProjectionMatrix();
5192
5193 const controls = new OrbitControls(camera, renderer.domElement);
5194 controls.enableDamping = true;
5195 controls.dampingFactor = 0.08;
5196 controls.target.set(0, 0, 0);
5197 controls.minDistance = maxDim * 0.2;
5198 controls.maxDistance = maxDim * 25;
5199 controls.update();
5200
5201 const resize = () =>
5202 {
5203 const w = Math.max(160, Math.floor(wrap.clientWidth || 0));
5204 const h = Math.max(160, Math.floor((wrap.clientHeight || 0) - (hint.offsetHeight || 0) - 6));
5205 renderer.setSize(w, h, false);
5206 camera.aspect = w / h;
5207 camera.updateProjectionMatrix();
5208 };
5209 resize();
5210
5211 let stop = false;
5212 let rafId = 0;
5213 const frame = () =>
5214 {
5215 if (stop) return;
5216 controls.update();
5217 renderer.render(scene, camera);
5218 rafId = requestAnimationFrame(frame);
5219 };
5220 frame();
5221
5222 const resizeObserver = typeof ResizeObserver === 'function'
5223 ? new ResizeObserver(() => resize())
5224 : null;
5225 if (resizeObserver) resizeObserver.observe(wrap);
5226
5227 STATE.previewCleanup = () =>
5228 {
5229 stop = true;
5230 if (rafId) cancelAnimationFrame(rafId);
5231 if (resizeObserver) resizeObserver.disconnect();
5232 try { controls.dispose(); } catch { /* ignore */ }
5233 try { disposeObject3D(modelRoot); } catch { /* ignore */ }
5234 try { renderer.dispose(); } catch { /* ignore */ }
5235 };
5236}
5237
5238async function renderPreviewBody (item, blob, objectUrl, targetEl = null)
5239{
5240 const body = targetEl || document.getElementById('preview-body');
5241 body.innerHTML = '';
5242
5243 const mime = String(blob.type || '').toLowerCase();
5244 const previewable = isInlinePreviewableBlob(blob, item.name);
5245
5246 if (!previewable)
5247 {
5248 const msg = document.createElement('p');
5249 msg.className = 'preview-unsupported';
5250 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
5251 body.appendChild(msg);
5252 return;
5253 }
5254
5255 if (/^image\//.test(mime) || IMAGE_EXTS.has(extOf(item.name)))
5256 {
5257 const img = document.createElement('img');
5258 img.className = 'preview-media';
5259 img.src = objectUrl;
5260 img.alt = item.name;
5261 body.appendChild(img);
5262 return;
5263 }
5264
5265 if (/^video\//.test(mime) || VIDEO_EXTS.has(extOf(item.name)))
5266 {
5267 const video = document.createElement('video');
5268 video.className = 'preview-media';
5269 video.src = objectUrl;
5270 video.controls = true;
5271 video.preload = 'metadata';
5272 body.appendChild(video);
5273 return;
5274 }
5275
5276 if (/^audio\//.test(mime) || AUDIO_EXTS.has(extOf(item.name)))
5277 {
5278 const audio = document.createElement('audio');
5279 audio.className = 'preview-audio';
5280 audio.src = objectUrl;
5281 audio.controls = true;
5282 body.appendChild(audio);
5283 return;
5284 }
5285
5286 if (modelPreviewType(item.name))
5287 {
5288 await renderModelPreview(item, blob, body);
5289 return;
5290 }
5291
5292 if (mime === 'application/pdf')
5293 {
5294 const frame = document.createElement('iframe');
5295 frame.className = 'preview-frame';
5296 frame.src = objectUrl;
5297 frame.title = item.name;
5298 body.appendChild(frame);
5299 return;
5300 }
5301
5302 if (isTextLikeBlob(blob, item.name))
5303 {
5304 const text = await blob.text();
5305 const lang = detectCodeLanguage(item.name, mime);
5306 const formatted = prettyPrintCode(text, lang);
5307 const pre = document.createElement('pre');
5308 pre.className = 'preview-text preview-code';
5309 pre.innerHTML = highlightCode(formatted, lang);
5310 body.appendChild(pre);
5311 return;
5312 }
5313
5314 const msg = document.createElement('p');
5315 msg.className = 'preview-unsupported';
5316 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
5317 body.appendChild(msg);
5318}
5319
5320async function downloadOrView (item, sourceSvgEl = null)
5321{
5322 if (STATE.previewExpandState)
5323 {
5324 await closePreview({ force: true });
5325 }
5326
5327 const sourceTileEl = sourceSvgEl ? sourceSvgEl.closest('.file-item') : null;
5328 if (sourceTileEl)
5329 {
5330 STATE.previewSourceEl = sourceSvgEl;
5331 const expanded = await openExpandedTilePreview(item, sourceTileEl, sourceSvgEl, async (previewMount) =>
5332 {
5333 if (VIDEO_EXTS.has(extOf(item.name)))
5334 {
5335 clearPreviewObjectUrl();
5336 previewMount.innerHTML = '';
5337 await renderStreamedVideoPreview(item, previewMount);
5338 return;
5339 }
5340
5341 const blob = await fetchFileBlob(item);
5342 if (!blob) throw new Error('Download failed');
5343
5344 clearPreviewObjectUrl();
5345 const objectUrl = URL.createObjectURL(blob);
5346 STATE.previewObjectUrl = objectUrl;
5347
5348 if (!previewMount.isConnected) return;
5349
5350 previewMount.innerHTML = '';
5351 await renderPreviewBody(item, blob, objectUrl, previewMount);
5352 });
5353 if (expanded) return;
5354 }
5355
5356 toast('Preview unavailable — no source tile found.', 'err');
5357}
5358
5359// ───────────────────────────────────────────────────────────────────────────
5360// UPLOAD
5361// ───────────────────────────────────────────────────────────────────────────
5362
5363async function createFolderInCurrentDir ()
5364{
5365 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5366 if (!canWrite()) { toast('No write access.', 'err'); return; }
5367
5368 const name = await showPrompt('New Folder', 'Enter a name for the new folder:');
5369 if (name == null) return;
5370 const folderName = name.trim();
5371 if (!folderName)
5372 {
5373 toast('Folder name is required.', 'err');
5374 return;
5375 }
5376
5377 try
5378 {
5379 await api('POST', '/files/mkdir', { dir: STATE.currentDir, name: folderName });
5380 toast('Folder created.', 'ok');
5381 await navigateTo(STATE.currentDir, STATE.currentRoot);
5382 } catch (err)
5383 {
5384 toast(err.message, 'err');
5385 }
5386}
5387
5388function canWrite (item = null)
5389{
5390 if (STATE.isAdmin) return true;
5391 const root = item && item._root
5392 ? item._root
5393 : (STATE.currentRoot || (item ? resolveRootForPath(item.path) : null));
5394 if (!root) return false;
5395 if (root.isUserFolder) return true;
5396 const p = STATE.permissions[rootPermissionLabel(root)];
5397 return p && p.write;
5398}
5399
5400async function uploadFiles (fileList)
5401{
5402 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5403 if (!canWrite()) { toast('No write access.', 'err'); return; }
5404
5405 const files = Array.from(fileList || []);
5406 if (!files.length) return;
5407
5408 // Show upload bar
5409 const wrap = document.createElement('div');
5410 wrap.className = 'upload-bar-wrap';
5411 wrap.innerHTML = `<span>Preparing upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
5412 document.body.appendChild(wrap);
5413 STATE.uploadInProgress = true;
5414
5415 try
5416 {
5417 const existingNames = await listDirNameSet(STATE.currentDir);
5418 let done = 0;
5419 let uploaded = 0;
5420
5421 for (const original of files)
5422 {
5423 let fileToUpload = original;
5424
5425 if (existingNames.has(original.name))
5426 {
5427 const suggested = nextAvailableName(original.name, existingNames);
5428 const decision = await showFileConflictChoice(original.name, suggested, 'upload');
5429 if (decision === 'cancel')
5430 {
5431 done++;
5432 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
5433 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
5434 continue;
5435 }
5436
5437 if (decision === 'rename')
5438 {
5439 fileToUpload = cloneFileWithName(original, suggested);
5440 }
5441 }
5442
5443 await uploadSingleFile(fileToUpload, STATE.currentDir);
5444 existingNames.add(fileToUpload.name);
5445 done++;
5446 uploaded++;
5447 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
5448 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
5449 }
5450
5451 toast(`Uploaded ${uploaded} file(s).`, 'ok');
5452 await navigateTo(STATE.currentDir, STATE.currentRoot);
5453 } catch (err)
5454 {
5455 toast(err.message, 'err');
5456 } finally
5457 {
5458 STATE.uploadInProgress = false;
5459 wrap.remove();
5460 }
5461}
5462
5463async function uploadSingleFile (file, targetDir)
5464{
5465 const formData = new FormData();
5466 formData.append('files', file);
5467
5468 await new Promise((resolve, reject) =>
5469 {
5470 const xhr = new XMLHttpRequest();
5471 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
5472 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
5473 xhr.setRequestHeader('X-Fp', getFingerprint());
5474 xhr.setRequestHeader('X-Upload-Size', String(file.size || 0));
5475 xhr.onload = () => xhr.status === 200
5476 ? resolve()
5477 : reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
5478 xhr.onerror = () => reject(new Error('Network error'));
5479 xhr.send(formData);
5480 });
5481}
5482
5483async function ensureServerDir (baseDir, relativeDir)
5484{
5485 const parts = String(relativeDir || '').split(/[\\/]/).filter(Boolean);
5486 let current = baseDir;
5487 for (const part of parts)
5488 {
5489 try
5490 {
5491 const resp = await api('POST', '/files/mkdir', { dir: current, name: part });
5492 current = resp && resp.path ? resp.path : joinServerPath(current, part);
5493 } catch (err)
5494 {
5495 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
5496 current = joinServerPath(current, part);
5497 }
5498 }
5499 return current;
5500}
5501
5502async function uploadFolderInputFiles (fileList)
5503{
5504 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5505 if (!canWrite()) { toast('No write access.', 'err'); return; }
5506 if (!fileList || !fileList.length) return;
5507
5508 const files = Array.from(fileList);
5509 const total = files.length;
5510 let done = 0;
5511
5512 const wrap = document.createElement('div');
5513 wrap.className = 'upload-bar-wrap';
5514 wrap.innerHTML = `<span>Preparing folder upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
5515 document.body.appendChild(wrap);
5516 STATE.uploadInProgress = true;
5517
5518 try
5519 {
5520 const dirCache = new Map();
5521 dirCache.set('', STATE.currentDir);
5522
5523 for (const file of files)
5524 {
5525 const rel = file.webkitRelativePath || file.name;
5526 const relParts = rel.split(/[\\/]/).filter(Boolean);
5527 const relDir = relParts.slice(0, -1).join('/');
5528
5529 if (!dirCache.has(relDir))
5530 {
5531 const parentRel = relParts.slice(0, -2).join('/');
5532 const parentAbs = dirCache.get(parentRel) || await ensureServerDir(STATE.currentDir, parentRel);
5533 const thisName = relParts[relParts.length - 2];
5534
5535 try
5536 {
5537 const created = await api('POST', '/files/mkdir', { dir: parentAbs, name: thisName });
5538 dirCache.set(relDir, created.path || joinServerPath(parentAbs, thisName));
5539 } catch (err)
5540 {
5541 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
5542 dirCache.set(relDir, joinServerPath(parentAbs, thisName));
5543 }
5544 }
5545
5546 const targetDir = dirCache.get(relDir) || STATE.currentDir;
5547 await uploadSingleFile(file, targetDir);
5548 done++;
5549 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
5550 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
5551 }
5552
5553 toast(`Uploaded ${total} file(s).`, 'ok');
5554 await navigateTo(STATE.currentDir, STATE.currentRoot);
5555 } catch (err)
5556 {
5557 toast(err.message, 'err');
5558 } finally
5559 {
5560 STATE.uploadInProgress = false;
5561 wrap.remove();
5562 }
5563}
5564
5565// ───────────────────────────────────────────────────────────────────────────
5566// FOLDER DRAG-AND-DROP (recursive)
5567// ───────────────────────────────────────────────────────────────────────────
5568
5569/**
5570 * Reads all readEntries batches from a DirectoryReader (browsers may return
5571 * results in chunks; we must keep calling until we get an empty array).
5572 */
5573function readAllEntries (reader)
5574{
5575 return new Promise((resolve, reject) =>
5576 {
5577 const all = [];
5578 function next ()
5579 {
5580 reader.readEntries(batch =>
5581 {
5582 if (!batch.length) { resolve(all); return; }
5583 all.push(...batch);
5584 next();
5585 }, reject);
5586 }
5587 next();
5588 });
5589}
5590
5591/**
5592 * Recursively walk a FileSystemEntry tree, creating server-side directories
5593 * on the fly and collecting { file, targetDir } pairs for upload.
5594 */
5595async function collectEntries (entry, serverDir, toUpload)
5596{
5597 if (entry.isFile)
5598 {
5599 const file = await new Promise((res, rej) => entry.file(res, rej));
5600 toUpload.push({ file, targetDir: serverDir });
5601 } else if (entry.isDirectory)
5602 {
5603 // Ask the server to create the directory; it returns the canonical path.
5604 let newServerDir;
5605 try
5606 {
5607 const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
5608 newServerDir = resp.path;
5609 } catch
5610 {
5611 // Directory may already exist — reconstruct path from what we know.
5612 // The server always returns JSON with {error} on failure, so we can
5613 // still continue by falling back to a best-effort path join.
5614 // We rely on the fact that the server separator is consistent within
5615 // a session (the list/browse API already returned paths in that format).
5616 const sep = serverDir.includes('\\') ? '\\' : '/';
5617 newServerDir = serverDir + sep + entry.name;
5618 }
5619 const reader = entry.createReader();
5620 const subEntries = await readAllEntries(reader);
5621 for (const sub of subEntries)
5622 {
5623 await collectEntries(sub, newServerDir, toUpload);
5624 }
5625 }
5626}
5627
5628async function uploadEntries (entries)
5629{
5630 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5631 if (!canWrite()) { toast('No write access.', 'err'); return; }
5632
5633 const wrap = document.createElement('div');
5634 wrap.className = 'upload-bar-wrap';
5635 wrap.innerHTML = `<span>Scanning…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
5636 document.body.appendChild(wrap);
5637 STATE.uploadInProgress = true;
5638
5639 try
5640 {
5641 const toUpload = [];
5642 for (const entry of entries)
5643 {
5644 await collectEntries(entry, STATE.currentDir, toUpload);
5645 }
5646
5647 if (!toUpload.length) { toast('No files found.', 'err'); return; }
5648
5649 let done = 0;
5650 const total = toUpload.length;
5651 const updateBar = () =>
5652 {
5653 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
5654 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
5655 };
5656 updateBar();
5657
5658 for (const { file, targetDir } of toUpload)
5659 {
5660 await uploadSingleFile(file, targetDir);
5661 done++;
5662 updateBar();
5663 }
5664
5665 toast(`Uploaded ${total} file(s).`, 'ok');
5666 await navigateTo(STATE.currentDir, STATE.currentRoot);
5667 } catch (err)
5668 {
5669 toast(err.message, 'err');
5670 } finally
5671 {
5672 STATE.uploadInProgress = false;
5673 wrap.remove();
5674 }
5675}
5676
5677// DRAG-AND-DROP
5678// ───────────────────────────────────────────────────────────────────────────
5679
5680function initDragDrop ()
5681{
5682 const main = document.getElementById('main-content');
5683 const dropOvl = document.getElementById('drop-overlay');
5684 let dragDepth = 0;
5685
5686 main.addEventListener('dragenter', e =>
5687 {
5688 e.preventDefault();
5689 dragDepth++;
5690 dropOvl.classList.remove('hidden');
5691 });
5692 main.addEventListener('dragleave', () =>
5693 {
5694 dragDepth--;
5695 if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
5696 });
5697 main.addEventListener('dragover', e => e.preventDefault());
5698 main.addEventListener('drop', async e =>
5699 {
5700 e.preventDefault();
5701 dragDepth = 0;
5702 dropOvl.classList.add('hidden');
5703 if (!canWrite()) { toast('No write access.', 'err'); return; }
5704
5705 const items = Array.from(e.dataTransfer.items || []);
5706 // Use the FileSystem Entry API when available so we can handle folders.
5707 if (items.length && typeof items[0].webkitGetAsEntry === 'function')
5708 {
5709 const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
5710 if (entries.some(en => en.isDirectory))
5711 {
5712 await uploadEntries(entries);
5713 return;
5714 }
5715 }
5716 // Plain files only — use the fast batch path.
5717 const files = e.dataTransfer.files;
5718 if (files.length) await uploadFiles(files);
5719 });
5720}
5721
5722// ───────────────────────────────────────────────────────────────────────────
5723// RENAME
5724// ───────────────────────────────────────────────────────────────────────────
5725
5726function openRenameModal (item)
5727{
5728 const modal = document.getElementById('rename-modal');
5729 modal.classList.remove('hidden');
5730 const input = document.getElementById('rename-input');
5731 input.value = item.name;
5732 input.focus();
5733 input.select();
5734 document.getElementById('rename-error').classList.add('hidden');
5735 document.getElementById('rename-form').onsubmit = async (e) =>
5736 {
5737 e.preventDefault();
5738 const newName = input.value.trim();
5739 if (!newName) return;
5740 try
5741 {
5742 if (item._root)
5743 {
5744 await api('POST', '/files/root-alias', { rootPath: item.path, alias: newName });
5745 } else
5746 {
5747 await api('POST', '/files/rename', { from: item.path, to: newName });
5748 }
5749 modal.classList.add('hidden');
5750 toast(item._root ? 'Alias updated.' : 'Renamed.', 'ok');
5751 if (item._root)
5752 {
5753 await loadRoots({
5754 preferredDir: STATE.currentDir,
5755 preferredRootPath: (STATE.currentRoot && STATE.currentRoot.path) || item.path,
5756 });
5757 } else
5758 {
5759 await navigateTo(STATE.currentDir, STATE.currentRoot);
5760 }
5761 } catch (err)
5762 {
5763 document.getElementById('rename-error').textContent = err.message;
5764 document.getElementById('rename-error').classList.remove('hidden');
5765 }
5766 };
5767}
5768
5769// ───────────────────────────────────────────────────────────────────────────
5770// DELETE
5771// ───────────────────────────────────────────────────────────────────────────
5772
5773async function deleteItem (item)
5774{
5775 if (!await showConfirm('Delete item', `Delete "${item.name}"? This cannot be undone.`)) return;
5776 try
5777 {
5778 await api('POST', '/files/delete', { path: item.path });
5779 toast('Deleted.', 'ok');
5780 closeSidebar();
5781 await navigateTo(STATE.currentDir, STATE.currentRoot);
5782 } catch (err)
5783 {
5784 toast(err.message, 'err');
5785 }
5786}
5787
5788// ───────────────────────────────────────────────────────────────────────────
5789// ADMIN PANEL
5790// ───────────────────────────────────────────────────────────────────────────
5791
5792let _adminUpdateStatus = null;
5793
5794function animateBadgeToTarget (targetEl)
5795{
5796 const badge = document.getElementById('admin-update-badge');
5797 if (!badge || !targetEl) return;
5798 if (badge.parentElement === targetEl) return;
5799
5800 const from = badge.getBoundingClientRect();
5801 targetEl.appendChild(badge);
5802 const to = badge.getBoundingClientRect();
5803
5804 const dx = from.left - to.left;
5805 const dy = from.top - to.top;
5806
5807 badge.style.transition = 'none';
5808 badge.style.transform = `translate(${dx}px, ${dy}px)`;
5809 badge.style.willChange = 'transform';
5810
5811 requestAnimationFrame(() =>
5812 {
5813 badge.style.transition = 'transform 240ms cubic-bezier(0.22, 1, 0.36, 1)';
5814 badge.style.transform = 'translate(0, 0)';
5815 });
5816
5817 const cleanup = () =>
5818 {
5819 badge.style.transition = '';
5820 badge.style.transform = '';
5821 badge.style.willChange = '';
5822 badge.removeEventListener('transitionend', cleanup);
5823 };
5824 badge.addEventListener('transitionend', cleanup);
5825}
5826
5827function moveBadgeToTarget (targetEl)
5828{
5829 const badge = document.getElementById('admin-update-badge');
5830 if (!badge || !targetEl) return;
5831 if (badge.parentElement === targetEl) return;
5832
5833 badge.style.transition = '';
5834 badge.style.transform = '';
5835 badge.style.willChange = '';
5836 targetEl.appendChild(badge);
5837}
5838
5839function syncAdminUpdateBadgeAnchor ({ animate = true, forceUserAnchor = false } = {})
5840{
5841 const badge = document.getElementById('admin-update-badge');
5842 const userMenuBtn = document.getElementById('btn-user-menu');
5843 const adminBtn = document.getElementById('btn-admin');
5844 if (!badge || !userMenuBtn || !adminBtn) return;
5845
5846 const userDropdown = userMenuBtn.closest('.topbar-dropdown');
5847 const userMenuOpen = !!(userDropdown && userDropdown.classList.contains('open'));
5848 const target = forceUserAnchor ? userMenuBtn : (userMenuOpen ? adminBtn : userMenuBtn);
5849
5850 if (badge.classList.contains('hidden'))
5851 {
5852 moveBadgeToTarget(userMenuBtn);
5853 return;
5854 }
5855
5856 if (animate) animateBadgeToTarget(target);
5857 else moveBadgeToTarget(target);
5858}
5859
5860function setAdminUpdateBadge (count)
5861{
5862 const badge = document.getElementById('admin-update-badge');
5863 const userMenuBtn = document.getElementById('btn-user-menu');
5864 if (!badge || !userMenuBtn) return;
5865
5866 if (!STATE.isAdmin || !Number.isFinite(count) || count <= 0)
5867 {
5868 badge.classList.add('hidden');
5869 badge.textContent = '';
5870 if (badge.parentElement !== userMenuBtn) userMenuBtn.appendChild(badge);
5871 userMenuBtn.removeAttribute('data-update-count');
5872 return;
5873 }
5874
5875 const whole = Math.floor(count);
5876 const capped = Math.min(whole, 99);
5877 badge.textContent = capped >= 99 ? '99+' : String(capped);
5878 badge.classList.remove('hidden');
5879 userMenuBtn.dataset.updateCount = String(whole);
5880 syncAdminUpdateBadgeAnchor();
5881}
5882
5883function pulseAdminUpdateButton ()
5884{
5885 const btn = document.getElementById('admin-shutdown-btn');
5886 if (!btn) return;
5887
5888 if (typeof btn.scrollIntoView === 'function')
5889 {
5890 btn.scrollIntoView({ behavior: 'smooth', block: 'center' });
5891 }
5892
5893 btn.classList.remove('admin-update-highlight');
5894 // Force reflow so repeated openings can replay the pulse animation.
5895 void btn.offsetWidth;
5896 btn.classList.add('admin-update-highlight');
5897
5898 setTimeout(() =>
5899 {
5900 btn.classList.remove('admin-update-highlight');
5901 }, 1800);
5902}
5903
5904async function openAdminModal ()
5905{
5906 document.getElementById('admin-modal').classList.remove('hidden');
5907 await refreshGlobalFavicon();
5908 await refreshAdminConfig();
5909 await refreshAdminUsers();
5910 await refreshAdminUpdateStatus({ pulseIfUpdateAvailable: true });
5911}
5912
5913async function refreshAdminConfig ()
5914{
5915 const data = await api('GET', '/admin/config');
5916 if (!data) return;
5917
5918 const userPathInput = document.getElementById('admin-user-path');
5919 const sizeInput = document.getElementById('admin-user-size-limit');
5920 if (userPathInput) userPathInput.value = data.userPath || '';
5921 if (sizeInput)
5922 {
5923 sizeInput.value = data.userFolderSizeLimit ? formatBytes(data.userFolderSizeLimit) : '';
5924 updateAdminSizeFeedback(sizeInput.value);
5925 }
5926
5927 const container = document.getElementById('admin-paths');
5928 container.innerHTML = '';
5929 for (const p of data.paths)
5930 {
5931 const row = document.createElement('div');
5932 row.className = 'path-row';
5933 row.innerHTML = `<span>${p}</span><button data-path="${p}" title="Remove">✕</button>`;
5934 row.querySelector('button').addEventListener('click', () =>
5935 {
5936 row.remove();
5937 });
5938 container.appendChild(row);
5939 }
5940}
5941
5942async function refreshAdminUsers ()
5943{
5944 const data = await api('GET', '/admin/users');
5945 if (!data) return;
5946 const container = document.getElementById('admin-users-list');
5947 container.innerHTML = '';
5948
5949 // Need paths for permission rows
5950 const cfg = await api('GET', '/admin/config');
5951 const paths = cfg ? (cfg.effectivePaths || []) : [];
5952
5953 for (const u of data.users)
5954 {
5955 const row = document.createElement('div');
5956 row.className = 'user-row';
5957 row.innerHTML = `
5958 <span class="user-name">${u.username}</span>
5959 ${u.isAdmin ? '<span class="user-admin-badge">Admin</span>' : ''}
5960 <button data-id="${u.id}" data-action="edit">Edit</button>
5961 ${u.username === STATE.username ? '' : `<button data-id="${u.id}" data-action="delete" class="danger">Delete</button>`}
5962 `;
5963 row.querySelector('[data-action="edit"]').addEventListener('click', () =>
5964 openUserModal(u, paths));
5965 const deleteBtn = row.querySelector('[data-action="delete"]');
5966 if (deleteBtn) deleteBtn.addEventListener('click', async () =>
5967 {
5968 if (!await showConfirm('Delete user', `Delete user "${u.username}"? This cannot be undone.`)) return;
5969 try
5970 {
5971 await api('DELETE', `/admin/users/${u.id}`);
5972 toast('User deleted.', 'ok');
5973 await refreshAdminUsers();
5974 } catch (err) { toast(err.message, 'err'); }
5975 });
5976 container.appendChild(row);
5977 }
5978
5979 await refreshAdminOrphanUserFolders();
5980}
5981
5982async function refreshAdminOrphanUserFolders ()
5983{
5984 const section = document.getElementById('admin-orphan-userfolders-section');
5985 const list = document.getElementById('admin-orphan-userfolders-list');
5986 if (!section || !list) return;
5987
5988 let data = null;
5989 try
5990 {
5991 data = await api('GET', '/admin/orphan-userfolders');
5992 } catch
5993 {
5994 section.classList.add('hidden');
5995 list.innerHTML = '';
5996 return;
5997 }
5998
5999 const folders = Array.isArray(data && data.folders) ? data.folders : [];
6000 if (!folders.length)
6001 {
6002 section.classList.add('hidden');
6003 list.innerHTML = '';
6004 return;
6005 }
6006
6007 section.classList.remove('hidden');
6008 list.innerHTML = '';
6009
6010 for (const folder of folders)
6011 {
6012 const row = document.createElement('div');
6013 row.className = 'user-row orphan-folder-row';
6014
6015 const name = document.createElement('span');
6016 name.className = 'user-name';
6017 name.textContent = folder.folderName || 'Unknown folder';
6018
6019 const info = document.createElement('span');
6020 info.className = 'orphan-folder-meta';
6021 const itemCount = Number(folder.itemCount) || 0;
6022 info.textContent = `${itemCount} item${itemCount === 1 ? '' : 's'}`;
6023
6024 const openBtn = document.createElement('button');
6025 openBtn.dataset.action = 'open-orphan-folder';
6026 openBtn.textContent = 'Open folder';
6027 openBtn.addEventListener('click', async () =>
6028 {
6029 const targetPath = String(folder.path || '').trim();
6030 if (!targetPath) return;
6031
6032 try
6033 {
6034 const syntheticRoot = {
6035 label: name.textContent,
6036 originalName: name.textContent,
6037 alias: null,
6038 path: targetPath,
6039 isUserFolder: true,
6040 isOrphanUserFolder: true,
6041 };
6042 await navigateTo(targetPath, syntheticRoot);
6043 document.getElementById('admin-modal').classList.add('hidden');
6044 } catch (err)
6045 {
6046 toast(err.message || 'Failed to open folder.', 'err');
6047 }
6048 });
6049
6050 row.appendChild(name);
6051 row.appendChild(info);
6052 row.appendChild(openBtn);
6053 list.appendChild(row);
6054 }
6055}
6056
6057async function refreshAdminUpdateStatus (opts = {})
6058{
6059 const pulseIfUpdateAvailable = !!opts.pulseIfUpdateAvailable;
6060 const btn = document.getElementById('admin-shutdown-btn');
6061 _adminUpdateStatus = null;
6062 btn.textContent = 'Shut down server';
6063 setAdminUpdateBadge(0);
6064
6065 try
6066 {
6067 const data = await api('GET', '/admin/update-status');
6068 if (!data) return;
6069 _adminUpdateStatus = data;
6070
6071 const updateCount = (data.underSystemd && Array.isArray(data.commitsAhead))
6072 ? data.commitsAhead.length
6073 : 0;
6074 setAdminUpdateBadge(updateCount);
6075
6076 if (!data.underSystemd)
6077 {
6078 btn.textContent = 'Shut down server';
6079 }
6080 else if (data.commitsAhead.length === 0)
6081 {
6082 btn.textContent = 'Restart Server';
6083 }
6084 else
6085 {
6086 btn.textContent = 'Restart & Update';
6087 if (pulseIfUpdateAvailable) pulseAdminUpdateButton();
6088 }
6089 }
6090 catch
6091 {
6092 // Not critical; button stays as "Shut down server".
6093 }
6094}
6095
6096function openUserModal (user, paths)
6097{
6098 const modal = document.getElementById('user-modal');
6099 modal.classList.remove('hidden');
6100 document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
6101 document.getElementById('user-error').classList.add('hidden');
6102
6103 const usernameInput = document.getElementById('user-username');
6104 usernameInput.value = user ? user.username : '';
6105 usernameInput.readOnly = !!user;
6106
6107 document.getElementById('user-password').value = '';
6108 const adminChk = document.getElementById('user-is-admin');
6109 const editingOwnAccount = !!(user
6110 && String(user.username || '').toLowerCase() === String(STATE.username || '').toLowerCase());
6111 adminChk.checked = user ? user.isAdmin : false;
6112 adminChk.disabled = editingOwnAccount;
6113 adminChk.title = editingOwnAccount
6114 ? 'You cannot remove admin privileges from your own account.'
6115 : '';
6116
6117 // Password placeholder
6118 document.getElementById('user-password').placeholder =
6119 user ? 'Leave blank to keep current' : 'Min 8 characters';
6120
6121 // Build permissions grid
6122 const permDiv = document.getElementById('user-permissions');
6123 permDiv.innerHTML = '';
6124 if (paths.length)
6125 {
6126 const heading = document.createElement('h4');
6127 heading.textContent = 'Path Permissions';
6128 permDiv.appendChild(heading);
6129
6130 const isAdminUser = !!(user && user.isAdmin);
6131 // Mirror the is-admin checkbox so toggling it live-updates the perm rows.
6132 const rebuildPermRows = (admin) =>
6133 {
6134 permDiv.querySelectorAll('.perm-row').forEach(r =>
6135 {
6136 r.querySelectorAll('input[type=checkbox]').forEach(cb =>
6137 {
6138 cb.disabled = admin;
6139 if (admin) cb.checked = true;
6140 });
6141 r.title = admin ? 'Admins always have full access' : '';
6142 });
6143 };
6144 adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
6145
6146 const syncReadWriteConstraints = (row, admin = false) =>
6147 {
6148 const readCb = row.querySelector('input[data-type="read"]');
6149 const writeCb = row.querySelector('input[data-type="write"]');
6150 if (!readCb || !writeCb) return;
6151
6152 if (admin)
6153 {
6154 readCb.checked = true;
6155 writeCb.checked = true;
6156 readCb.disabled = true;
6157 writeCb.disabled = true;
6158 return;
6159 }
6160
6161 readCb.disabled = false;
6162 if (!readCb.checked)
6163 {
6164 writeCb.checked = false;
6165 writeCb.disabled = true;
6166 }
6167 else
6168 {
6169 writeCb.disabled = false;
6170 }
6171 };
6172
6173 const syncAllReadWriteConstraints = () =>
6174 {
6175 const admin = adminChk.checked;
6176 permDiv.querySelectorAll('.perm-row').forEach((row) =>
6177 {
6178 syncReadWriteConstraints(row, admin);
6179 });
6180 };
6181
6182 for (const p of paths)
6183 {
6184 const label = p.split(/[\\/]/).pop();
6185 const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
6186 const row = document.createElement('div');
6187 row.className = 'perm-row';
6188 const readChecked = isAdminUser || perms.read;
6189 const writeChecked = isAdminUser || perms.write;
6190 row.innerHTML = `
6191 <span class="perm-label">${label}</span>
6192 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="read" ${readChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Read</label>
6193 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="write" ${writeChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Write</label>
6194 `;
6195 if (isAdminUser) row.title = 'Admins always have full access';
6196 const readCb = row.querySelector('input[data-type="read"]');
6197 if (readCb)
6198 {
6199 readCb.addEventListener('change', () =>
6200 {
6201 syncReadWriteConstraints(row, adminChk.checked);
6202 });
6203 }
6204 permDiv.appendChild(row);
6205 }
6206
6207 syncAllReadWriteConstraints();
6208 adminChk.addEventListener('change', syncAllReadWriteConstraints);
6209 }
6210
6211 document.getElementById('user-form').onsubmit = async (e) =>
6212 {
6213 e.preventDefault();
6214 const password = document.getElementById('user-password').value;
6215 const isAdmin = document.getElementById('user-is-admin').checked;
6216 const permissions = {};
6217 permDiv.querySelectorAll('input[data-label]').forEach(cb =>
6218 {
6219 const lbl = cb.dataset.label;
6220 if (!permissions[lbl]) permissions[lbl] = {};
6221 permissions[lbl][cb.dataset.type] = cb.checked;
6222 });
6223
6224 try
6225 {
6226 if (user)
6227 {
6228 const body = { isAdmin, permissions };
6229 if (password) body.password = password;
6230 await api('PATCH', `/admin/users/${user.id}`, body);
6231 } else
6232 {
6233 const uname = document.getElementById('user-username').value.trim();
6234 await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
6235 }
6236 modal.classList.add('hidden');
6237 toast('User saved.', 'ok');
6238 await refreshAdminUsers();
6239 } catch (err)
6240 {
6241 document.getElementById('user-error').textContent = err.message;
6242 document.getElementById('user-error').classList.remove('hidden');
6243 }
6244 };
6245}
6246
6247// ───────────────────────────────────────────────────────────────────────────
6248// SVG ICONS
6249// ───────────────────────────────────────────────────────────────────────────
6250
6251const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif']);
6252const VIDEO_EXTS = new Set(['mp4', 'webm', 'ogv', 'mov', 'avi', 'mkv']);
6253const AUDIO_EXTS = new Set(['mp3', 'ogg', 'wav', 'flac', 'aac', 'm4a']);
6254const MODEL_EXTS = new Set(['stl', 'obj']);
6255const DOC_EXTS = new Set(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp']);
6256const 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']);
6257const ARCHIVE_EXTS = new Set(['zip', 'tar', 'gz', 'bz2', 'xz', 'rar', '7z']);
6258const MAX_DIRECT_SVG_THUMB_BYTES = 1024 * 1024;
6259
6260function iconFolder (size = 52)
6261{
6262 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
6263 stroke="#5b7fff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
6264 <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"/>
6265 </svg>`;
6266}
6267
6268function iconFile (name, size = 52)
6269{
6270 const color = fileAccentColor(name);
6271 let symbol = '';
6272
6273 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
6274 stroke="${color}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
6275 <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
6276 <polyline points="14 2 14 8 20 8"/>
6277 </svg>`;
6278}
6279
6280function watchStatusForTile (item)
6281{
6282 if (!item || item.isDir) return null;
6283 if (!VIDEO_EXTS.has(extOf(item.name || ''))) return null;
6284
6285 const cached = STATE.watchedStatusByPath[item.path];
6286 if (cached === 'fully' || cached === 'partway') return cached;
6287
6288 const currentUser = String(STATE.username || '').trim();
6289 if (!currentUser) return null;
6290
6291 const watchedBy = item.watchedBy && typeof item.watchedBy === 'object' ? item.watchedBy : {};
6292 const statusRaw = watchedBy[currentUser];
6293 const status = String(statusRaw || '').toLowerCase();
6294 if (status === 'fully' || status === 'partway') return status;
6295 return null;
6296}
6297
6298function renderWatchedOverlayOnIcon (iconEl, watchStatus)
6299{
6300 if (!iconEl) return;
6301
6302 const existing = iconEl.querySelector('.watched-overlay');
6303 if (existing) existing.remove();
6304 if (watchStatus !== 'fully' && watchStatus !== 'partway') return;
6305
6306 const overlay = document.createElement('div');
6307 overlay.className = `watched-overlay watched-overlay--${watchStatus}`;
6308 overlay.innerHTML = watchedEyeFilledSvg();
6309 iconEl.appendChild(overlay);
6310}
6311
6312function findTileIconByPath (filePath)
6313{
6314 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return null;
6315 const tile = Array.from(document.querySelectorAll('.file-item')).find((el) => el.dataset.path === filePath);
6316 if (!tile) return null;
6317 return tile.querySelector('.icon');
6318}
6319
6320function watchStatusFromWatchedBy (watchedBy)
6321{
6322 const currentUser = String(STATE.username || '').trim();
6323 if (!currentUser) return null;
6324
6325 const map = watchedBy && typeof watchedBy === 'object' ? watchedBy : {};
6326 const statusRaw = map[currentUser];
6327 const status = String(statusRaw || '').toLowerCase();
6328 if (status === 'fully' || status === 'partway') return status;
6329 return null;
6330}
6331
6332async function loadWatchedStatusesForCurrentDir ()
6333{
6334 const dirAtStart = STATE.currentDir;
6335 if (!dirAtStart) return;
6336
6337 const videoItems = (STATE.items || []).filter((item) =>
6338 item && !item.isDir && VIDEO_EXTS.has(extOf(item.name || ''))
6339 );
6340 if (!videoItems.length) return;
6341
6342 const loadId = ++STATE.watchedLoadId;
6343
6344 let statusMap = null;
6345 const filePaths = videoItems.map((item) => item.path);
6346
6347 const bulk = await api('POST', '/files/watched-statuses', { filePaths }).catch(() => null);
6348 if (bulk && bulk.statuses && typeof bulk.statuses === 'object')
6349 {
6350 statusMap = {};
6351 for (const item of videoItems)
6352 {
6353 const status = String(bulk.statuses[item.path] || '').toLowerCase();
6354 statusMap[item.path] = status === 'fully' || status === 'partway' ? status : null;
6355 }
6356 }
6357
6358 // Compatibility fallback for older servers that do not expose bulk statuses yet.
6359 if (!statusMap)
6360 {
6361 statusMap = {};
6362 const statuses = await Promise.all(videoItems.map(async (item) =>
6363 {
6364 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`).catch(() => null);
6365 return {
6366 path: item.path,
6367 status: watchStatusFromWatchedBy(meta && meta.watchedBy),
6368 };
6369 }));
6370
6371 for (const entry of statuses)
6372 {
6373 statusMap[entry.path] = entry.status;
6374 }
6375 }
6376
6377 if (loadId !== STATE.watchedLoadId) return;
6378 if (!samePath(STATE.currentDir, dirAtStart)) return;
6379 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return;
6380
6381 for (const item of videoItems)
6382 {
6383 const status = statusMap[item.path] || null;
6384 if (status) STATE.watchedStatusByPath[item.path] = status;
6385 else delete STATE.watchedStatusByPath[item.path];
6386
6387 const iconEl = findTileIconByPath(item.path);
6388 renderWatchedOverlayOnIcon(iconEl, status);
6389 }
6390}
6391
6392function watchedEyeFilledSvg ()
6393{
6394 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>`;
6395}
6396
6397// ───────────────────────────────────────────────────────────────────────────
6398// EVENT WIRING
6399// ───────────────────────────────────────────────────────────────────────────
6400
6401// ───────────────────────────────────────────────────────────────────────────
6402// THUMBNAIL PREVIEWS
6403// ───────────────────────────────────────────────────────────────────────────
6404
6405function revokeThumbnails ()
6406{
6407 STATE.thumbnailUrls.forEach(u => URL.revokeObjectURL(u));
6408 STATE.thumbnailUrls = [];
6409}
6410
6411function disconnectThumbnailObserver ()
6412{
6413 if (!STATE.thumbnailObserver) return;
6414 STATE.thumbnailObserver.disconnect();
6415 STATE.thumbnailObserver = null;
6416}
6417
6418function disconnectFolderIconObserver ()
6419{
6420 if (!STATE.folderIconObserver) return;
6421 STATE.folderIconObserver.disconnect();
6422 STATE.folderIconObserver = null;
6423}
6424
6425function setThumbnailPending (iconEl, pending)
6426{
6427 if (!iconEl) return;
6428 if (pending)
6429 {
6430 iconEl.classList.add('thumb-pending');
6431 iconEl.dataset.thumbPending = '1';
6432 return;
6433 }
6434
6435 iconEl.classList.remove('thumb-pending');
6436 delete iconEl.dataset.thumbPending;
6437}
6438
6439function getThumbnailKind (name)
6440{
6441 const ext = extOf(name || '');
6442 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || MODEL_EXTS.has(ext)) return 'image';
6443 if (CODE_EXTS.has(ext)) return 'text';
6444 return 'badge';
6445}
6446
6447function maxThumbBytesForKind (kind)
6448{
6449 if (kind === 'image') return 15 * 1024 * 1024;
6450 if (kind === 'text') return 1024 * 1024;
6451 return 0;
6452}
6453
6454function drawTokenizedLine (ctx, line, x, y)
6455{
6456 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;
6457 let last = 0;
6458 let cursor = x;
6459 for (const m of line.matchAll(tokenRe))
6460 {
6461 const i = m.index == null ? 0 : m.index;
6462 if (i > last)
6463 {
6464 const plain = line.slice(last, i);
6465 ctx.fillStyle = '#dce4ff';
6466 ctx.fillText(plain, cursor, y);
6467 cursor += ctx.measureText(plain).width;
6468 }
6469
6470 const tok = m[0];
6471 if (/^\/\//.test(tok) || /^\/\*/.test(tok)) ctx.fillStyle = '#6f7f9a';
6472 else if (/^['"`]/.test(tok)) ctx.fillStyle = '#9ee37d';
6473 else if (/^\d/.test(tok)) ctx.fillStyle = '#f8c46a';
6474 else ctx.fillStyle = '#8bb4ff';
6475
6476 ctx.fillText(tok, cursor, y);
6477 cursor += ctx.measureText(tok).width;
6478 last = i + tok.length;
6479 }
6480
6481 if (last < line.length)
6482 {
6483 const tail = line.slice(last);
6484 ctx.fillStyle = '#dce4ff';
6485 ctx.fillText(tail, cursor, y);
6486 }
6487}
6488
6489function textThumbnailDataUrl (text)
6490{
6491 const canvas = document.createElement('canvas');
6492 canvas.width = 160;
6493 canvas.height = 200;
6494 const ctx = canvas.getContext('2d');
6495 if (!ctx) return null;
6496
6497 ctx.fillStyle = '#0d111a';
6498 ctx.fillRect(0, 0, canvas.width, canvas.height);
6499 ctx.font = '8px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace';
6500 ctx.textBaseline = 'top';
6501
6502 const lines = String(text || '')
6503 .replace(/\r\n/g, '\n')
6504 .split('\n')
6505 .slice(0, 17);
6506
6507 let y = 8;
6508 for (const line of lines)
6509 {
6510 drawTokenizedLine(ctx, line.slice(0, 42), 6, y);
6511 y += 11;
6512 if (y > 190) break;
6513 }
6514 return canvas.toDataURL('image/png');
6515}
6516
6517function badgeThumbnailDataUrl (name, kind)
6518{
6519 const canvas = document.createElement('canvas');
6520 canvas.width = 160;
6521 canvas.height = 200;
6522 const ctx = canvas.getContext('2d');
6523 if (!ctx) return null;
6524
6525 const ext = (extOf(name || '') || 'file').toUpperCase().slice(0, 5);
6526 const color = '#5b7fff';
6527
6528 ctx.fillStyle = '#111826';
6529 ctx.fillRect(0, 0, 160, 200);
6530 ctx.fillStyle = color;
6531 ctx.fillRect(0, 0, 160, 28);
6532 ctx.fillStyle = '#ffffff';
6533 ctx.font = 'bold 12px sans-serif';
6534 ctx.textAlign = 'center';
6535 ctx.fillText(ext, 80, 8);
6536 ctx.textAlign = 'left';
6537 ctx.fillStyle = '#9fb1d8';
6538 ctx.font = '10px sans-serif';
6539 ctx.fillText('Preview', 8, 48);
6540 ctx.fillStyle = '#dce4ff';
6541 ctx.font = 'bold 11px sans-serif';
6542 ctx.fillText(ext, 8, 66);
6543 return canvas.toDataURL('image/png');
6544}
6545
6546async functio
6547… afgekapt