BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

app.js 227.0 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 closeDebugModal();
1698 document.getElementById('app').classList.add('hidden');
1699 const overlay = document.getElementById('auth-overlay');
1700 const usernameInput = document.getElementById('auth-username');
1701 const passwordInput = document.getElementById('auth-password');
1702 overlay.classList.remove('hidden');
1703 document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
1704 document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
1705 const submitBtn = document.getElementById('auth-submit');
1706 submitBtn.disabled = false;
1707 submitBtn.textContent = setupMode ? 'Create Account' : 'Sign In';
1708 document.getElementById('auth-error').classList.add('hidden');
1709 usernameInput.value = '';
1710 passwordInput.value = '';
1711 usernameInput.autocomplete = 'username';
1712 passwordInput.autocomplete = setupMode ? 'new-password' : 'current-password';
1713 usernameInput.focus();
1714 document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
1715}
1716
1717function showApp ()
1718{
1719 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1720 document.getElementById('auth-overlay').classList.add('hidden');
1721 document.getElementById('app').classList.remove('hidden');
1722 if (isMobileViewport())
1723 {
1724 hideSidebarPanel();
1725 } else
1726 {
1727 openFolderSidebar();
1728 }
1729 document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
1730 document.getElementById('btn-debug').classList.toggle('hidden', !STATE.isAdmin);
1731 const userLabel = document.getElementById('user-menu-label');
1732 if (userLabel) userLabel.textContent = STATE.username || 'User';
1733 void refreshGlobalFavicon();
1734 if (STATE.isAdmin)
1735 {
1736 void refreshAdminUpdateStatus();
1737 }
1738 else
1739 {
1740 setAdminUpdateBadge(0);
1741 }
1742 startAutoRefresh();
1743}
1744
1745async function initAuth ()
1746{
1747 // Generate a fresh key pair in the background; login falls back gracefully
1748 // while this is still in progress.
1749 generateClientKeyPair().catch(() =>
1750 {
1751 toast('Secure crypto unavailable in this browser context; using compatibility login mode.', 'err');
1752 });
1753
1754 // Fetch server public key
1755 const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
1756 if (publicKey) STATE.serverPublicKeyJwk = publicKey;
1757 if (!publicKey && hasWebCrypto()) { toast('Could not reach server.', 'err'); return; }
1758 STATE.serverPublicKeyJwk = publicKey;
1759
1760 // Check whether first-run setup is needed
1761 const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
1762
1763 if (!needed)
1764 {
1765 const saved = loadSessionState();
1766 if (saved && saved.token)
1767 {
1768 STATE.token = saved.token;
1769 STATE.restoreDir = saved.dir || null;
1770 STATE.restoreRootPath = saved.rootPath || null;
1771 STATE.lastOperationAt = saved.lastOperationAt;
1772
1773 const me = await api('GET', '/auth/me', null, { noAutoLogout: true }).catch(() => null);
1774 if (me)
1775 {
1776 STATE.username = me.username;
1777 STATE.isAdmin = me.isAdmin;
1778 STATE.permissions = me.permissions;
1779 showApp();
1780 await loadRoots({
1781 preferredDir: STATE.restoreDir,
1782 preferredRootPath: STATE.restoreRootPath,
1783 });
1784 return;
1785 }
1786
1787 STATE.token = null;
1788 clearSessionState();
1789 }
1790 }
1791
1792 showAuthOverlay(needed);
1793}
1794
1795async function doLogin (username, password, isSetup)
1796{
1797 const encrypted = await hybridEncryptForServer({ username, password });
1798 const endpoint = isSetup ? '/auth/setup' : '/auth/login';
1799
1800 let data;
1801 try
1802 {
1803 data = await api('POST', endpoint, {
1804 encrypted,
1805 clientPublicKey: STATE.clientPublicKeyJwk,
1806 fingerprint: getFingerprint(),
1807 });
1808 } catch (err)
1809 {
1810 return err.message;
1811 }
1812
1813 if (!data) return 'Login failed.';
1814
1815 // Decrypt the token sent back by the server
1816 const token = await hybridDecryptFromServer(data.encrypted || data);
1817 if (!token) return 'Login failed.';
1818 STATE.token = token;
1819
1820 // Load user info
1821 const me = await api('GET', '/auth/me');
1822 if (!me) return 'Session error.';
1823
1824 STATE.username = me.username;
1825 STATE.isAdmin = me.isAdmin;
1826 STATE.permissions = me.permissions;
1827
1828 saveSessionState();
1829 showApp();
1830 await loadRoots();
1831 return null; // no error
1832}
1833
1834function logout ()
1835{
1836 void performLogout();
1837}
1838
1839function openChangePasswordModal ()
1840{
1841 const modal = document.getElementById('change-password-modal');
1842 const form = document.getElementById('change-password-form');
1843 const currentInput = document.getElementById('change-password-current');
1844 const nextInput = document.getElementById('change-password-next');
1845 const confirmInput = document.getElementById('change-password-confirm');
1846 const errorEl = document.getElementById('change-password-error');
1847
1848 function hide ()
1849 {
1850 modal.classList.add('hidden');
1851 form.onsubmit = null;
1852 }
1853
1854 currentInput.value = '';
1855 nextInput.value = '';
1856 confirmInput.value = '';
1857 errorEl.textContent = '';
1858 errorEl.classList.add('hidden');
1859 modal.classList.remove('hidden');
1860 currentInput.focus();
1861
1862 form.onsubmit = async (e) =>
1863 {
1864 e.preventDefault();
1865 const currentPassword = currentInput.value;
1866 const newPassword = nextInput.value;
1867 const confirmPassword = confirmInput.value;
1868
1869 if (newPassword !== confirmPassword)
1870 {
1871 errorEl.textContent = 'New passwords do not match.';
1872 errorEl.classList.remove('hidden');
1873 return;
1874 }
1875
1876 if (newPassword.length < 8)
1877 {
1878 errorEl.textContent = 'New password must be at least 8 characters.';
1879 errorEl.classList.remove('hidden');
1880 return;
1881 }
1882
1883 try
1884 {
1885 await api('POST', '/auth/change-password', {
1886 currentPassword,
1887 newPassword,
1888 });
1889 hide();
1890 toast('Password changed.', 'ok');
1891 }
1892 catch (err)
1893 {
1894 errorEl.textContent = err.message || 'Failed to change password.';
1895 errorEl.classList.remove('hidden');
1896 }
1897 };
1898}
1899
1900async function performLogout ()
1901{
1902 const tokenAtStart = STATE.token;
1903 stopAutoRefresh();
1904
1905 if (tokenAtStart)
1906 {
1907 try
1908 {
1909 await api('POST', '/auth/logout', {}, { noAutoLogout: true });
1910 } catch
1911 {
1912 // Ignore network errors while logging out locally.
1913 }
1914 }
1915
1916 STATE.token = null;
1917 STATE.username = null;
1918 STATE.isAdmin = false;
1919 STATE.permissions = {};
1920 STATE.currentDir = null;
1921 STATE.currentRoot = null;
1922 STATE.items = [];
1923 STATE.restoreDir = null;
1924 STATE.restoreRootPath = null;
1925 STATE.lastOperationAt = null;
1926 _adminUpdateStatus = null;
1927 setAdminUpdateBadge(0);
1928 clearSessionState();
1929 closePreview({ force: true });
1930 closeSidebar();
1931 await initAuth();
1932}
1933
1934// ───────────────────────────────────────────────────────────────────────────
1935// NAVIGATION
1936// ───────────────────────────────────────────────────────────────────────────
1937
1938async function loadRoots (opts = {})
1939{
1940 const data = await api('GET', '/files/roots');
1941 if (!data) return;
1942 STATE.roots = data.roots;
1943
1944 const preferredDir = opts.preferredDir || null;
1945 const preferredRootPath = opts.preferredRootPath || null;
1946
1947 if (preferredDir && preferredRootPath)
1948 {
1949 const preferredRoot = STATE.roots.find(r => samePath(r.path, preferredRootPath));
1950 if (preferredRoot && pathInside(preferredDir, preferredRoot.path))
1951 {
1952 try
1953 {
1954 await navigateTo(preferredDir, preferredRoot, { keepSidebar: true });
1955 return;
1956 } catch
1957 {
1958 // Fall back to default root behavior.
1959 }
1960 }
1961 }
1962
1963 if (STATE.roots.length === 1)
1964 {
1965 // Single root → open it directly
1966 await navigateTo(STATE.roots[0].path, STATE.roots[0]);
1967 } else
1968 {
1969 renderRootsView();
1970 }
1971}
1972
1973function renderRootsView ()
1974{
1975 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1976 disconnectThumbnailObserver();
1977 disconnectFolderIconObserver();
1978 revokeThumbnails();
1979
1980 STATE.currentDir = null;
1981 STATE.currentRoot = null;
1982 STATE.searchQuery = null;
1983 saveSessionState();
1984 renderBreadcrumb();
1985 const grid = document.getElementById('file-grid');
1986 grid.innerHTML = '';
1987 document.getElementById('empty-notice').classList.add('hidden');
1988 document.getElementById('folder-stats').classList.add('hidden');
1989 closeSidebar();
1990
1991 for (const root of STATE.roots)
1992 {
1993 const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
1994 grid.appendChild(el);
1995 }
1996
1997 loadThumbnails();
1998}
1999
2000async function navigateTo (absPath, root, opts = {})
2001{
2002 STATE.searchQuery = null;
2003 if (root) STATE.currentRoot = root;
2004 STATE.currentDir = absPath;
2005
2006 const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
2007 if (!data) return;
2008
2009 STATE.items = data.items;
2010 saveSessionState();
2011 renderBreadcrumb();
2012 renderFileGrid();
2013 await refreshFolderStats();
2014 closeSidebar();
2015}
2016
2017async function runGlobalFileSearch ()
2018{
2019 const input = document.getElementById('top-search-input');
2020 if (!input) return;
2021
2022 const query = String(input.value || '').trim();
2023 if (!query)
2024 {
2025 toast('Enter a search term first.', 'err');
2026 return;
2027 }
2028
2029 let data;
2030 try
2031 {
2032 data = await api('GET', `/files/search?query=${encodeURIComponent(query)}&limit=250`);
2033 }
2034 catch (err)
2035 {
2036 toast('Search failed: ' + err.message, 'err');
2037 return;
2038 }
2039
2040 STATE.searchQuery = query;
2041 STATE.currentDir = null;
2042 STATE.currentRoot = null;
2043 STATE.items = Array.isArray(data && data.results)
2044 ? data.results.map((it) => ({
2045 name: it.name,
2046 path: it.path,
2047 dir: it.dir,
2048 isDir: false,
2049 size: it.size,
2050 mtime: it.mtime,
2051 }))
2052 : [];
2053
2054 renderBreadcrumb();
2055 renderFileGrid();
2056 closeSidebar();
2057
2058 const stats = document.getElementById('folder-stats');
2059 if (stats)
2060 {
2061 const n = STATE.items.length;
2062 stats.textContent = n === 1
2063 ? `1 file found for "${query}".`
2064 : `${n} files found for "${query}".`;
2065 stats.classList.remove('hidden');
2066 }
2067}
2068
2069function renderBreadcrumb ()
2070{
2071 if (typeof document === 'undefined') return;
2072 const nav = document.getElementById('breadcrumb');
2073 if (!nav) return;
2074 nav.innerHTML = '';
2075
2076 // "Home" crumb
2077 const home = document.createElement('span');
2078 home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
2079 home.textContent = 'Home';
2080 home.addEventListener('click', () =>
2081 {
2082 if (STATE.roots.length === 1)
2083 {
2084 navigateTo(STATE.roots[0].path, STATE.roots[0]);
2085 } else
2086 {
2087 renderRootsView();
2088 }
2089 });
2090 nav.appendChild(home);
2091
2092 if (STATE.searchQuery)
2093 {
2094 const sep = document.createElement('span');
2095 sep.className = 'sep';
2096 sep.textContent = ' / ';
2097 nav.appendChild(sep);
2098
2099 const searchCrumb = document.createElement('span');
2100 searchCrumb.className = 'crumb active';
2101 searchCrumb.textContent = `Search: ${STATE.searchQuery}`;
2102 nav.appendChild(searchCrumb);
2103 return;
2104 }
2105
2106 if (!STATE.currentDir || !STATE.currentRoot) return;
2107
2108 // Build path segments relative to the root.
2109 const rootPath = STATE.currentRoot.path;
2110 const relative = relativePathFromRoot(STATE.currentDir, rootPath);
2111 const segments = relative === '.' ? [] : relative.split(/[\\/]/).filter(Boolean);
2112 const parts = [STATE.currentRoot.label, ...segments];
2113
2114 for (let i = 0; i < parts.length; i++)
2115 {
2116 const sep = document.createElement('span');
2117 sep.className = 'sep';
2118 sep.textContent = ' / ';
2119 nav.appendChild(sep);
2120
2121 const crumb = document.createElement('span');
2122 crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
2123 crumb.textContent = parts[i];
2124
2125 // Root crumb points to rootPath; segment crumbs point to their folder.
2126 const capturedPath = i === 0
2127 ? rootPath
2128 : joinServerPath(rootPath, segments.slice(0, i).join('/'));
2129 crumb.classList.add('crumb-drop-target');
2130 crumb.dataset.path = capturedPath;
2131 if (i < parts.length - 1)
2132 {
2133 crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
2134 }
2135
2136 nav.appendChild(crumb);
2137 }
2138}
2139
2140async function refreshFolderStats ()
2141{
2142 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
2143 const el = document.getElementById('folder-stats');
2144 if (!STATE.currentDir || STATE.searchQuery)
2145 {
2146 el.classList.add('hidden');
2147 return;
2148 }
2149
2150 const data = await api('GET', `/files/space?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
2151 if (!data)
2152 {
2153 el.classList.add('hidden');
2154 return;
2155 }
2156
2157 const used = formatBytes(data.usedBytes);
2158 if (data.userFreeBytes != null)
2159 {
2160 el.textContent = `Folder usage: ${used} | Free space remaining: ${formatBytes(data.userFreeBytes)}`;
2161 } else
2162 {
2163 const free = data.freeBytes == null ? 'unknown' : formatBytes(data.freeBytes);
2164 el.textContent = `Folder usage: ${used} | Free on disk: ${free}`;
2165 }
2166 el.classList.remove('hidden');
2167}
2168
2169function itemsSignature (items)
2170{
2171 return JSON.stringify(
2172 (items || []).map(it => [it.path, it.mtime, it.uploadedAt, it.size, it.isDir])
2173 .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
2174 );
2175}
2176
2177async function incrementalRefreshCurrentDir ()
2178{
2179 if (STATE.previewExpandState) return;
2180 if (STATE.searchQuery) return;
2181 if (!STATE.currentDir || STATE.uploadInProgress) return;
2182
2183 const data = await api('GET', `/files/list?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
2184 if (!data) return;
2185
2186 const oldSig = itemsSignature(STATE.items);
2187 const newSig = itemsSignature(data.items);
2188 if (oldSig !== newSig)
2189 {
2190 const selectedPath = STATE.selectedItem ? STATE.selectedItem.path : null;
2191 STATE.items = data.items;
2192 renderFileGrid();
2193
2194 if (selectedPath)
2195 {
2196 const match = STATE.items.find(i => i.path === selectedPath);
2197 if (match)
2198 {
2199 const selectedEl = Array.from(document.querySelectorAll('.file-item'))
2200 .find(el => el.dataset.path === selectedPath);
2201 if (selectedEl) selectItem(selectedEl, match);
2202 } else
2203 {
2204 closeSidebar();
2205 }
2206 }
2207 }
2208 else
2209 {
2210 loadThumbnails();
2211 void loadWatchedStatusesForCurrentDir();
2212 }
2213
2214 await refreshFolderStats();
2215}
2216
2217function startAutoRefresh ()
2218{
2219 stopAutoRefresh();
2220 STATE.autoRefreshTimer = setInterval(() =>
2221 {
2222 if (document.hidden) return;
2223 incrementalRefreshCurrentDir();
2224 }, 5000);
2225}
2226
2227function stopAutoRefresh ()
2228{
2229 if (STATE.autoRefreshTimer)
2230 {
2231 clearInterval(STATE.autoRefreshTimer);
2232 STATE.autoRefreshTimer = null;
2233 }
2234}
2235
2236// ───────────────────────────────────────────────────────────────────────────
2237// FILE GRID RENDERING
2238// ───────────────────────────────────────────────────────────────────────────
2239
2240function parseItemTimestampMs (value)
2241{
2242 if (value == null || value === '') return null;
2243 const asNumber = Number(value);
2244 if (Number.isFinite(asNumber) && asNumber > 0) return asNumber;
2245 const asDate = Date.parse(String(value));
2246 return Number.isFinite(asDate) ? asDate : null;
2247}
2248
2249function dayStartMsFromTimestamp (value)
2250{
2251 const ts = parseItemTimestampMs(value);
2252 if (!Number.isFinite(ts)) return null;
2253 const d = new Date(ts);
2254 return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
2255}
2256
2257function dayCountWord (count)
2258{
2259 const words = {
2260 2: 'two',
2261 3: 'three',
2262 4: 'four',
2263 5: 'five',
2264 6: 'six',
2265 };
2266 return words[count] || String(count);
2267}
2268
2269function groupDateLabel (dayStartMs)
2270{
2271 if (!Number.isFinite(dayStartMs)) return 'Unknown date';
2272
2273 const now = new Date();
2274 const todayStartMs = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
2275 const diffDays = Math.floor((todayStartMs - dayStartMs) / (24 * 60 * 60 * 1000));
2276
2277 if (diffDays === 0) return 'today';
2278 if (diffDays === 1) return 'yesterday';
2279 if (diffDays >= 2 && diffDays <= 6) return `${dayCountWord(diffDays)} days ago`;
2280 if (diffDays === 7) return 'one week ago';
2281
2282 return new Date(dayStartMs).toLocaleDateString('en-GB', {
2283 day: '2-digit',
2284 month: 'short',
2285 year: 'numeric',
2286 });
2287}
2288
2289function itemFileTypeLabel (item)
2290{
2291 if (item.isDir) return 'Folder';
2292 const ext = extOf(item.name);
2293 return ext ? `.${ext}` : 'No extension';
2294}
2295
2296function itemAlphabeticalGroupLabel (item)
2297{
2298 const first = String(item.name || '').trim().charAt(0).toUpperCase();
2299 if (!first) return '#';
2300 return /[A-Z0-9]/.test(first) ? first : '#';
2301}
2302
2303function itemSizeGroupInfo (item)
2304{
2305 if (item.isDir) return { id: 'folder', label: 'Folder', rank: -1 };
2306 const size = Number(item.size);
2307 if (!Number.isFinite(size) || size < 0) return { id: 'unknown', label: 'Unknown size', rank: 999 };
2308 if (size === 0) return { id: 'empty', label: 'Empty', rank: 0 };
2309 if (size < (1024 * 1024)) return { id: 'small', label: 'Smaller than 1 MB', rank: 1 };
2310 if (size < (100 * 1024 * 1024)) return { id: 'medium', label: '1 MB to 100 MB', rank: 2 };
2311 if (size < (1024 * 1024 * 1024)) return { id: 'large', label: '100 MB to 1 GB', rank: 3 };
2312 return { id: 'huge', label: 'Larger than 1 GB', rank: 4 };
2313}
2314
2315function itemGroupInfo (item, groupBy)
2316{
2317 if (groupBy === 'alphabetical')
2318 {
2319 const label = itemAlphabeticalGroupLabel(item);
2320 return { id: `alpha:${label}`, label, rank: label.charCodeAt(0) || 999 };
2321 }
2322
2323 if (groupBy === 'fileType')
2324 {
2325 const label = itemFileTypeLabel(item);
2326 return { id: `type:${label.toLowerCase()}`, label, rank: 0 };
2327 }
2328
2329 if (groupBy === 'lastChangedDate')
2330 {
2331 const dayStart = dayStartMsFromTimestamp(item.mtime);
2332 return {
2333 id: `mtime:${dayStart == null ? 'unknown' : dayStart}`,
2334 label: groupDateLabel(dayStart),
2335 rank: dayStart == null ? Number.NEGATIVE_INFINITY : dayStart,
2336 };
2337 }
2338
2339 if (groupBy === 'timeUploadedDate')
2340 {
2341 const dayStart = dayStartMsFromTimestamp(item.uploadedAt != null ? item.uploadedAt : item.mtime);
2342 return {
2343 id: `uploaded:${dayStart == null ? 'unknown' : dayStart}`,
2344 label: groupDateLabel(dayStart),
2345 rank: dayStart == null ? Number.NEGATIVE_INFINITY : dayStart,
2346 };
2347 }
2348
2349 if (groupBy === 'size')
2350 {
2351 const sizeGroup = itemSizeGroupInfo(item);
2352 return {
2353 id: `size:${sizeGroup.id}`,
2354 label: sizeGroup.label,
2355 rank: sizeGroup.rank,
2356 };
2357 }
2358
2359 return { id: 'none', label: '', rank: 0 };
2360}
2361
2362function compareText (a, b)
2363{
2364 return String(a || '').localeCompare(String(b || ''), undefined, { numeric: true, sensitivity: 'base' });
2365}
2366
2367function compareNullableNumber (a, b, ascending)
2368{
2369 const hasA = Number.isFinite(a);
2370 const hasB = Number.isFinite(b);
2371 if (!hasA && !hasB) return 0;
2372 if (!hasA) return 1;
2373 if (!hasB) return -1;
2374 const diff = a - b;
2375 return ascending ? diff : -diff;
2376}
2377
2378function compareBySortMode (a, b, sortBy, ascending)
2379{
2380 if (sortBy === 'fileType')
2381 {
2382 const extA = itemFileTypeLabel(a.item).toLowerCase();
2383 const extB = itemFileTypeLabel(b.item).toLowerCase();
2384 const byType = compareText(extA, extB);
2385 if (byType !== 0) return ascending ? byType : -byType;
2386 const byName = compareText(a.item.name, b.item.name);
2387 return ascending ? byName : -byName;
2388 }
2389
2390 if (sortBy === 'lastChanged')
2391 {
2392 return compareNullableNumber(parseItemTimestampMs(a.item.mtime), parseItemTimestampMs(b.item.mtime), ascending);
2393 }
2394
2395 if (sortBy === 'timeUploaded')
2396 {
2397 const uploadedA = parseItemTimestampMs(a.item.uploadedAt != null ? a.item.uploadedAt : a.item.mtime);
2398 const uploadedB = parseItemTimestampMs(b.item.uploadedAt != null ? b.item.uploadedAt : b.item.mtime);
2399 return compareNullableNumber(uploadedA, uploadedB, ascending);
2400 }
2401
2402 if (sortBy === 'size')
2403 {
2404 const sizeA = Number.isFinite(Number(a.item.size)) ? Number(a.item.size) : null;
2405 const sizeB = Number.isFinite(Number(b.item.size)) ? Number(b.item.size) : null;
2406 return compareNullableNumber(sizeA, sizeB, ascending);
2407 }
2408
2409 const byName = compareText(a.item.name, b.item.name);
2410 return ascending ? byName : -byName;
2411}
2412
2413function buildFileGridRows (items, prefs)
2414{
2415 const list = Array.isArray(items) ? items : [];
2416 const groupBy = prefs.groupBy || 'none';
2417 const sortBy = prefs.sortBy || 'alphabetical';
2418 const descriptors = list.map((item) => ({
2419 item,
2420 group: itemGroupInfo(item, groupBy),
2421 }));
2422
2423 descriptors.sort((a, b) =>
2424 {
2425 if (groupBy !== 'none')
2426 {
2427 const dateGrouping = groupBy === 'lastChangedDate' || groupBy === 'timeUploadedDate';
2428 if (a.group.rank !== b.group.rank)
2429 {
2430 const byRank = dateGrouping ? (b.group.rank - a.group.rank) : (a.group.rank - b.group.rank);
2431 if (byRank !== 0) return byRank;
2432 }
2433 const byGroupLabel = compareText(a.group.label, b.group.label);
2434 if (byGroupLabel !== 0) return dateGrouping ? byGroupLabel : (prefs.ascending ? byGroupLabel : -byGroupLabel);
2435 }
2436
2437 if (prefs.foldersFirst && a.item.isDir !== b.item.isDir)
2438 {
2439 return a.item.isDir ? -1 : 1;
2440 }
2441
2442 const bySort = compareBySortMode(a, b, sortBy, !!prefs.ascending);
2443 if (bySort !== 0) return bySort;
2444
2445 return compareText(a.item.name, b.item.name);
2446 });
2447
2448 const rows = [];
2449 let previousGroupId = null;
2450 for (const descriptor of descriptors)
2451 {
2452 if (groupBy !== 'none' && descriptor.group.id !== previousGroupId)
2453 {
2454 rows.push({ type: 'group', label: descriptor.group.label });
2455 previousGroupId = descriptor.group.id;
2456 }
2457 rows.push({ type: 'item', item: descriptor.item });
2458 }
2459
2460 return rows;
2461}
2462
2463function makeGroupSeparator (label)
2464{
2465 const el = document.createElement('div');
2466 el.className = 'file-group-separator';
2467
2468 const text = document.createElement('span');
2469 text.textContent = String(label || 'Other');
2470 el.appendChild(text);
2471 return el;
2472}
2473
2474function renderFileItemName (targetEl, fileName)
2475{
2476 if (!targetEl) return;
2477
2478 const rawName = String(fileName || '');
2479 targetEl.textContent = '';
2480 if (!rawName) return;
2481
2482 const segments = rawName.split(/([\-.,])/);
2483 for (const segment of segments)
2484 {
2485 if (!segment) continue;
2486 targetEl.appendChild(document.createTextNode(segment));
2487
2488 if (segment === '-' || segment === ',' || segment === '.')
2489 {
2490 targetEl.appendChild(document.createElement('wbr'));
2491 }
2492 }
2493}
2494
2495function renderFileGrid ()
2496{
2497 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
2498 disconnectThumbnailObserver();
2499 disconnectFolderIconObserver();
2500 revokeThumbnails();
2501 const grid = document.getElementById('file-grid');
2502 grid.innerHTML = '';
2503 const empty = document.getElementById('empty-notice');
2504
2505 const prefs = (!STATE.searchQuery && STATE.currentDir)
2506 ? folderViewPrefsForDir(STATE.currentDir)
2507 : { ...DEFAULT_FOLDER_VIEW_PREFS };
2508 const rows = buildFileGridRows(STATE.items, prefs);
2509
2510 empty.classList.toggle('hidden', STATE.items.length > 0);
2511
2512 for (const row of rows)
2513 {
2514 if (row.type === 'group')
2515 {
2516 grid.appendChild(makeGroupSeparator(row.label));
2517 continue;
2518 }
2519 grid.appendChild(makeFileItem(row.item));
2520 }
2521
2522 loadThumbnails();
2523 void loadWatchedStatusesForCurrentDir();
2524}
2525
2526function makeFileItem (item)
2527{
2528 const el = document.createElement('div');
2529 el.className = 'file-item';
2530 el.dataset.path = item.path;
2531 if (item.isDir) el.dataset.isdir = '1';
2532
2533 const icon = document.createElement('div');
2534 icon.className = 'icon';
2535 icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
2536 if (!item.isDir)
2537 {
2538 icon.dataset.previewPath = item.path;
2539 renderWatchedOverlayOnIcon(icon, watchStatusForTile(item));
2540 } else
2541 {
2542 icon.dataset.folderPath = item.path;
2543 }
2544 el.appendChild(icon);
2545
2546 const name = document.createElement('div');
2547 name.className = 'name';
2548 renderFileItemName(name, item.name);
2549 el.appendChild(name);
2550
2551 if (!item._root) makeDraggable(el, item);
2552 attachMobileLongPress(el, item);
2553
2554 el.addEventListener('contextmenu', (e) =>
2555 {
2556 e.preventDefault();
2557 e.stopPropagation();
2558
2559 if (isMobileViewport()) return;
2560 if (el.classList.contains('file-item--preview')) return;
2561
2562 document.querySelectorAll('.file-item.selected').forEach(node => node.classList.remove('selected'));
2563 el.classList.add('selected');
2564 STATE.selectedItem = item;
2565 openItemContextMenu(item, e.clientX, e.clientY);
2566 });
2567
2568 // Single-click: open sidebar
2569 el.addEventListener('click', (e) =>
2570 {
2571 e.stopPropagation();
2572 closeCustomContextMenu();
2573 if (el.classList.contains('file-item--preview')) return;
2574 if (isMobileViewport())
2575 {
2576 if (el.dataset.longPressTriggered === '1')
2577 {
2578 el.dataset.longPressTriggered = '0';
2579 return;
2580 }
2581
2582 if (item.isDir)
2583 {
2584 navigateTo(item.path, item._root || STATE.currentRoot);
2585 } else
2586 {
2587 downloadOrView(item, icon.querySelector('svg'));
2588 }
2589 return;
2590 }
2591
2592 selectItem(el, item);
2593 });
2594
2595 // Double-click: enter folder or view/download file
2596 el.addEventListener('dblclick', (e) =>
2597 {
2598 e.stopPropagation();
2599 if (el.classList.contains('file-item--preview')) return;
2600 if (item.isDir)
2601 {
2602 navigateTo(item.path, item._root || STATE.currentRoot);
2603 } else
2604 {
2605 downloadOrView(item, icon.querySelector('svg'));
2606 }
2607 });
2608
2609 return el;
2610}
2611
2612function attachMobileLongPress (el, item)
2613{
2614 if (item._root) return;
2615
2616 let pressTimer = null;
2617 let startX = 0;
2618 let startY = 0;
2619
2620 function clearPress ()
2621 {
2622 if (!pressTimer) return;
2623 clearTimeout(pressTimer);
2624 pressTimer = null;
2625 }
2626
2627 function cancelPress ()
2628 {
2629 clearPress();
2630 }
2631
2632 el.addEventListener('pointerdown', (e) =>
2633 {
2634 if (!isMobileViewport()) return;
2635 if (e.button !== undefined && e.button !== 0) return;
2636 if (e.pointerType && e.pointerType === 'mouse') return;
2637
2638 startX = e.clientX;
2639 startY = e.clientY;
2640 clearPress();
2641
2642 pressTimer = setTimeout(() =>
2643 {
2644 pressTimer = null;
2645 el.dataset.longPressTriggered = '1';
2646 selectItem(el, item);
2647 }, MOBILE_LONG_PRESS_MS);
2648 });
2649
2650 el.addEventListener('pointermove', (e) =>
2651 {
2652 if (!pressTimer) return;
2653 if (Math.hypot(e.clientX - startX, e.clientY - startY) > MOBILE_LONG_PRESS_MOVE_THRESHOLD)
2654 {
2655 clearPress();
2656 }
2657 });
2658
2659 el.addEventListener('pointerup', cancelPress);
2660 el.addEventListener('pointercancel', cancelPress);
2661 el.addEventListener('pointerleave', cancelPress);
2662}
2663
2664function selectItem (el, item)
2665{
2666 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
2667 el.classList.add('selected');
2668 STATE.selectedItem = item;
2669 openSidebar(item);
2670}
2671
2672function isAbortError (err)
2673{
2674 if (!err) return false;
2675 return err.name === 'AbortError' || /abort/i.test(String(err.message || ''));
2676}
2677
2678function beginSidebarLoad ()
2679{
2680 if (STATE.sidebarAbortController && typeof STATE.sidebarAbortController.abort === 'function')
2681 {
2682 try { STATE.sidebarAbortController.abort(); } catch { /* ignore */ }
2683 }
2684
2685 STATE.sidebarLoadId += 1;
2686 STATE.sidebarAbortController = null;
2687
2688 return {
2689 id: STATE.sidebarLoadId,
2690 };
2691}
2692
2693function isSidebarLoadStale (item, sidebarLoadId)
2694{
2695 if (sidebarLoadId !== STATE.sidebarLoadId) return true;
2696 if (!STATE.selectedItem) return true;
2697 return STATE.selectedItem !== item && STATE.selectedItem.path !== item.path;
2698}
2699
2700// ───────────────────────────────────────────────────────────────────────────
2701// SIDEBAR
2702// ───────────────────────────────────────────────────────────────────────────
2703
2704/**
2705 * Renders (or clears) the duplicates panel at the bottom of the sidebar.
2706 * @param {object|null} item — the item whose duplicates are shown; null = clear
2707 * @param {Array|null} duplicates — array of {path, name, dir, relativePath}; null = loading state
2708 */
2709function renderSidebarDuplicates (item, duplicates)
2710{
2711 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
2712 const panel = document.getElementById('sidebar-duplicates');
2713 if (!panel) return;
2714
2715 // Clear / hide when no item or no duplicates.
2716 if (!item || (Array.isArray(duplicates) && duplicates.length === 0))
2717 {
2718 panel.classList.add('hidden');
2719 panel.innerHTML = '';
2720 return;
2721 }
2722
2723 // Loading state.
2724 if (duplicates === null)
2725 {
2726 panel.classList.add('hidden');
2727 panel.innerHTML = '';
2728 return;
2729 }
2730
2731 panel.innerHTML = '';
2732 const heading = document.createElement('p');
2733 heading.className = 'sidebar-duplicates-heading';
2734 heading.textContent = `Duplicates (${duplicates.length})`;
2735 panel.appendChild(heading);
2736
2737 const list = document.createElement('ul');
2738 list.className = 'sidebar-duplicates-list';
2739
2740 for (const dup of duplicates)
2741 {
2742 const li = document.createElement('li');
2743 const btn = document.createElement('button');
2744 btn.className = 'sidebar-duplicate-entry';
2745 btn.title = dup.path;
2746 // Show path relative to its root; keep absolute path in the tooltip.
2747 btn.textContent = dup.relativePath || dup.path;
2748 btn.addEventListener('click', () => navigateToDuplicate(dup));
2749 li.appendChild(btn);
2750 list.appendChild(li);
2751 }
2752
2753 panel.appendChild(list);
2754 panel.classList.remove('hidden');
2755}
2756
2757/**
2758 * Navigates to the folder containing a duplicate file and then auto-opens it.
2759 * @param {{ path: string, name: string, dir: string }} dup
2760 */
2761async function navigateToDuplicate (dup)
2762{
2763 // If the duplicate lives in the folder already shown, just select it.
2764 if (STATE.currentDir && samePath(dup.dir, STATE.currentDir))
2765 {
2766 const tile = Array.from(document.querySelectorAll('.file-item'))
2767 .find((el) => el.dataset.path === dup.path);
2768 const dupItem = STATE.items.find((i) => i.path === dup.path);
2769 if (tile && dupItem)
2770 {
2771 selectItem(tile, dupItem);
2772 }
2773 return;
2774 }
2775
2776 // Find the root that contains the duplicate.
2777 const root = STATE.roots.find(
2778 (r) => dup.dir === r.path || dup.dir.startsWith(r.path + '/') || dup.dir.startsWith(r.path + '\\'),
2779 );
2780 if (!root)
2781 {
2782 toast('Cannot navigate to duplicate: root not accessible.', 'err');
2783 return;
2784 }
2785
2786 await navigateTo(dup.dir, root);
2787
2788 // After navigation, find and select the file tile to open it.
2789 const tile = Array.from(document.querySelectorAll('.file-item'))
2790 .find((el) => el.dataset.path === dup.path);
2791 const dupItem = STATE.items.find((i) => i.path === dup.path);
2792
2793 if (tile && dupItem)
2794 {
2795 selectItem(tile, dupItem);
2796 }
2797}
2798
2799function renderItemActionButtons (actions, item)
2800{
2801 if (!actions || !item) return;
2802 actions.innerHTML = '';
2803
2804 if (!item.isDir)
2805 {
2806 const btnDl = document.createElement('button');
2807 btnDl.textContent = 'View / Download';
2808 btnDl.addEventListener('click', () =>
2809 {
2810 const tile = Array.from(document.querySelectorAll('.file-item')).find(node => node.dataset.path === item.path);
2811 const source = (tile ? tile.querySelector('.icon svg') : null) || document.querySelector('#sidebar-icon svg');
2812 downloadOrView(item, source);
2813 });
2814 actions.appendChild(btnDl);
2815
2816 const btnShareFile = document.createElement('button');
2817 btnShareFile.textContent = 'Share';
2818 btnShareFile.addEventListener('click', () => openShareModal(item));
2819 actions.appendChild(btnShareFile);
2820 }
2821 else
2822 {
2823 const btnOpen = document.createElement('button');
2824 btnOpen.textContent = 'Open folder';
2825 btnOpen.addEventListener('click', () => navigateTo(item.path, item._root || STATE.currentRoot));
2826 actions.appendChild(btnOpen);
2827
2828 const btnZip = document.createElement('button');
2829 btnZip.textContent = 'Download as zip';
2830 btnZip.addEventListener('click', () =>
2831 {
2832 btnZip.disabled = true;
2833 btnZip.textContent = 'Working...';
2834 const url = `/api/files/download-zip?dir=${encodeURIComponent(item.path)}`;
2835 const headers = {
2836 Authorization: 'Bearer ' + STATE.token,
2837 'X-Fp': getFingerprint(),
2838 };
2839 fetch(url, { headers })
2840 .then(res =>
2841 {
2842 if (!res.ok) throw new Error('Download mislukt');
2843 return res.blob();
2844 })
2845 .then(blob =>
2846 {
2847 const blobUrl = URL.createObjectURL(blob);
2848 const a = document.createElement('a');
2849 a.href = blobUrl;
2850 a.download = item.name + '.zip';
2851 a.click();
2852 setTimeout(() => URL.revokeObjectURL(blobUrl), 10000);
2853 })
2854 .catch((err) => toast(err.message || 'Download mislukt', 'err'))
2855 .finally(() =>
2856 {
2857 btnZip.disabled = false;
2858 btnZip.textContent = 'Download as zip';
2859 });
2860 });
2861 actions.appendChild(btnZip);
2862
2863 const btnShareFolder = document.createElement('button');
2864 btnShareFolder.textContent = 'Share';
2865 btnShareFolder.addEventListener('click', () => openShareModal(item));
2866 actions.appendChild(btnShareFolder);
2867 }
2868
2869 if (!canWrite(item)) return;
2870
2871 if (item.isDir)
2872 {
2873 const btnSetIcon = document.createElement('button');
2874 btnSetIcon.textContent = 'Set icon';
2875 btnSetIcon.addEventListener('click', () => openFolderIconPicker(item));
2876 actions.appendChild(btnSetIcon);
2877 }
2878
2879 if (!item._root)
2880 {
2881 const btnMove = document.createElement('button');
2882 btnMove.textContent = 'Move to';
2883 btnMove.addEventListener('click', () => openMovePicker(item));
2884 actions.appendChild(btnMove);
2885
2886 if (!item.isDir)
2887 {
2888 const btnCopy = document.createElement('button');
2889 btnCopy.textContent = 'Copy to';
2890 btnCopy.addEventListener('click', () => openCopyPicker(item));
2891 actions.appendChild(btnCopy);
2892 }
2893 }
2894
2895 const btnRen = document.createElement('button');
2896 btnRen.textContent = 'Rename';
2897 btnRen.addEventListener('click', () => openRenameModal(item));
2898 actions.appendChild(btnRen);
2899
2900 if (!item._root)
2901 {
2902 const btnDel = document.createElement('button');
2903 btnDel.textContent = 'Delete';
2904 btnDel.className = 'danger';
2905 btnDel.addEventListener('click', () => deleteItem(item));
2906 actions.appendChild(btnDel);
2907 }
2908}
2909
2910function closeCustomContextMenu ()
2911{
2912 const menu = document.getElementById('custom-context-menu');
2913 if (!menu) return;
2914 menu.classList.add('hidden');
2915 menu.innerHTML = '';
2916}
2917
2918function ensureCustomContextMenu ()
2919{
2920 let menu = document.getElementById('custom-context-menu');
2921 if (menu) return menu;
2922
2923 menu = document.createElement('div');
2924 menu.id = 'custom-context-menu';
2925 menu.className = 'custom-context-menu hidden';
2926 menu.setAttribute('role', 'menu');
2927 menu.setAttribute('aria-label', 'Context menu');
2928 menu.addEventListener('click', (e) => e.stopPropagation());
2929 document.body.appendChild(menu);
2930 return menu;
2931}
2932
2933function openCustomContextMenuAt (x, y, build)
2934{
2935 const menu = ensureCustomContextMenu();
2936 menu.innerHTML = '';
2937 build(menu);
2938 if (!menu.childElementCount)
2939 {
2940 closeCustomContextMenu();
2941 return;
2942 }
2943
2944 menu.classList.remove('hidden');
2945 menu.style.left = '0px';
2946 menu.style.top = '0px';
2947
2948 const maxLeft = Math.max(6, window.innerWidth - menu.offsetWidth - 6);
2949 const maxTop = Math.max(6, window.innerHeight - menu.offsetHeight - 6);
2950 menu.style.left = `${Math.min(Math.max(6, x), maxLeft)}px`;
2951 menu.style.top = `${Math.min(Math.max(6, y), maxTop)}px`;
2952}
2953
2954function addContextMenuButton (menu, label, onClick, { danger = false, checked = null, hasSubmenu = false } = {})
2955{
2956 const btn = document.createElement('button');
2957 btn.type = 'button';
2958 btn.className = 'custom-context-menu-item';
2959 if (danger) btn.classList.add('danger');
2960 if (checked !== null) btn.classList.add('custom-context-menu-item--check');
2961 if (hasSubmenu) btn.classList.add('custom-context-menu-item--submenu');
2962
2963 const labelEl = document.createElement('span');
2964 if (checked === true) labelEl.textContent = '✓ ' + label;
2965 else if (checked === false) labelEl.textContent = '□ ' + label;
2966 else labelEl.textContent = label;
2967 btn.appendChild(labelEl);
2968
2969 if (hasSubmenu)
2970 {
2971 const arrow = document.createElement('span');
2972 arrow.textContent = '›';
2973 btn.appendChild(arrow);
2974 }
2975
2976 btn.addEventListener('click', async (e) =>
2977 {
2978 e.stopPropagation();
2979 await onClick();
2980 closeCustomContextMenu();
2981 });
2982 menu.appendChild(btn);
2983 return btn;
2984}
2985
2986function addContextMenuSeparator (menu)
2987{
2988 const sep = document.createElement('div');
2989 sep.className = 'custom-context-menu-separator';
2990 menu.appendChild(sep);
2991}
2992
2993function addContextMenuSubmenu (menu, label, options)
2994{
2995 const row = document.createElement('div');
2996 row.className = 'custom-context-menu-row';
2997 const trigger = addContextMenuButton(row, label, () => { }, { hasSubmenu: true });
2998 trigger.addEventListener('click', (e) => e.preventDefault());
2999
3000 const panel = document.createElement('div');
3001 panel.className = 'custom-context-submenu';
3002 for (const option of options)
3003 {
3004 addContextMenuButton(panel, option.label, option.onClick, {
3005 checked: option.checked,
3006 });
3007 }
3008 row.appendChild(panel);
3009 menu.appendChild(row);
3010}
3011
3012function openItemContextMenu (item, x, y)
3013{
3014 openCustomContextMenuAt(x, y, (menu) =>
3015 {
3016 renderItemActionButtons(menu, item);
3017 menu.querySelectorAll('button').forEach((btn) =>
3018 {
3019 if (btn.classList.contains('danger')) btn.classList.add('danger');
3020 btn.addEventListener('click', () => closeCustomContextMenu(), { once: true });
3021 });
3022 });
3023}
3024
3025function openFolderContextMenu (x, y)
3026{
3027 if (!STATE.currentDir)
3028 {
3029 closeCustomContextMenu();
3030 return;
3031 }
3032
3033 const prefs = folderViewPrefsForDir(STATE.currentDir);
3034 const makeOptionHandler = (patch) => async () =>
3035 {
3036 saveFolderViewPrefsForDir(STATE.currentDir, patch);
3037 renderFileGrid();
3038 };
3039
3040 openCustomContextMenuAt(x, y, (menu) =>
3041 {
3042 if (canWrite())
3043 {
3044 addContextMenuButton(menu, 'Create Folder', createFolderInCurrentDir);
3045 addContextMenuSeparator(menu);
3046 }
3047
3048 addContextMenuSubmenu(menu, 'Sort by', FOLDER_SORT_OPTIONS.map((option) => ({
3049 label: option.label,
3050 checked: prefs.sortBy === option.value,
3051 onClick: makeOptionHandler({ sortBy: option.value }),
3052 })));
3053
3054 addContextMenuSubmenu(menu, 'Group by', FOLDER_GROUP_OPTIONS.map((option) => ({
3055 label: option.label,
3056 checked: prefs.groupBy === option.value,
3057 onClick: makeOptionHandler({ groupBy: option.value }),
3058 })));
3059
3060 addContextMenuSeparator(menu);
3061 addContextMenuButton(menu, 'Always keep folders at the top', makeOptionHandler({ foldersFirst: !prefs.foldersFirst }), {
3062 checked: !!prefs.foldersFirst,
3063 });
3064 addContextMenuButton(menu, prefs.ascending ? 'Ascending' : 'Descending', makeOptionHandler({ ascending: !prefs.ascending }), {
3065 checked: !!prefs.ascending,
3066 });
3067 });
3068}
3069// ───────────────────────────────────────────────────────────────────────────
3070
3071async function openSidebar (item)
3072{
3073 const sidebarLoad = beginSidebarLoad();
3074
3075 const sidebar = document.getElementById('sidebar');
3076 sidebar.classList.remove('hidden');
3077 document.getElementById('app').classList.add('sidebar-open');
3078
3079 document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
3080 if (item.isDir)
3081 {
3082 document.getElementById('sidebar-icon').dataset.folderPath = item.path;
3083 } else
3084 {
3085 delete document.getElementById('sidebar-icon').dataset.folderPath;
3086 }
3087 document.getElementById('sidebar-name').textContent = item.name;
3088
3089 // Load metadata
3090 const dl = document.getElementById('sidebar-meta');
3091 dl.innerHTML = '<dt>Loading…</dt><dd></dd>';
3092
3093 const actions = document.getElementById('sidebar-actions');
3094 actions.innerHTML = '';
3095
3096 // Reset duplicates panel whenever a new item is opened.
3097 renderSidebarDuplicates(null, null);
3098
3099 if (!item.isDir)
3100 {
3101 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`).catch((err) =>
3102 {
3103 if (isAbortError(err)) return null;
3104 throw err;
3105 });
3106 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3107
3108 if (meta)
3109 {
3110 const watchedBy = VIDEO_EXTS.has(extOf(item.name))
3111 ? Object.entries(meta.watchedBy || {})
3112 .map(([user, status]) => `${String(user)}: ${String(status)}`)
3113 .sort((a, b) => a.localeCompare(b))
3114 : [];
3115
3116 dl.innerHTML = `
3117 <dt>Size</dt> <dd>${formatBytes(meta.size)}</dd>
3118 <dt>Modified</dt> <dd>${new Date(meta.mtime).toLocaleString()}</dd>
3119 <dt>Uploaded by</dt><dd>${meta.uploader || '—'}</dd>
3120 <dt>Downloaded by</dt><dd>${meta.downloaders.join(', ') || '—'}</dd>
3121 ${VIDEO_EXTS.has(extOf(item.name)) ? `<dt>Watched by</dt><dd>${watchedBy.join(', ') || '—'}</dd>` : ''}
3122 `;
3123 }
3124
3125 // Fetch and render duplicate files.
3126 renderSidebarDuplicates(item, null); // show loading state
3127 const selectedPathAtRequest = item.path;
3128 api('GET', `/files/duplicates?file=${encodeURIComponent(item.path)}`)
3129 .then((data) =>
3130 {
3131 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3132 if (!STATE.selectedItem || STATE.selectedItem.path !== selectedPathAtRequest) return;
3133 renderSidebarDuplicates(item, data ? data.duplicates : []);
3134 })
3135 .catch((err) =>
3136 {
3137 if (isAbortError(err)) return;
3138 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3139 if (!STATE.selectedItem || STATE.selectedItem.path !== selectedPathAtRequest) return;
3140 renderSidebarDuplicates(item, []);
3141 });
3142
3143 } else
3144 {
3145 dl.innerHTML = `<dt>Type</dt><dd>${item._root ? 'Root folder' : 'Folder'}</dd>`;
3146
3147 if (item._root)
3148 {
3149 dl.innerHTML += `
3150 <dt>Alias</dt><dd>${item.name}</dd>
3151 <dt>Original name</dt><dd>${item._root.originalName || basenameOfPath(item.path)}</dd>
3152 `;
3153
3154 const space = await api('GET', `/files/space?dir=${encodeURIComponent(item.path)}`).catch((err) =>
3155 {
3156 if (isAbortError(err)) return null;
3157 return null;
3158 });
3159 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3160
3161 if (space)
3162 {
3163 const used = formatBytes(space.usedBytes);
3164 const free = space.userFreeBytes != null
3165 ? formatBytes(space.userFreeBytes)
3166 : (space.freeBytes == null ? 'unknown' : formatBytes(space.freeBytes));
3167 const freeLabel = space.userFreeBytes != null ? 'Free space remaining' : 'Remaining';
3168 dl.innerHTML += `
3169 <dt>Used</dt><dd>${used}</dd>
3170 <dt>${freeLabel}</dt><dd>${free}</dd>
3171 `;
3172 }
3173
3174 if (item._root.isUserFolder)
3175 {
3176 dl.innerHTML += `
3177 <dt>Access</dt><dd>Private (your folder)</dd>
3178 `;
3179 } else
3180 {
3181 const accessUsers = await fetchRootAccessList(item.path);
3182 if (isSidebarLoadStale(item, sidebarLoad.id)) return;
3183 if (accessUsers)
3184 {
3185 dl.innerHTML += `
3186 <dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>
3187 `;
3188 }
3189 }
3190 }
3191 }
3192
3193 renderItemActionButtons(actions, item);
3194
3195 if (item.isDir)
3196 {
3197 // Load folder icon thumbnail into the sidebar icon element.
3198 void loadOneFolderIcon(document.getElementById('sidebar-icon'));
3199 }
3200}
3201
3202function openFolderSidebar ()
3203{
3204 beginSidebarLoad();
3205
3206 const sidebar = document.getElementById('sidebar');
3207 sidebar.classList.remove('hidden');
3208 document.getElementById('app').classList.add('sidebar-open');
3209
3210 document.getElementById('sidebar-icon').innerHTML = iconFolder(64);
3211
3212 const nameEl = document.getElementById('sidebar-name');
3213 const dl = document.getElementById('sidebar-meta');
3214 const actions = document.getElementById('sidebar-actions');
3215 actions.innerHTML = '';
3216 renderSidebarDuplicates(null, null);
3217
3218 if (!STATE.currentDir || !STATE.currentRoot)
3219 {
3220 nameEl.textContent = 'Storage Roots';
3221 dl.innerHTML = `
3222 <dt>Type</dt><dd>Root overview</dd>
3223 <dt>Roots</dt><dd>${STATE.roots.length}</dd>
3224 `;
3225 return;
3226 }
3227
3228 const parts = String(STATE.currentDir).split(/[\\/]/).filter(Boolean);
3229 const fallback = STATE.currentRoot.label || 'Folder';
3230 nameEl.textContent = parts.length ? parts[parts.length - 1] : fallback;
3231
3232 const dirs = STATE.items.filter(i => i.isDir).length;
3233 const files = STATE.items.length - dirs;
3234 const displayPath = displayPathWithRootLabel(STATE.currentDir, STATE.currentRoot.path, STATE.currentRoot.label);
3235 const baseDetails = `
3236 <dt>Path</dt><dd>${displayPath}</dd>
3237 <dt>Folders</dt><dd>${dirs}</dd>
3238 <dt>Files</dt><dd>${files}</dd>
3239 `;
3240 dl.innerHTML = baseDetails;
3241 renderFolderViewControls(actions, STATE.currentDir);
3242
3243 if (samePath(STATE.currentDir, STATE.currentRoot.path))
3244 {
3245 if (STATE.currentRoot.isUserFolder)
3246 {
3247 dl.innerHTML += '<dt>Access</dt><dd>Private (your folder)</dd>';
3248 return;
3249 }
3250
3251 dl.innerHTML += '<dt>Access</dt><dd>Loading…</dd>';
3252 const currentDirAtStart = STATE.currentDir;
3253 const currentRootPathAtStart = STATE.currentRoot.path;
3254 void fetchRootAccessList(currentRootPathAtStart).then((accessUsers) =>
3255 {
3256 if (!accessUsers) return;
3257 if (!STATE.currentRoot) return;
3258 if (!samePath(STATE.currentDir, currentDirAtStart)) return;
3259 if (!samePath(STATE.currentRoot.path, currentRootPathAtStart)) return;
3260 dl.innerHTML = `${baseDetails}<dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>`;
3261 });
3262 }
3263}
3264
3265function renderFolderViewControls (actions, dirPath)
3266{
3267 if (!actions || !dirPath) return;
3268
3269 const prefs = folderViewPrefsForDir(dirPath);
3270
3271 const section = document.createElement('section');
3272 section.className = 'sidebar-view-options';
3273
3274 const heading = document.createElement('h3');
3275 heading.textContent = 'View options';
3276 section.appendChild(heading);
3277
3278 const sortLabel = document.createElement('label');
3279 sortLabel.className = 'sidebar-view-option-label';
3280 sortLabel.textContent = 'Sort by';
3281 const sortSelect = document.createElement('select');
3282 sortSelect.className = 'sidebar-view-option-control';
3283 sortSelect.dataset.viewOption = 'sort';
3284 for (const option of FOLDER_SORT_OPTIONS)
3285 {
3286 const optEl = document.createElement('option');
3287 optEl.value = option.value;
3288 optEl.textContent = option.label;
3289 sortSelect.appendChild(optEl);
3290 }
3291 sortSelect.value = prefs.sortBy;
3292 sortSelect.addEventListener('change', () =>
3293 {
3294 saveFolderViewPrefsForDir(dirPath, { sortBy: sortSelect.value });
3295 renderFileGrid();
3296 });
3297 sortLabel.appendChild(sortSelect);
3298 section.appendChild(sortLabel);
3299
3300 const groupLabel = document.createElement('label');
3301 groupLabel.className = 'sidebar-view-option-label';
3302 groupLabel.textContent = 'Group by';
3303 const groupSelect = document.createElement('select');
3304 groupSelect.className = 'sidebar-view-option-control';
3305 groupSelect.dataset.viewOption = 'group';
3306 for (const option of FOLDER_GROUP_OPTIONS)
3307 {
3308 const optEl = document.createElement('option');
3309 optEl.value = option.value;
3310 optEl.textContent = option.label;
3311 groupSelect.appendChild(optEl);
3312 }
3313 groupSelect.value = prefs.groupBy;
3314 groupSelect.addEventListener('change', () =>
3315 {
3316 saveFolderViewPrefsForDir(dirPath, { groupBy: groupSelect.value });
3317 renderFileGrid();
3318 });
3319 groupLabel.appendChild(groupSelect);
3320 section.appendChild(groupLabel);
3321
3322 const foldersTopLabel = document.createElement('label');
3323 foldersTopLabel.className = 'sidebar-view-toggle';
3324 const foldersTopInput = document.createElement('input');
3325 foldersTopInput.type = 'checkbox';
3326 foldersTopInput.dataset.viewOption = 'folders-first';
3327 foldersTopInput.checked = !!prefs.foldersFirst;
3328 foldersTopInput.addEventListener('change', () =>
3329 {
3330 saveFolderViewPrefsForDir(dirPath, { foldersFirst: foldersTopInput.checked });
3331 renderFileGrid();
3332 });
3333 const foldersTopText = document.createElement('span');
3334 foldersTopText.textContent = 'Always keep folders at the top';
3335 foldersTopLabel.appendChild(foldersTopInput);
3336 foldersTopLabel.appendChild(foldersTopText);
3337 section.appendChild(foldersTopLabel);
3338
3339 const ascLabel = document.createElement('label');
3340 ascLabel.className = 'sidebar-view-toggle';
3341 const ascInput = document.createElement('input');
3342 ascInput.type = 'checkbox';
3343 ascInput.dataset.viewOption = 'ascending';
3344 ascInput.checked = !!prefs.ascending;
3345 ascInput.addEventListener('change', () =>
3346 {
3347 saveFolderViewPrefsForDir(dirPath, { ascending: ascInput.checked });
3348 renderFileGrid();
3349 });
3350 const ascText = document.createElement('span');
3351 ascText.textContent = ascInput.checked ? 'Ascending' : 'Descending';
3352 ascInput.addEventListener('change', () =>
3353 {
3354 ascText.textContent = ascInput.checked ? 'Ascending' : 'Descending';
3355 });
3356 ascLabel.appendChild(ascInput);
3357 ascLabel.appendChild(ascText);
3358 section.appendChild(ascLabel);
3359
3360 actions.appendChild(section);
3361}
3362
3363function closeSidebar ()
3364{
3365 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return;
3366 beginSidebarLoad();
3367 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
3368 STATE.selectedItem = null;
3369
3370 if (isMobileViewport())
3371 {
3372 hideSidebarPanel();
3373 return;
3374 }
3375
3376 openFolderSidebar();
3377}
3378
3379function isMobileViewport ()
3380{
3381 return window.matchMedia(MOBILE_BREAKPOINT_QUERY).matches;
3382}
3383
3384function hideSidebarPanel ()
3385{
3386 const sidebar = document.getElementById('sidebar');
3387 const app = document.getElementById('app');
3388 sidebar.classList.add('hidden');
3389 app.classList.remove('sidebar-open');
3390}
3391
3392function basenameOfPath (p)
3393{
3394 const parts = String(p || '').split(/[\\/]/).filter(Boolean);
3395 return parts.length ? parts[parts.length - 1] : String(p || '');
3396}
3397
3398async function fetchRootAccessList (rootPath)
3399{
3400 if (!rootPath) return null;
3401 const data = await api('GET', `/files/root-access?rootPath=${encodeURIComponent(rootPath)}`).catch((err) =>
3402 {
3403 if (isAbortError(err)) return null;
3404 return null;
3405 });
3406 if (!data || !Array.isArray(data.users)) return null;
3407 return data.users;
3408}
3409
3410function formatRootAccessList (users)
3411{
3412 if (!Array.isArray(users) || users.length === 0) return 'No users';
3413
3414 const sorted = [...users].sort((a, b) =>
3415 {
3416 const modeRank = (mode) => mode === 'R+W' ? 0 : 1;
3417 const byMode = modeRank(a.mode) - modeRank(b.mode);
3418 if (byMode !== 0) return byMode;
3419 return String(a.username).localeCompare(String(b.username));
3420 });
3421
3422 const items = sorted
3423 .map((u) => `<li>${escapeHtml(String(u.username || ''))} ${escapeHtml(String(u.mode || 'R'))}</li>`)
3424 .join('');
3425 return `<ul class="root-access-list">${items}</ul>`;
3426}
3427
3428function rootPermissionLabel (root)
3429{
3430 if (root && root.isUserFolder) return 'My Folder';
3431 return (root && (root.originalName || root.label)) || '';
3432}
3433
3434function resolveRootForPath (targetPath)
3435{
3436 if (!targetPath) return null;
3437 return STATE.roots.find((r) => samePath(targetPath, r.path) || pathInside(targetPath, r.path)) || null;
3438}
3439
3440function writableRoots ()
3441{
3442 if (STATE.isAdmin) return STATE.roots.slice();
3443 return STATE.roots.filter((r) =>
3444 {
3445 if (r.isUserFolder) return true;
3446 const perm = STATE.permissions[rootPermissionLabel(r)];
3447 return !!(perm && perm.write);
3448 });
3449}
3450
3451async function moveWithConflictResolution (item, targetDir)
3452{
3453 try
3454 {
3455 return await api('POST', '/files/move', { from: item.path, toDir: targetDir });
3456 }
3457 catch (err)
3458 {
3459 if (!/already exists/i.test(err.message || '')) throw err;
3460
3461 const existingNames = await listDirNameSet(targetDir);
3462 const desiredName = item.name || basenameOfPath(item.path) || 'file';
3463 const suggestedName = nextAvailableName(desiredName, existingNames);
3464 const decision = await showFileConflictChoice(desiredName, suggestedName, 'move');
3465 if (decision === 'cancel') return null;
3466
3467 if (decision === 'overwrite')
3468 {
3469 return api('POST', '/files/move', {
3470 from: item.path,
3471 toDir: targetDir,
3472 conflict: 'overwrite',
3473 });
3474 }
3475
3476 return api('POST', '/files/move', {
3477 from: item.path,
3478 toDir: targetDir,
3479 conflict: 'rename',
3480 targetName: suggestedName,
3481 });
3482 }
3483}
3484
3485async function copyWithConflictResolution (item, targetDir)
3486{
3487 try
3488 {
3489 return await api('POST', '/files/copy', { from: item.path, toDir: targetDir });
3490 }
3491 catch (err)
3492 {
3493 if (!/already exists/i.test(err.message || '')) throw err;
3494
3495 const existingNames = await listDirNameSet(targetDir);
3496 const desiredName = item.name || basenameOfPath(item.path) || 'file';
3497 const suggestedName = nextAvailableName(desiredName, existingNames);
3498 const decision = await showFileConflictChoice(desiredName, suggestedName, 'copy');
3499 if (decision === 'cancel') return null;
3500
3501 if (decision === 'overwrite')
3502 {
3503 return api('POST', '/files/copy', {
3504 from: item.path,
3505 toDir: targetDir,
3506 conflict: 'overwrite',
3507 });
3508 }
3509
3510 return api('POST', '/files/copy', {
3511 from: item.path,
3512 toDir: targetDir,
3513 conflict: 'rename',
3514 targetName: suggestedName,
3515 });
3516 }
3517}
3518
3519function ensureMoveModal ()
3520{
3521 let overlay = document.getElementById('move-modal');
3522 if (overlay) return overlay;
3523
3524 overlay = document.createElement('div');
3525 overlay.id = 'move-modal';
3526 overlay.className = 'modal-overlay hidden';
3527 overlay.innerHTML = `
3528 <div class="modal move-modal">
3529 <button class="modal-close" id="move-modal-close" aria-label="Close">✕</button>
3530 <h2>Move To</h2>
3531 <p id="move-modal-caption" class="muted"></p>
3532 <div id="move-tree" class="move-tree"></div>
3533 <p id="move-selected" class="muted"></p>
3534 <div class="dialog-actions">
3535 <button id="move-modal-cancel">Cancel</button>
3536 <button id="move-modal-confirm" class="primary">Move</button>
3537 </div>
3538 </div>
3539 `;
3540 document.body.appendChild(overlay);
3541
3542 const closeBtn = overlay.querySelector('#move-modal-close');
3543 const cancelBtn = overlay.querySelector('#move-modal-cancel');
3544 const confirmBtn = overlay.querySelector('#move-modal-confirm');
3545
3546 function hide ()
3547 {
3548 overlay.classList.add('hidden');
3549 STATE.movePicker = null;
3550 }
3551
3552 closeBtn.addEventListener('click', hide);
3553 cancelBtn.addEventListener('click', hide);
3554 overlay.addEventListener('click', (e) =>
3555 {
3556 if (e.target === overlay) hide();
3557 });
3558
3559 confirmBtn.addEventListener('click', async () =>
3560 {
3561 const st = STATE.movePicker;
3562 if (!st || !st.item || !st.selectedPath)
3563 {
3564 toast('Select a destination folder first.', 'err');
3565 return;
3566 }
3567
3568 try
3569 {
3570 if (st.mode === 'copy')
3571 {
3572 const copied = await copyWithConflictResolution(st.item, st.selectedPath);
3573 if (!copied) return;
3574 }
3575 else
3576 {
3577 const moved = await moveWithConflictResolution(st.item, st.selectedPath);
3578 if (!moved) return;
3579 }
3580 }
3581 catch (err)
3582 {
3583 const action = st.mode === 'copy' ? 'Copy' : 'Move';
3584 toast(`${action} failed: ${err.message}`, 'err');
3585 return;
3586 }
3587
3588 hide();
3589 if (st.mode !== 'copy' && STATE.selectedItem && STATE.selectedItem.path === st.item.path) closeSidebar();
3590 navigateTo(STATE.currentDir, STATE.currentRoot);
3591 });
3592
3593 return overlay;
3594}
3595
3596function setMoveSelection (path, buttonEl)
3597{
3598 if (!STATE.movePicker) return;
3599 STATE.movePicker.selectedPath = path;
3600
3601 document.querySelectorAll('.move-node-label.selected').forEach((el) => el.classList.remove('selected'));
3602 if (buttonEl) buttonEl.classList.add('selected');
3603
3604 const selectedEl = document.getElementById('move-selected');
3605 selectedEl.textContent = path ? `Destination: ${path}` : 'Destination: none';
3606}
3607
3608async function loadMoveChildren (containerEl, dirPath)
3609{
3610 if (containerEl.dataset.loaded === '1') return;
3611 containerEl.dataset.loaded = '1';
3612
3613 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dirPath)}`).catch(() => null);
3614 const folders = data ? data.items.filter((it) => it.isDir).sort((a, b) => a.name.localeCompare(b.name)) : [];
3615
3616 if (!folders.length)
3617 {
3618 const empty = document.createElement('div');
3619 empty.className = 'move-empty';
3620 empty.textContent = 'No subfolders';
3621 containerEl.appendChild(empty);
3622 return;
3623 }
3624
3625 for (const child of folders)
3626 {
3627 containerEl.appendChild(createMoveNode(child.path, child.name));
3628 }
3629}
3630
3631function createMoveNode (folderPath, label)
3632{
3633 const node = document.createElement('div');
3634 node.className = 'move-node';
3635
3636 const row = document.createElement('div');
3637 row.className = 'move-node-row';
3638
3639 const toggle = document.createElement('button');
3640 toggle.type = 'button';
3641 toggle.className = 'move-toggle';
3642 toggle.textContent = '▸';
3643
3644 const selectBtn = document.createElement('button');
3645 selectBtn.type = 'button';
3646 selectBtn.className = 'move-node-label';
3647 selectBtn.textContent = label;
3648 selectBtn.addEventListener('click', () => setMoveSelection(folderPath, selectBtn));
3649
3650 const children = document.createElement('div');
3651 children.className = 'move-children hidden';
3652
3653 toggle.addEventListener('click', async () =>
3654 {
3655 if (children.classList.contains('hidden'))
3656 {
3657 await loadMoveChildren(children, folderPath);
3658 children.classList.remove('hidden');
3659 toggle.textContent = '▾';
3660 } else
3661 {
3662 children.classList.add('hidden');
3663 toggle.textContent = '▸';
3664 }
3665 });
3666
3667 row.appendChild(toggle);
3668 row.appendChild(selectBtn);
3669 node.appendChild(row);
3670 node.appendChild(children);
3671 return node;
3672}
3673
3674function openDestinationPicker (item, mode)
3675{
3676 if (!canWrite())
3677 {
3678 toast('No write access.', 'err');
3679 return;
3680 }
3681
3682 const roots = writableRoots();
3683 if (!roots.length)
3684 {
3685 toast('No writable destination roots available.', 'err');
3686 return;
3687 }
3688
3689 const overlay = ensureMoveModal();
3690 const tree = overlay.querySelector('#move-tree');
3691 const caption = overlay.querySelector('#move-modal-caption');
3692 const titleEl = overlay.querySelector('h2');
3693 const confirmBtn = overlay.querySelector('#move-modal-confirm');
3694
3695 const op = mode === 'copy' ? 'copy' : 'move';
3696 STATE.movePicker = { item, selectedPath: null, mode: op };
3697 titleEl.textContent = op === 'copy' ? 'Copy To' : 'Move To';
3698 confirmBtn.textContent = op === 'copy' ? 'Copy' : 'Move';
3699 caption.textContent = `Select destination folder for: ${item.name}`;
3700 tree.innerHTML = '';
3701
3702 for (const root of roots)
3703 {
3704 tree.appendChild(createMoveNode(root.path, root.label));
3705 }
3706
3707 setMoveSelection(null, null);
3708 overlay.classList.remove('hidden');
3709}
3710
3711function openMovePicker (item)
3712{
3713 openDestinationPicker(item, 'move');
3714}
3715
3716function openCopyPicker (item)
3717{
3718 openDestinationPicker(item, 'copy');
3719}
3720
3721// ───────────────────────────────────────────────────────────────────────────
3722// FOLDER ICON PICKER
3723// ───────────────────────────────────────────────────────────────────────────
3724
3725function globalFaviconFallbackMarkup ()
3726{
3727 return iconFile('favicon.png', 18);
3728}
3729
3730function applyGlobalFaviconPreview (hasFavicon)
3731{
3732 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
3733 const preview = document.getElementById('global-favicon-preview');
3734 if (!preview) return;
3735
3736 if (!hasFavicon)
3737 {
3738 preview.innerHTML = globalFaviconFallbackMarkup();
3739 return;
3740 }
3741
3742 const img = document.createElement('img');
3743 img.alt = 'Current favicon';
3744 img.src = `/api/files/global-favicon-image?v=${STATE.faviconVersion}`;
3745 img.addEventListener('error', () =>
3746 {
3747 preview.innerHTML = globalFaviconFallbackMarkup();
3748 }, { once: true });
3749 preview.innerHTML = '';
3750 preview.appendChild(img);
3751}
3752
3753function applyGlobalFaviconLink (hasFavicon)
3754{
3755 if (typeof document === 'undefined' || typeof document.getElementById !== 'function' || !document.head) return;
3756 let link = document.getElementById('global-favicon-link');
3757 if (!link)
3758 {
3759 link = document.createElement('link');
3760 link.id = 'global-favicon-link';
3761 link.rel = 'icon';
3762 document.head.appendChild(link);
3763 }
3764
3765 if (!hasFavicon)
3766 {
3767 link.removeAttribute('href');
3768 return;
3769 }
3770
3771 link.href = `/api/files/global-favicon-image?v=${STATE.faviconVersion}`;
3772}
3773
3774async function refreshGlobalFavicon ()
3775{
3776 const data = await api('GET', '/files/global-favicon').catch(() => null);
3777 const hasFavicon = !!(data && data.favicon && data.favicon.filePath);
3778 applyGlobalFaviconPreview(hasFavicon);
3779 applyGlobalFaviconLink(hasFavicon);
3780}
3781
3782async function openIconPickerModal ({
3783 dirPath,
3784 titleText,
3785 subtitleText,
3786 emptyText,
3787 confirmLabel,
3788 clearLabel,
3789 onSelect,
3790 onClear,
3791})
3792{
3793 if (!dirPath)
3794 {
3795 toast('Open a folder first.', 'err');
3796 return;
3797 }
3798
3799 const data = await api('GET', `/files/folder-images?dir=${encodeURIComponent(dirPath)}`).catch(() => null);
3800 const images = data ? data.images : [];
3801
3802 const existingIconOverlay = document.getElementById('folder-icon-picker');
3803 if (existingIconOverlay) existingIconOverlay.remove();
3804
3805 const overlay = document.createElement('div');
3806 overlay.id = 'folder-icon-picker';
3807 overlay.className = 'modal-overlay';
3808
3809 const modal = document.createElement('div');
3810 modal.className = 'modal folder-icon-modal';
3811
3812 const closeBtn = document.createElement('button');
3813 closeBtn.className = 'modal-close';
3814 closeBtn.setAttribute('aria-label', 'Close');
3815 closeBtn.textContent = '✕';
3816
3817 const title = document.createElement('h2');
3818 title.textContent = titleText;
3819
3820 const filterInput = document.createElement('input');
3821 filterInput.type = 'text';
3822 filterInput.className = 'folder-icon-filter';
3823 filterInput.placeholder = 'Search icons';
3824 filterInput.setAttribute('aria-label', 'Search icons');
3825
3826 const subtitle = document.createElement('p');
3827 subtitle.className = 'muted';
3828 subtitle.textContent = images.length ? subtitleText : emptyText;
3829
3830 const grid = document.createElement('div');
3831 grid.className = 'folder-icon-grid';
3832
3833 for (const { filePath } of images)
3834 {
3835 const name = filePath.split('/').pop();
3836 const cell = document.createElement('div');
3837 cell.className = 'folder-icon-cell';
3838 cell.dataset.path = filePath;
3839 cell.dataset.name = String(name || '').toLowerCase();
3840
3841 const imgEl = document.createElement('img');
3842 imgEl.alt = name;
3843 imgEl.className = 'folder-icon-thumb';
3844 imgEl.dataset.src = filePath;
3845
3846 const label = document.createElement('div');
3847 label.className = 'folder-icon-label';
3848 label.textContent = name;
3849
3850 cell.appendChild(imgEl);
3851 cell.appendChild(label);
3852
3853 cell.addEventListener('click', () =>
3854 {
3855 grid.querySelectorAll('.folder-icon-cell.selected').forEach(el => el.classList.remove('selected'));
3856 cell.classList.add('selected');
3857 confirmBtn.disabled = false;
3858 });
3859
3860 grid.appendChild(cell);
3861 }
3862
3863 function applyFilter ()
3864 {
3865 const needle = String(filterInput.value || '').trim().toLowerCase();
3866 let visible = 0;
3867 for (const cell of grid.querySelectorAll('.folder-icon-cell'))
3868 {
3869 const name = cell.dataset.name || '';
3870 const show = !needle || name.includes(needle);
3871 cell.classList.toggle('hidden', !show);
3872 if (show) visible += 1;
3873 }
3874 subtitle.textContent = visible
3875 ? subtitleText
3876 : 'No matching thumbnails were found.';
3877 }
3878
3879 filterInput.addEventListener('input', applyFilter);
3880
3881 const dialogActions = document.createElement('div');
3882 dialogActions.className = 'dialog-actions';
3883
3884 const clearBtn = document.createElement('button');
3885 clearBtn.textContent = clearLabel;
3886 clearBtn.addEventListener('click', async () =>
3887 {
3888 try
3889 {
3890 await onClear();
3891 }
3892 catch (err)
3893 {
3894 toast('Failed to clear icon: ' + err.message, 'err');
3895 return;
3896 }
3897 hide();
3898 });
3899
3900 const cancelBtn = document.createElement('button');
3901 cancelBtn.textContent = 'Cancel';
3902 cancelBtn.addEventListener('click', () => hide());
3903
3904 const confirmBtn = document.createElement('button');
3905 confirmBtn.className = 'primary';
3906 confirmBtn.textContent = confirmLabel;
3907 confirmBtn.disabled = true;
3908 confirmBtn.addEventListener('click', async () =>
3909 {
3910 const selected = grid.querySelector('.folder-icon-cell.selected');
3911 if (!selected) return;
3912
3913 try
3914 {
3915 await onSelect(selected.dataset.path);
3916 }
3917 catch (err)
3918 {
3919 toast('Failed to set icon: ' + err.message, 'err');
3920 return;
3921 }
3922
3923 hide();
3924 });
3925
3926 dialogActions.appendChild(clearBtn);
3927 dialogActions.appendChild(cancelBtn);
3928 dialogActions.appendChild(confirmBtn);
3929
3930 modal.appendChild(closeBtn);
3931 modal.appendChild(title);
3932 modal.appendChild(filterInput);
3933 modal.appendChild(subtitle);
3934 modal.appendChild(grid);
3935 modal.appendChild(dialogActions);
3936 overlay.appendChild(modal);
3937 document.body.appendChild(overlay);
3938
3939 function hide ()
3940 {
3941 overlay.remove();
3942 grid.querySelectorAll('.folder-icon-thumb[src^="blob:"]').forEach((img) =>
3943 {
3944 URL.revokeObjectURL(img.src);
3945 });
3946 }
3947
3948 closeBtn.addEventListener('click', hide);
3949 overlay.addEventListener('click', (e) => { if (e.target === overlay) hide(); });
3950
3951 for (const cell of grid.querySelectorAll('.folder-icon-cell'))
3952 {
3953 const imgEl = cell.querySelector('.folder-icon-thumb');
3954 const filePath = imgEl.dataset.src;
3955 void fetch(`/api/files/thumbnail?file=${encodeURIComponent(filePath)}`, {
3956 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
3957 }).then(async (r) =>
3958 {
3959 if (!r.ok || !overlay.isConnected) return;
3960 const blob = await r.blob();
3961 const url = URL.createObjectURL(blob);
3962 imgEl.src = url;
3963 }).catch(() => { });
3964 }
3965
3966 filterInput.focus();
3967}
3968
3969async function openFolderIconPicker (item)
3970{
3971 if (!canWrite(item))
3972 {
3973 toast('No write access.', 'err');
3974 return;
3975 }
3976
3977 await openIconPickerModal({
3978 dirPath: item.path,
3979 titleText: 'Set folder icon',
3980 subtitleText: 'Select a file thumbnail to use as the folder icon.',
3981 emptyText: 'No files with cached thumbnails were found inside this folder.',
3982 confirmLabel: 'Set icon',
3983 clearLabel: 'Clear icon',
3984 onSelect: async (imagePath) =>
3985 {
3986 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath });
3987 refreshAfterIconChange(item);
3988 },
3989 onClear: async () =>
3990 {
3991 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath: null });
3992 refreshAfterIconChange(item);
3993 },
3994 });
3995}
3996
3997async function openGlobalFaviconPicker ()
3998{
3999 if (!STATE.isAdmin)
4000 {
4001 toast('Admin access required.', 'err');
4002 return;
4003 }
4004
4005 const existingIconOverlay = document.getElementById('folder-icon-picker');
4006 if (existingIconOverlay) existingIconOverlay.remove();
4007
4008 const overlay = document.createElement('div');
4009 overlay.id = 'folder-icon-picker';
4010 overlay.className = 'modal-overlay';
4011
4012 const modal = document.createElement('div');
4013 modal.className = 'modal folder-icon-modal';
4014
4015 const closeBtn = document.createElement('button');
4016 closeBtn.className = 'modal-close';
4017 closeBtn.setAttribute('aria-label', 'Close');
4018 closeBtn.textContent = '✕';
4019
4020 const title = document.createElement('h2');
4021 title.textContent = 'Set global favicon';
4022
4023 const filterInput = document.createElement('input');
4024 filterInput.type = 'text';
4025 filterInput.className = 'folder-icon-filter';
4026 filterInput.placeholder = 'Search images across all folders';
4027 filterInput.setAttribute('aria-label', 'Search images');
4028
4029 const subtitle = document.createElement('p');
4030 subtitle.className = 'muted';
4031 subtitle.textContent = 'Type at least 2 characters to search accessible images.';
4032
4033 const grid = document.createElement('div');
4034 grid.className = 'folder-icon-grid';
4035
4036 const dialogActions = document.createElement('div');
4037 dialogActions.className = 'dialog-actions';
4038
4039 const clearBtn = document.createElement('button');
4040 clearBtn.textContent = 'Clear favicon';
4041 clearBtn.addEventListener('click', async () =>
4042 {
4043 try
4044 {
4045 await api('POST', '/files/global-favicon', { imagePath: null });
4046 STATE.faviconVersion = Date.now();
4047 await refreshGlobalFavicon();
4048 }
4049 catch (err)
4050 {
4051 toast('Failed to clear icon: ' + err.message, 'err');
4052 return;
4053 }
4054 hide();
4055 });
4056
4057 const cancelBtn = document.createElement('button');
4058 cancelBtn.textContent = 'Cancel';
4059 cancelBtn.addEventListener('click', () => hide());
4060
4061 const confirmBtn = document.createElement('button');
4062 confirmBtn.className = 'primary';
4063 confirmBtn.textContent = 'Set favicon';
4064 confirmBtn.disabled = true;
4065
4066 let selectedPath = null;
4067 let searchToken = 0;
4068 let searchTimer = null;
4069
4070 confirmBtn.addEventListener('click', async () =>
4071 {
4072 if (!selectedPath) return;
4073 try
4074 {
4075 await api('POST', '/files/global-favicon', { imagePath: selectedPath });
4076 STATE.faviconVersion = Date.now();
4077 await refreshGlobalFavicon();
4078 }
4079 catch (err)
4080 {
4081 toast('Failed to set icon: ' + err.message, 'err');
4082 return;
4083 }
4084 hide();
4085 });
4086
4087 function revokeCellThumbs ()
4088 {
4089 grid.querySelectorAll('.folder-icon-thumb[src^="blob:"]').forEach((img) =>
4090 {
4091 URL.revokeObjectURL(img.src);
4092 });
4093 }
4094
4095 function renderResults (items)
4096 {
4097 selectedPath = null;
4098 confirmBtn.disabled = true;
4099 revokeCellThumbs();
4100 grid.innerHTML = '';
4101
4102 for (const { path: filePath, name } of (items || []))
4103 {
4104 const cell = document.createElement('div');
4105 cell.className = 'folder-icon-cell';
4106 cell.dataset.path = filePath;
4107
4108 const imgEl = document.createElement('img');
4109 imgEl.alt = name;
4110 imgEl.className = 'folder-icon-thumb';
4111
4112 const label = document.createElement('div');
4113 label.className = 'folder-icon-label';
4114 label.textContent = name;
4115
4116 cell.appendChild(imgEl);
4117 cell.appendChild(label);
4118
4119 cell.addEventListener('click', () =>
4120 {
4121 grid.querySelectorAll('.folder-icon-cell.selected').forEach(el => el.classList.remove('selected'));
4122 cell.classList.add('selected');
4123 selectedPath = filePath;
4124 confirmBtn.disabled = false;
4125 });
4126
4127 grid.appendChild(cell);
4128
4129 void fetch(`/api/files/thumbnail?file=${encodeURIComponent(filePath)}`, {
4130 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
4131 }).then(async (r) =>
4132 {
4133 if (!r.ok || !overlay.isConnected) return;
4134 const blob = await r.blob();
4135 const url = URL.createObjectURL(blob);
4136 imgEl.src = url;
4137 }).catch(() => { });
4138 }
4139 }
4140
4141 async function runSearchNow ()
4142 {
4143 const query = String(filterInput.value || '').trim();
4144 searchToken += 1;
4145 const token = searchToken;
4146
4147 if (query.length < 2)
4148 {
4149 subtitle.textContent = 'Type at least 2 characters to search accessible images.';
4150 renderResults([]);
4151 return;
4152 }
4153
4154 subtitle.textContent = 'Searching…';
4155 const data = await api('GET', `/files/search-images?query=${encodeURIComponent(query)}&limit=80`).catch(() => null);
4156 if (!overlay.isConnected || token !== searchToken) return;
4157
4158 const results = Array.isArray(data && data.results) ? data.results : [];
4159 renderResults(results);
4160
4161 if (!results.length)
4162 {
4163 subtitle.textContent = 'No matching thumbnails were found.';
4164 return;
4165 }
4166
4167 const suffix = data && data.truncated
4168 ? ` Scanned first ${Number(data.scannedFiles) || 0} files; refine your search for more.`
4169 : '';
4170 subtitle.textContent = `${results.length} matching image${results.length === 1 ? '' : 's'} found.${suffix}`;
4171 }
4172
4173 filterInput.addEventListener('input', () =>
4174 {
4175 if (searchTimer) clearTimeout(searchTimer);
4176 searchTimer = setTimeout(() =>
4177 {
4178 void runSearchNow();
4179 }, 240);
4180 });
4181
4182 dialogActions.appendChild(clearBtn);
4183 dialogActions.appendChild(cancelBtn);
4184 dialogActions.appendChild(confirmBtn);
4185
4186 modal.appendChild(closeBtn);
4187 modal.appendChild(title);
4188 modal.appendChild(filterInput);
4189 modal.appendChild(subtitle);
4190 modal.appendChild(grid);
4191 modal.appendChild(dialogActions);
4192 overlay.appendChild(modal);
4193 document.body.appendChild(overlay);
4194
4195 function hide ()
4196 {
4197 if (searchTimer) clearTimeout(searchTimer);
4198 overlay.remove();
4199 revokeCellThumbs();
4200 }
4201
4202 closeBtn.addEventListener('click', hide);
4203 overlay.addEventListener('click', (e) => { if (e.target === overlay) hide(); });
4204 filterInput.focus();
4205}
4206
4207function refreshAfterIconChange (item)
4208{
4209 // Reset and reload icon in grid tiles.
4210 const gridTile = Array.from(document.querySelectorAll('.icon[data-folder-path]'))
4211 .find(el => el.dataset.folderPath === item.path);
4212 if (gridTile)
4213 {
4214 const svg = gridTile.querySelector('svg');
4215 if (svg)
4216 {
4217 // Rebuild to plain folder SVG, then reload.
4218 gridTile.innerHTML = iconFolder();
4219 delete gridTile.dataset.thumbReady;
4220 gridTile.dataset.folderPath = item.path;
4221 void loadOneFolderIcon(gridTile);
4222 }
4223 }
4224
4225 // Also reset the sidebar icon if it's showing the same folder.
4226 const sidebarIcon = document.getElementById('sidebar-icon');
4227 if (sidebarIcon && sidebarIcon.dataset.folderPath === item.path)
4228 {
4229 sidebarIcon.innerHTML = iconFolder(64);
4230 delete sidebarIcon.dataset.thumbReady;
4231 void loadOneFolderIcon(sidebarIcon);
4232 }
4233}
4234
4235// ───────────────────────────────────────────────────────────────────────────
4236// DOWNLOAD / VIEW
4237// ───────────────────────────────────────────────────────────────────────────
4238
4239function isInlinePreviewableBlob (blob, name)
4240{
4241 const mime = String(blob.type || '').toLowerCase();
4242 if (/^(image|video|audio)\//.test(mime)) return true;
4243 if (/^text\//.test(mime)) return true;
4244 if (mime === 'application/pdf') return true;
4245 if (mime === 'application/json') return true;
4246 if (mime === 'application/xml') return true;
4247 if (mime === 'application/javascript') return true;
4248
4249 // Fallback by extension when MIME is missing or generic.
4250 const ext = extOf(name || '');
4251 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || AUDIO_EXTS.has(ext)) return true;
4252 if (MODEL_EXTS.has(ext)) return true;
4253 if (MODEL_EXTS.has(ext)) return true;
4254 if (CODE_EXTS.has(ext)) return true;
4255 return false;
4256}
4257
4258function isTextLikeBlob (blob, name)
4259{
4260 const mime = String(blob.type || '').toLowerCase();
4261 if (/^text\//.test(mime)) return true;
4262 if (mime === 'application/json' || mime === 'application/xml' || mime === 'application/javascript') return true;
4263 const ext = extOf(name || '');
4264 return CODE_EXTS.has(ext);
4265}
4266
4267function detectCodeLanguage (name, mime)
4268{
4269 const ext = extOf(name || '');
4270 const m = String(mime || '').toLowerCase();
4271 if (m.includes('json') || ext === 'json') return 'json';
4272 if (m.includes('xml') || ext === 'xml') return 'xml';
4273 if (m.includes('html') || ext === 'html' || ext === 'htm') return 'html';
4274 if (m.includes('css') || ext === 'css') return 'css';
4275 if (m.includes('javascript') || ['js', 'jsx', 'mjs', 'cjs'].includes(ext)) return 'js';
4276 if (m.includes('typescript') || ['ts', 'tsx'].includes(ext)) return 'ts';
4277 if (['sh', 'bash', 'zsh'].includes(ext)) return 'sh';
4278 if (['md', 'txt', 'log', 'ini', 'toml', 'yaml', 'yml'].includes(ext)) return 'plain';
4279 return CODE_EXTS.has(ext) ? 'js' : 'plain';
4280}
4281
4282function prettyPrintMarkup (raw)
4283{
4284 const src = String(raw || '')
4285 .replace(/>\s+</g, '><')
4286 .replace(/\r\n/g, '\n');
4287
4288 const lines = src.replace(/></g, '>\n<').split('\n');
4289 let indent = 0;
4290 const out = [];
4291
4292 for (const ln of lines)
4293 {
4294 const line = ln.trim();
4295 if (!line) continue;
4296 const isClose = /^<\//.test(line);
4297 const isSelf = /\/>$/.test(line) || /^<[^!?][^>]*>[^<]*<\/[^>]+>$/.test(line);
4298 const isOpen = /^<[^!?/][^>]*>$/.test(line);
4299
4300 if (isClose) indent = Math.max(0, indent - 1);
4301 out.push(' '.repeat(indent) + line);
4302 if (isOpen && !isSelf) indent += 1;
4303 }
4304
4305 return out.join('\n');
4306}
4307
4308function prettyPrintBraces (raw)
4309{
4310 const lines = String(raw || '')
4311 .replace(/\r\n/g, '\n')
4312 .split('\n');
4313 let indent = 0;
4314 const out = [];
4315
4316 for (const ln of lines)
4317 {
4318 const line = ln.trim();
4319 if (!line)
4320 {
4321 out.push('');
4322 continue;
4323 }
4324 if (/^[}\])]/.test(line)) indent = Math.max(0, indent - 1);
4325 out.push(' '.repeat(indent) + line);
4326 if (/[{[(]$/.test(line) || /[{[(]\s*(\/\/.*)?$/.test(line)) indent += 1;
4327 }
4328 return out.join('\n');
4329}
4330
4331function prettyPrintCode (raw, lang)
4332{
4333 const text = String(raw || '').replace(/\r\n/g, '\n');
4334 if (lang === 'json')
4335 {
4336 try { return JSON.stringify(JSON.parse(text), null, 2); } catch { return text; }
4337 }
4338 if (lang === 'xml' || lang === 'html') return prettyPrintMarkup(text);
4339 if (lang === 'js' || lang === 'ts' || lang === 'css') return prettyPrintBraces(text);
4340 return text;
4341}
4342
4343function escapeHtml (s)
4344{
4345 return String(s)
4346 .replace(/&/g, '&amp;')
4347 .replace(/</g, '&lt;')
4348 .replace(/>/g, '&gt;');
4349}
4350
4351function highlightCode (raw, lang)
4352{
4353 if (lang === 'plain') return escapeHtml(raw);
4354
4355 let html = escapeHtml(raw);
4356 const stash = [];
4357 const keep = (regex, cls) =>
4358 {
4359 html = html.replace(regex, (m) =>
4360 {
4361 const idx = stash.push(`<span class="tok-${cls}">${m}</span>`) - 1;
4362 return `@@TOK${idx}@@`;
4363 });
4364 };
4365
4366 if (lang === 'json')
4367 {
4368 html = html
4369 .replace(/("(?:\\.|[^"\\])*")\s*:/g, '<span class="tok-key">$1</span>:')
4370 .replace(/: ("(?:\\.|[^"\\])*")/g, ': <span class="tok-string">$1</span>')
4371 .replace(/\b(true|false|null)\b/g, '<span class="tok-keyword">$1</span>')
4372 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
4373 return html;
4374 }
4375
4376 if (lang === 'xml' || lang === 'html')
4377 {
4378 html = html
4379 .replace(/(&lt;\/?)([a-zA-Z0-9:_-]+)/g, '$1<span class="tok-keyword">$2</span>')
4380 .replace(/([a-zA-Z0-9:_-]+)=(&quot;[^&]*&quot;|"[^"]*")/g, '<span class="tok-key">$1</span>=<span class="tok-string">$2</span>');
4381 return html;
4382 }
4383
4384 if (lang === 'sh') keep(/(^|\s)#.*$/gm, 'comment');
4385 else keep(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, 'comment');
4386 keep(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, 'string');
4387
4388 html = html
4389 .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>')
4390 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
4391
4392 html = html.replace(/@@TOK(\d+)@@/g, (_, idx) => stash[Number(idx)] || '');
4393 return html;
4394}
4395
4396function clearPreviewObjectUrl ()
4397{
4398 if (typeof STATE.previewCleanup === 'function')
4399 {
4400 try { STATE.previewCleanup(); } catch { /* ignore */ }
4401 }
4402 STATE.previewCleanup = null;
4403 STATE.previewDownloadAction = null;
4404 if (!STATE.previewObjectUrl) return;
4405 if (String(STATE.previewObjectUrl).startsWith('blob:'))
4406 {
4407 URL.revokeObjectURL(STATE.previewObjectUrl);
4408 }
4409 STATE.previewObjectUrl = null;
4410}
4411
4412function ensureStylesheet (id, href)
4413{
4414 let link = document.getElementById(id);
4415 if (link) return Promise.resolve(link);
4416
4417 link = document.createElement('link');
4418 link.id = id;
4419 link.rel = 'stylesheet';
4420 link.href = href;
4421
4422 return new Promise((resolve, reject) =>
4423 {
4424 link.addEventListener('load', () => resolve(link), { once: true });
4425 link.addEventListener('error', () => reject(new Error('Failed to load video player styles.')), { once: true });
4426 document.head.appendChild(link);
4427 });
4428}
4429
4430function ensureScript (id, src)
4431{
4432 let script = document.getElementById(id);
4433 if (script && window.videojs) return Promise.resolve(window.videojs);
4434
4435 if (!script)
4436 {
4437 script = document.createElement('script');
4438 script.id = id;
4439 script.src = src;
4440 }
4441
4442 return new Promise((resolve, reject) =>
4443 {
4444 script.addEventListener('load', () => resolve(window.videojs), { once: true });
4445 script.addEventListener('error', () => reject(new Error('Failed to load video player script.')), { once: true });
4446 if (!script.isConnected) document.head.appendChild(script);
4447 });
4448}
4449
4450async function ensureVideoJsLoaded ()
4451{
4452 if (window.videojs)
4453 {
4454 configureVideoJsBuffering(window.videojs);
4455 return window.videojs;
4456 }
4457 if (!videoJsLoaderPromise)
4458 {
4459 videoJsLoaderPromise = Promise.all([
4460 ensureStylesheet('videojs-styles', '/vendor/video.js/video-js.css'),
4461 ensureScript('videojs-script', '/vendor/video.js/video.min.js'),
4462 ]).then(() =>
4463 {
4464 configureVideoJsBuffering(window.videojs);
4465 return window.videojs;
4466 });
4467 }
4468 return videoJsLoaderPromise;
4469}
4470
4471function configureVideoJsBuffering (videojs)
4472{
4473 if (!VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED)
4474 return;
4475
4476 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
4477 videojs.__filemanagerBufferingConfigured = true;
4478
4479 try
4480 {
4481 videojs.Vhs.GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
4482 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
4483 } catch
4484 {
4485 // Ignore builds that do not expose VHS buffer configuration.
4486 }
4487}
4488
4489async function createVideoStreamSessionForItem (item)
4490{
4491 return api('POST', '/files/video-stream', { filePath: item.path });
4492}
4493
4494async function releaseVideoStreamSession (sessionId, opts = {})
4495{
4496 const id = String(sessionId || '').trim();
4497 if (!id) return;
4498
4499 await api('DELETE', `/files/video-stream/${encodeURIComponent(id)}`, null, {
4500 keepalive: !!opts.keepalive,
4501 noAutoLogout: true,
4502 }).catch(() => null);
4503}
4504
4505function releaseActivePreviewVideoStreamSession (opts = {})
4506{
4507 const sessionId = String(STATE.previewVideoStreamSessionId || '').trim();
4508 if (!sessionId) return;
4509 STATE.previewVideoStreamSessionId = null;
4510 void releaseVideoStreamSession(sessionId, opts);
4511}
4512
4513async function preparePreviewDownload (item)
4514{
4515 const blob = await fetchFileBlob(item);
4516 if (!blob)
4517 {
4518 toast('Download failed.', 'err');
4519 return;
4520 }
4521
4522 const objectUrl = URL.createObjectURL(blob);
4523 triggerDownload(item.name, objectUrl);
4524 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
4525}
4526
4527async function renderStreamedVideoPreview (item, targetEl)
4528{
4529 const videojs = await ensureVideoJsLoaded();
4530 const session = await createVideoStreamSessionForItem(item);
4531 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
4532 const prefs = loadUserVideoPrefs();
4533 applyUserVideoTextTrackPrefs();
4534
4535 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
4536 {
4537 toast('Some subtitle tracks could not be converted for web playback.', 'err');
4538 }
4539
4540 STATE.previewDownloadAction = () => preparePreviewDownload(item);
4541
4542 const video = document.createElement('video');
4543 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
4544 video.controls = true;
4545 video.preload = 'auto';
4546 video.playsInline = true;
4547 targetEl.classList.add('preview-expand-content--video');
4548 targetEl.appendChild(video);
4549
4550 const player = videojs(video, {
4551 controls: true,
4552 fluid: false,
4553 fill: true,
4554 responsive: false,
4555 preload: 'auto',
4556 controlBar: {
4557 currentTimeDisplay: true,
4558 timeDivider: true,
4559 durationDisplay: true,
4560 remainingTimeDisplay: false,
4561 },
4562 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
4563 tracks: (session.subtitleTracks || []).map((track) => ({
4564 kind: 'subtitles',
4565 src: track.src,
4566 srclang: track.language || 'und',
4567 label: track.label,
4568 default: !!track.default,
4569 })),
4570 });
4571
4572 const trackPrefs = bindUserVideoTrackPrefs(player, prefs);
4573
4574 ensureVideoPlaybackUi(player, session.durationSeconds);
4575 const imageSubtitleController = bindImageSubtitleOverlay(player, videojs, prefs, session, item);
4576
4577 // -------------------------------------------------------------------------
4578
4579 let sentPartway = false;
4580 let sentFully = false;
4581 const markWatch = async () =>
4582 {
4583 let ratio = 0;
4584 try
4585 {
4586 const duration = Number(player.duration());
4587 const current = Number(player.currentTime());
4588 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
4589 {
4590 ratio = current / duration;
4591 }
4592 } catch
4593 {
4594 return;
4595 }
4596
4597 if (ratio >= 0.7)
4598 {
4599 if (sentFully) return;
4600 sentPartway = true;
4601 sentFully = true;
4602 void reportWatchProgress(item.path, ratio);
4603 return;
4604 }
4605
4606 if (ratio >= 0.05)
4607 {
4608 if (sentPartway) return;
4609 sentPartway = true;
4610 void reportWatchProgress(item.path, ratio);
4611 }
4612 };
4613
4614 player.ready(() =>
4615 {
4616 const volume = Number(prefs.volume);
4617 if (Number.isFinite(volume))
4618 {
4619 player.volume(Math.max(0, Math.min(1, volume)));
4620 }
4621
4622 const settings = player && player.textTrackSettings;
4623 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
4624 {
4625 settings.setValues({
4626 backgroundColor: '#000',
4627 backgroundOpacity: '0',
4628 edgeStyle: 'uniform',
4629 });
4630 settings.updateDisplay();
4631 }
4632
4633 trackPrefs.applySavedTracks();
4634 });
4635
4636 player.on('loadedmetadata', trackPrefs.applySavedTracks);
4637 player.on('loadedplaylist', trackPrefs.applySavedTracks);
4638 player.on('timeupdate', markWatch);
4639 player.on('ended', () =>
4640 {
4641 sentPartway = true;
4642 sentFully = true;
4643 void reportWatchProgress(item.path, 1);
4644 });
4645 player.on('volumechange', () =>
4646 {
4647 const v = Number(player.volume());
4648 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
4649 });
4650
4651 STATE.previewCleanup = () =>
4652 {
4653 if (imageSubtitleController)
4654 {
4655 try { imageSubtitleController.captureSelectedTracks(); } catch { /* ignore */ }
4656 try { imageSubtitleController.detach(); } catch { /* ignore */ }
4657 }
4658 releaseActivePreviewVideoStreamSession();
4659 try { markWatch(); } catch { /* ignore */ }
4660 try { trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
4661 try { trackPrefs.detach(); } catch { /* ignore */ }
4662 try { player.dispose(); } catch { /* ignore */ }
4663 };
4664}
4665
4666function fileAccentColor (name)
4667{
4668 const ext = extOf(name || '');
4669 if (IMAGE_EXTS.has(ext)) return '#3fcf8e';
4670 if (VIDEO_EXTS.has(ext)) return '#e05c6e';
4671 if (AUDIO_EXTS.has(ext)) return '#c084fc';
4672 if (MODEL_EXTS.has(ext)) return '#2f6dff';
4673 if (DOC_EXTS.has(ext)) return '#f97316';
4674 if (CODE_EXTS.has(ext)) return '#38bdf8';
4675 if (ARCHIVE_EXTS.has(ext)) return '#facc15';
4676 return '#7880a0';
4677}
4678
4679function animateRect (el, fromRect, toRect, opts = {})
4680{
4681 const duration = opts.duration == null ? 260 : opts.duration;
4682 const easeOut = (t) => 1 - Math.pow(1 - t, 3);
4683
4684 el.style.left = `${fromRect.left}px`;
4685 el.style.top = `${fromRect.top}px`;
4686 el.style.width = `${fromRect.width}px`;
4687 el.style.height = `${fromRect.height}px`;
4688
4689 return new Promise((resolve) =>
4690 {
4691 const t0 = performance.now();
4692
4693 function frame (now)
4694 {
4695 const raw = Math.min((now - t0) / duration, 1);
4696 const t = easeOut(raw);
4697
4698 const left = fromRect.left + (toRect.left - fromRect.left) * t;
4699 const top = fromRect.top + (toRect.top - fromRect.top) * t;
4700 const width = fromRect.width + (toRect.width - fromRect.width) * t;
4701 const height = fromRect.height + (toRect.height - fromRect.height) * t;
4702
4703 el.style.left = `${left}px`;
4704 el.style.top = `${top}px`;
4705 el.style.width = `${width}px`;
4706 el.style.height = `${height}px`;
4707
4708 if (raw < 1)
4709 {
4710 requestAnimationFrame(frame);
4711 } else
4712 {
4713 resolve();
4714 }
4715 }
4716
4717 requestAnimationFrame(frame);
4718 });
4719}
4720
4721async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewContent)
4722{
4723 if (!tileEl || !sourceSvgEl) return false;
4724
4725 if (STATE.previewExpandState)
4726 {
4727 await closeExpandedTilePreview();
4728 }
4729
4730 const iconEl = tileEl.querySelector('.icon');
4731 const nameEl = tileEl.querySelector('.name');
4732 if (!iconEl) return false;
4733
4734 const startRect = tileEl.getBoundingClientRect();
4735 const targetW = Math.min(window.innerWidth * 0.94, 1100);
4736 const targetH = Math.min(window.innerHeight * 0.9, 860);
4737 const targetRect = {
4738 left: (window.innerWidth - targetW) / 2,
4739 top: (window.innerHeight - targetH) / 2,
4740 width: targetW,
4741 height: targetH,
4742 };
4743
4744 const backdrop = document.createElement('div');
4745 backdrop.className = 'preview-backdrop';
4746 document.body.appendChild(backdrop);
4747
4748 const parent = tileEl.parentNode;
4749 const nextSibling = tileEl.nextSibling;
4750 const iconHtml = iconEl.innerHTML;
4751 const originalIconSvg = iconEl.querySelector('svg');
4752 const placeholder = document.createElement('div');
4753 placeholder.className = 'file-item file-item--preview-placeholder';
4754 placeholder.style.width = `${startRect.width}px`;
4755 placeholder.style.height = `${startRect.height}px`;
4756
4757 if (parent)
4758 {
4759 parent.insertBefore(placeholder, tileEl);
4760 }
4761
4762 tileEl.remove();
4763 document.body.appendChild(tileEl);
4764 tileEl.classList.add('file-item--preview');
4765 tileEl.style.setProperty('--preview-accent', fileAccentColor(item.name));
4766 tileEl.style.position = 'fixed';
4767 tileEl.style.left = `${startRect.left}px`;
4768 tileEl.style.top = `${startRect.top}px`;
4769 tileEl.style.width = `${startRect.width}px`;
4770 tileEl.style.height = `${startRect.height}px`;
4771 tileEl.style.margin = '0';
4772 tileEl.style.zIndex = '10000';
4773
4774 if (nameEl) nameEl.style.display = 'none';
4775
4776 const titleEl = document.createElement('div');
4777 titleEl.className = 'preview-expand-title';
4778 titleEl.textContent = item.name;
4779
4780 const closeBtn = document.createElement('button');
4781 closeBtn.className = 'preview-expand-close';
4782 closeBtn.type = 'button';
4783 closeBtn.textContent = '×';
4784 closeBtn.setAttribute('aria-label', 'Close preview');
4785
4786 const dlBtn = document.createElement('button');
4787 dlBtn.className = 'preview-expand-download';
4788 dlBtn.type = 'button';
4789 dlBtn.textContent = 'Download';
4790 dlBtn.addEventListener('click', async (e) =>
4791 {
4792 e.stopPropagation();
4793 if (STATE.previewDownloadAction)
4794 {
4795 await STATE.previewDownloadAction();
4796 return;
4797 }
4798 if (!STATE.previewObjectUrl)
4799 {
4800 toast('Preview still loading.', 'err');
4801 return;
4802 }
4803 triggerDownload(item.name, STATE.previewObjectUrl);
4804 });
4805
4806 const shareBtn = document.createElement('button');
4807 shareBtn.className = 'preview-expand-share';
4808 shareBtn.type = 'button';
4809 shareBtn.textContent = 'Share';
4810 shareBtn.addEventListener('click', (e) =>
4811 {
4812 e.stopPropagation();
4813 openShareModal(item);
4814 });
4815
4816 const actionsEl = document.createElement('div');
4817 actionsEl.className = 'preview-expand-actions';
4818 actionsEl.appendChild(shareBtn);
4819 actionsEl.appendChild(dlBtn);
4820
4821 iconEl.innerHTML = '';
4822
4823 if (originalIconSvg)
4824 {
4825 const outline = originalIconSvg.cloneNode(true);
4826 outline.classList.add('preview-expand-outline');
4827 iconEl.appendChild(outline);
4828 }
4829
4830 const previewMount = document.createElement('div');
4831 previewMount.className = 'preview-expand-content';
4832 iconEl.appendChild(previewMount);
4833
4834 // Show spinner during expansion animation; content loads after it finishes
4835 const spinner = document.createElement('div');
4836 spinner.className = 'preview-loading-spinner';
4837 previewMount.appendChild(spinner);
4838
4839 tileEl.insertBefore(titleEl, tileEl.firstChild);
4840 tileEl.appendChild(closeBtn);
4841 tileEl.appendChild(actionsEl);
4842
4843 STATE.previewExpandState = {
4844 item,
4845 requireExplicitClose: VIDEO_EXTS.has(extOf(item.name)),
4846 tileEl,
4847 sourceSvgEl,
4848 parent,
4849 nextSibling,
4850 iconEl,
4851 iconHtml,
4852 nameEl,
4853 backdrop,
4854 placeholder,
4855 closeBtn,
4856 dlBtn,
4857 shareBtn,
4858 actionsEl,
4859 titleEl,
4860 previewMount,
4861 startRect,
4862 };
4863
4864 const onBackdrop = (e) =>
4865 {
4866 if (e.target === backdrop) closePreview();
4867 };
4868 const onClose = () => closePreview({ force: true });
4869 backdrop.addEventListener('click', onBackdrop);
4870 closeBtn.addEventListener('click', onClose);
4871 STATE.previewExpandState.onBackdrop = onBackdrop;
4872 STATE.previewExpandState.onClose = onClose;
4873
4874 requestAnimationFrame(() => backdrop.classList.add('visible'));
4875 await animateRect(tileEl, startRect, targetRect);
4876
4877 tileEl.style.left = `${targetRect.left}px`;
4878 tileEl.style.top = `${targetRect.top}px`;
4879 tileEl.style.width = `${targetRect.width}px`;
4880 tileEl.style.height = `${targetRect.height}px`;
4881
4882 try
4883 {
4884 await loadPreviewContent(previewMount);
4885 } catch
4886 {
4887 if (previewMount.isConnected)
4888 {
4889 previewMount.innerHTML = '';
4890 const msg = document.createElement('p');
4891 msg.className = 'preview-unsupported';
4892 msg.textContent = 'Preview failed to load. You can try again.';
4893 previewMount.appendChild(msg);
4894 }
4895 }
4896
4897 return true;
4898}
4899
4900async function closeExpandedTilePreview ()
4901{
4902 const st = STATE.previewExpandState;
4903 if (!st) return;
4904
4905 st.backdrop.classList.remove('visible');
4906 if (st.backdrop && st.onBackdrop) st.backdrop.removeEventListener('click', st.onBackdrop);
4907 if (st.closeBtn && st.onClose) st.closeBtn.removeEventListener('click', st.onClose);
4908
4909 const fromRect = st.tileEl.getBoundingClientRect();
4910 await animateRect(st.tileEl, fromRect, st.startRect, { duration: 220 });
4911
4912 st.tileEl.classList.remove('file-item--preview');
4913 st.tileEl.style.position = '';
4914 st.tileEl.style.left = '';
4915 st.tileEl.style.top = '';
4916 st.tileEl.style.width = '';
4917 st.tileEl.style.height = '';
4918 st.tileEl.style.margin = '';
4919 st.tileEl.style.zIndex = '';
4920
4921 if (st.titleEl) st.titleEl.remove();
4922 if (st.closeBtn) st.closeBtn.remove();
4923 if (st.actionsEl) st.actionsEl.remove();
4924 if (st.iconEl) st.iconEl.innerHTML = st.iconHtml;
4925 if (st.nameEl) st.nameEl.style.display = '';
4926
4927 if (st.placeholder && st.placeholder.parentNode)
4928 {
4929 st.placeholder.parentNode.insertBefore(st.tileEl, st.placeholder);
4930 st.placeholder.remove();
4931 } else if (st.parent)
4932 {
4933 if (st.nextSibling && st.nextSibling.parentNode === st.parent)
4934 {
4935 st.parent.insertBefore(st.tileEl, st.nextSibling);
4936 } else
4937 {
4938 st.parent.appendChild(st.tileEl);
4939 }
4940 }
4941
4942 if (st.backdrop) st.backdrop.remove();
4943 STATE.previewExpandState = null;
4944}
4945
4946async function closePreview (opts = {})
4947{
4948 if (STATE.previewClosing) return;
4949 if (STATE.previewExpandState)
4950 {
4951 if (STATE.previewExpandState.requireExplicitClose && !opts.force)
4952 {
4953 return;
4954 }
4955
4956 STATE.previewClosing = true;
4957 clearPreviewObjectUrl();
4958 try
4959 {
4960 await closeExpandedTilePreview();
4961 STATE.previewSourceEl = null;
4962 } finally
4963 {
4964 STATE.previewClosing = false;
4965 }
4966 }
4967}
4968
4969async function fetchFileBlob (item)
4970{
4971 const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
4972 try
4973 {
4974 const res = await fetch(url, {
4975 headers: {
4976 Authorization: 'Bearer ' + STATE.token,
4977 'X-Fp': getFingerprint(),
4978 },
4979 });
4980 if (!res.ok) throw new Error('Download failed.');
4981 return await res.blob();
4982 } catch
4983 {
4984 return null;
4985 }
4986}
4987
4988function triggerDownload (filename, objectUrl)
4989{
4990 const a = document.createElement('a');
4991 a.href = objectUrl;
4992 a.download = filename;
4993 a.click();
4994}
4995
4996function modelPreviewType (name)
4997{
4998 const ext = extOf(name || '');
4999 if (MODEL_EXTS.has(ext)) return ext;
5000 return null;
5001}
5002
5003async function loadThreePreviewModules ()
5004{
5005 if (!threePreviewModulesPromise)
5006 {
5007 threePreviewModulesPromise = Promise.all([
5008 import('/vendor/three/three.module.js'),
5009 import('/vendor/three/addons/controls/OrbitControls.js'),
5010 import('/vendor/three/addons/loaders/STLLoader.js'),
5011 import('/vendor/three/addons/loaders/OBJLoader.js'),
5012 ]).then(([THREE, controlsMod, stlMod, objMod]) =>
5013 {
5014 return {
5015 THREE,
5016 OrbitControls: controlsMod.OrbitControls,
5017 STLLoader: stlMod.STLLoader,
5018 OBJLoader: objMod.OBJLoader,
5019 };
5020 });
5021 }
5022
5023 return threePreviewModulesPromise;
5024}
5025
5026function disposeObject3D (root)
5027{
5028 if (!root || typeof root.traverse !== 'function') return;
5029 root.traverse((node) =>
5030 {
5031 if (node.geometry && typeof node.geometry.dispose === 'function')
5032 {
5033 node.geometry.dispose();
5034 }
5035
5036 if (!node.material) return;
5037 if (Array.isArray(node.material))
5038 {
5039 node.material.forEach((material) =>
5040 {
5041 if (material && typeof material.dispose === 'function') material.dispose();
5042 });
5043 return;
5044 }
5045
5046 if (typeof node.material.dispose === 'function') node.material.dispose();
5047 });
5048}
5049
5050async function buildModelObjectFromBlob (blob, type, modules)
5051{
5052 const { THREE, STLLoader, OBJLoader } = modules;
5053 const sharedMaterial = new THREE.MeshStandardMaterial({
5054 color: 0x2f6dff,
5055 metalness: 0.08,
5056 roughness: 0.72,
5057 });
5058
5059 if (type === 'stl')
5060 {
5061 const arr = await blob.arrayBuffer();
5062 const geometry = new STLLoader().parse(arr);
5063 geometry.computeVertexNormals();
5064 return new THREE.Mesh(geometry, sharedMaterial);
5065 }
5066
5067 if (type === 'obj')
5068 {
5069 const text = await blob.text();
5070 const obj = new OBJLoader().parse(text);
5071 obj.traverse((node) =>
5072 {
5073 if (!node || !node.isMesh) return;
5074 node.material = sharedMaterial.clone();
5075 });
5076 sharedMaterial.dispose();
5077 return obj;
5078 }
5079
5080 throw new Error('Unsupported 3D model format.');
5081}
5082
5083function setModelPreviewMessage (wrap, text)
5084{
5085 wrap.innerHTML = '';
5086 const msg = document.createElement('p');
5087 msg.className = 'preview-unsupported';
5088 msg.textContent = text;
5089 wrap.appendChild(msg);
5090}
5091
5092async function renderModelPreview (item, blob, targetEl)
5093{
5094 const type = modelPreviewType(item && item.name);
5095 if (!type)
5096 {
5097 const msg = document.createElement('p');
5098 msg.className = 'preview-unsupported';
5099 msg.textContent = 'This 3D file type is not supported yet.';
5100 targetEl.appendChild(msg);
5101 return;
5102 }
5103
5104 const wrap = document.createElement('div');
5105 wrap.className = 'preview-model-wrap';
5106 targetEl.appendChild(wrap);
5107
5108 const canvas = document.createElement('canvas');
5109 canvas.className = 'preview-model-canvas';
5110 canvas.style.touchAction = 'none';
5111 wrap.appendChild(canvas);
5112
5113 const hint = document.createElement('p');
5114 hint.className = 'preview-model-hint';
5115 hint.textContent = 'Drag to rotate. Use the scroll wheel to zoom.';
5116 wrap.appendChild(hint);
5117
5118 const gl =
5119 canvas.getContext('webgl2', { antialias: true, alpha: true }) ||
5120 canvas.getContext('webgl', { antialias: true, alpha: true });
5121 if (!gl)
5122 {
5123 setModelPreviewMessage(wrap, '3D preview is not available in this browser. You can still download this file.');
5124 return;
5125 }
5126
5127 let modules;
5128 try
5129 {
5130 modules = await loadThreePreviewModules();
5131 } catch
5132 {
5133 setModelPreviewMessage(wrap, '3D preview dependencies failed to load. You can still download this file.');
5134 return;
5135 }
5136
5137 if (!wrap.isConnected) return;
5138
5139 const { THREE, OrbitControls } = modules;
5140 const scene = new THREE.Scene();
5141 scene.background = new THREE.Color(0x0d111a);
5142
5143 const camera = new THREE.PerspectiveCamera(50, 1, 0.01, 5000);
5144 const renderer = new THREE.WebGLRenderer({ canvas, context: gl, antialias: true, alpha: true });
5145 renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
5146
5147 const ambient = new THREE.AmbientLight(0xffffff, 0.9);
5148 const key = new THREE.DirectionalLight(0xffffff, 0.95);
5149 key.position.set(1.2, 1.6, 1.1);
5150 scene.add(ambient);
5151 scene.add(key);
5152
5153 let modelRoot;
5154 try
5155 {
5156 modelRoot = await buildModelObjectFromBlob(blob, type, modules);
5157 } catch
5158 {
5159 renderer.dispose();
5160 setModelPreviewMessage(wrap, 'This 3D file could not be parsed. You can still download it.');
5161 return;
5162 }
5163
5164 if (!wrap.isConnected)
5165 {
5166 disposeObject3D(modelRoot);
5167 renderer.dispose();
5168 return;
5169 }
5170
5171 scene.add(modelRoot);
5172
5173 const box = new THREE.Box3().setFromObject(modelRoot);
5174 if (box.isEmpty())
5175 {
5176 disposeObject3D(modelRoot);
5177 renderer.dispose();
5178 setModelPreviewMessage(wrap, 'This 3D file has no visible geometry to preview.');
5179 return;
5180 }
5181
5182 const size = new THREE.Vector3();
5183 const center = new THREE.Vector3();
5184 box.getSize(size);
5185 box.getCenter(center);
5186 modelRoot.position.sub(center);
5187
5188 const maxDim = Math.max(size.x, size.y, size.z) || 1;
5189 const camDistance = maxDim * 1.8;
5190 camera.position.set(camDistance, camDistance * 0.75, camDistance);
5191 camera.near = Math.max(0.001, maxDim / 2000);
5192 camera.far = Math.max(1000, maxDim * 2000);
5193 camera.updateProjectionMatrix();
5194
5195 const controls = new OrbitControls(camera, renderer.domElement);
5196 controls.enableDamping = true;
5197 controls.dampingFactor = 0.08;
5198 controls.target.set(0, 0, 0);
5199 controls.minDistance = maxDim * 0.2;
5200 controls.maxDistance = maxDim * 25;
5201 controls.update();
5202
5203 const resize = () =>
5204 {
5205 const w = Math.max(160, Math.floor(wrap.clientWidth || 0));
5206 const h = Math.max(160, Math.floor((wrap.clientHeight || 0) - (hint.offsetHeight || 0) - 6));
5207 renderer.setSize(w, h, false);
5208 camera.aspect = w / h;
5209 camera.updateProjectionMatrix();
5210 };
5211 resize();
5212
5213 let stop = false;
5214 let rafId = 0;
5215 const frame = () =>
5216 {
5217 if (stop) return;
5218 controls.update();
5219 renderer.render(scene, camera);
5220 rafId = requestAnimationFrame(frame);
5221 };
5222 frame();
5223
5224 const resizeObserver = typeof ResizeObserver === 'function'
5225 ? new ResizeObserver(() => resize())
5226 : null;
5227 if (resizeObserver) resizeObserver.observe(wrap);
5228
5229 STATE.previewCleanup = () =>
5230 {
5231 stop = true;
5232 if (rafId) cancelAnimationFrame(rafId);
5233 if (resizeObserver) resizeObserver.disconnect();
5234 try { controls.dispose(); } catch { /* ignore */ }
5235 try { disposeObject3D(modelRoot); } catch { /* ignore */ }
5236 try { renderer.dispose(); } catch { /* ignore */ }
5237 };
5238}
5239
5240async function renderPreviewBody (item, blob, objectUrl, targetEl = null)
5241{
5242 const body = targetEl || document.getElementById('preview-body');
5243 body.innerHTML = '';
5244
5245 const mime = String(blob.type || '').toLowerCase();
5246 const previewable = isInlinePreviewableBlob(blob, item.name);
5247
5248 if (!previewable)
5249 {
5250 const msg = document.createElement('p');
5251 msg.className = 'preview-unsupported';
5252 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
5253 body.appendChild(msg);
5254 return;
5255 }
5256
5257 if (/^image\//.test(mime) || IMAGE_EXTS.has(extOf(item.name)))
5258 {
5259 const img = document.createElement('img');
5260 img.className = 'preview-media';
5261 img.src = objectUrl;
5262 img.alt = item.name;
5263 body.appendChild(img);
5264 return;
5265 }
5266
5267 if (/^video\//.test(mime) || VIDEO_EXTS.has(extOf(item.name)))
5268 {
5269 const video = document.createElement('video');
5270 video.className = 'preview-media';
5271 video.src = objectUrl;
5272 video.controls = true;
5273 video.preload = 'metadata';
5274 body.appendChild(video);
5275 return;
5276 }
5277
5278 if (/^audio\//.test(mime) || AUDIO_EXTS.has(extOf(item.name)))
5279 {
5280 const audio = document.createElement('audio');
5281 audio.className = 'preview-audio';
5282 audio.src = objectUrl;
5283 audio.controls = true;
5284 body.appendChild(audio);
5285 return;
5286 }
5287
5288 if (modelPreviewType(item.name))
5289 {
5290 await renderModelPreview(item, blob, body);
5291 return;
5292 }
5293
5294 if (mime === 'application/pdf')
5295 {
5296 const frame = document.createElement('iframe');
5297 frame.className = 'preview-frame';
5298 frame.src = objectUrl;
5299 frame.title = item.name;
5300 body.appendChild(frame);
5301 return;
5302 }
5303
5304 if (isTextLikeBlob(blob, item.name))
5305 {
5306 const text = await blob.text();
5307 const lang = detectCodeLanguage(item.name, mime);
5308 const formatted = prettyPrintCode(text, lang);
5309 const pre = document.createElement('pre');
5310 pre.className = 'preview-text preview-code';
5311 pre.innerHTML = highlightCode(formatted, lang);
5312 body.appendChild(pre);
5313 return;
5314 }
5315
5316 const msg = document.createElement('p');
5317 msg.className = 'preview-unsupported';
5318 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
5319 body.appendChild(msg);
5320}
5321
5322async function downloadOrView (item, sourceSvgEl = null)
5323{
5324 if (STATE.previewExpandState)
5325 {
5326 await closePreview({ force: true });
5327 }
5328
5329 const sourceTileEl = sourceSvgEl ? sourceSvgEl.closest('.file-item') : null;
5330 if (sourceTileEl)
5331 {
5332 STATE.previewSourceEl = sourceSvgEl;
5333 const expanded = await openExpandedTilePreview(item, sourceTileEl, sourceSvgEl, async (previewMount) =>
5334 {
5335 if (VIDEO_EXTS.has(extOf(item.name)))
5336 {
5337 clearPreviewObjectUrl();
5338 previewMount.innerHTML = '';
5339 await renderStreamedVideoPreview(item, previewMount);
5340 return;
5341 }
5342
5343 const blob = await fetchFileBlob(item);
5344 if (!blob) throw new Error('Download failed');
5345
5346 clearPreviewObjectUrl();
5347 const objectUrl = URL.createObjectURL(blob);
5348 STATE.previewObjectUrl = objectUrl;
5349
5350 if (!previewMount.isConnected) return;
5351
5352 previewMount.innerHTML = '';
5353 await renderPreviewBody(item, blob, objectUrl, previewMount);
5354 });
5355 if (expanded) return;
5356 }
5357
5358 toast('Preview unavailable — no source tile found.', 'err');
5359}
5360
5361// ───────────────────────────────────────────────────────────────────────────
5362// UPLOAD
5363// ───────────────────────────────────────────────────────────────────────────
5364
5365async function createFolderInCurrentDir ()
5366{
5367 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5368 if (!canWrite()) { toast('No write access.', 'err'); return; }
5369
5370 const name = await showPrompt('New Folder', 'Enter a name for the new folder:');
5371 if (name == null) return;
5372 const folderName = name.trim();
5373 if (!folderName)
5374 {
5375 toast('Folder name is required.', 'err');
5376 return;
5377 }
5378
5379 try
5380 {
5381 await api('POST', '/files/mkdir', { dir: STATE.currentDir, name: folderName });
5382 toast('Folder created.', 'ok');
5383 await navigateTo(STATE.currentDir, STATE.currentRoot);
5384 } catch (err)
5385 {
5386 toast(err.message, 'err');
5387 }
5388}
5389
5390function canWrite (item = null)
5391{
5392 if (STATE.isAdmin) return true;
5393 const root = item && item._root
5394 ? item._root
5395 : (STATE.currentRoot || (item ? resolveRootForPath(item.path) : null));
5396 if (!root) return false;
5397 if (root.isUserFolder) return true;
5398 const p = STATE.permissions[rootPermissionLabel(root)];
5399 return p && p.write;
5400}
5401
5402async function uploadFiles (fileList)
5403{
5404 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5405 if (!canWrite()) { toast('No write access.', 'err'); return; }
5406
5407 const files = Array.from(fileList || []);
5408 if (!files.length) return;
5409
5410 // Show upload bar
5411 const wrap = document.createElement('div');
5412 wrap.className = 'upload-bar-wrap';
5413 wrap.innerHTML = `<span>Preparing upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
5414 document.body.appendChild(wrap);
5415 STATE.uploadInProgress = true;
5416
5417 try
5418 {
5419 const existingNames = await listDirNameSet(STATE.currentDir);
5420 let done = 0;
5421 let uploaded = 0;
5422
5423 for (const original of files)
5424 {
5425 let fileToUpload = original;
5426
5427 if (existingNames.has(original.name))
5428 {
5429 const suggested = nextAvailableName(original.name, existingNames);
5430 const decision = await showFileConflictChoice(original.name, suggested, 'upload');
5431 if (decision === 'cancel')
5432 {
5433 done++;
5434 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
5435 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
5436 continue;
5437 }
5438
5439 if (decision === 'rename')
5440 {
5441 fileToUpload = cloneFileWithName(original, suggested);
5442 }
5443 }
5444
5445 await uploadSingleFile(fileToUpload, STATE.currentDir);
5446 existingNames.add(fileToUpload.name);
5447 done++;
5448 uploaded++;
5449 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
5450 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
5451 }
5452
5453 toast(`Uploaded ${uploaded} file(s).`, 'ok');
5454 await navigateTo(STATE.currentDir, STATE.currentRoot);
5455 } catch (err)
5456 {
5457 toast(err.message, 'err');
5458 } finally
5459 {
5460 STATE.uploadInProgress = false;
5461 wrap.remove();
5462 }
5463}
5464
5465async function uploadSingleFile (file, targetDir)
5466{
5467 const formData = new FormData();
5468 formData.append('files', file);
5469
5470 await new Promise((resolve, reject) =>
5471 {
5472 const xhr = new XMLHttpRequest();
5473 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
5474 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
5475 xhr.setRequestHeader('X-Fp', getFingerprint());
5476 xhr.setRequestHeader('X-Upload-Size', String(file.size || 0));
5477 xhr.onload = () => xhr.status === 200
5478 ? resolve()
5479 : reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
5480 xhr.onerror = () => reject(new Error('Network error'));
5481 xhr.send(formData);
5482 });
5483}
5484
5485async function ensureServerDir (baseDir, relativeDir)
5486{
5487 const parts = String(relativeDir || '').split(/[\\/]/).filter(Boolean);
5488 let current = baseDir;
5489 for (const part of parts)
5490 {
5491 try
5492 {
5493 const resp = await api('POST', '/files/mkdir', { dir: current, name: part });
5494 current = resp && resp.path ? resp.path : joinServerPath(current, part);
5495 } catch (err)
5496 {
5497 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
5498 current = joinServerPath(current, part);
5499 }
5500 }
5501 return current;
5502}
5503
5504async function uploadFolderInputFiles (fileList)
5505{
5506 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5507 if (!canWrite()) { toast('No write access.', 'err'); return; }
5508 if (!fileList || !fileList.length) return;
5509
5510 const files = Array.from(fileList);
5511 const total = files.length;
5512 let done = 0;
5513
5514 const wrap = document.createElement('div');
5515 wrap.className = 'upload-bar-wrap';
5516 wrap.innerHTML = `<span>Preparing folder upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
5517 document.body.appendChild(wrap);
5518 STATE.uploadInProgress = true;
5519
5520 try
5521 {
5522 const dirCache = new Map();
5523 dirCache.set('', STATE.currentDir);
5524
5525 for (const file of files)
5526 {
5527 const rel = file.webkitRelativePath || file.name;
5528 const relParts = rel.split(/[\\/]/).filter(Boolean);
5529 const relDir = relParts.slice(0, -1).join('/');
5530
5531 if (!dirCache.has(relDir))
5532 {
5533 const parentRel = relParts.slice(0, -2).join('/');
5534 const parentAbs = dirCache.get(parentRel) || await ensureServerDir(STATE.currentDir, parentRel);
5535 const thisName = relParts[relParts.length - 2];
5536
5537 try
5538 {
5539 const created = await api('POST', '/files/mkdir', { dir: parentAbs, name: thisName });
5540 dirCache.set(relDir, created.path || joinServerPath(parentAbs, thisName));
5541 } catch (err)
5542 {
5543 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
5544 dirCache.set(relDir, joinServerPath(parentAbs, thisName));
5545 }
5546 }
5547
5548 const targetDir = dirCache.get(relDir) || STATE.currentDir;
5549 await uploadSingleFile(file, targetDir);
5550 done++;
5551 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
5552 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
5553 }
5554
5555 toast(`Uploaded ${total} file(s).`, 'ok');
5556 await navigateTo(STATE.currentDir, STATE.currentRoot);
5557 } catch (err)
5558 {
5559 toast(err.message, 'err');
5560 } finally
5561 {
5562 STATE.uploadInProgress = false;
5563 wrap.remove();
5564 }
5565}
5566
5567// ───────────────────────────────────────────────────────────────────────────
5568// FOLDER DRAG-AND-DROP (recursive)
5569// ───────────────────────────────────────────────────────────────────────────
5570
5571/**
5572 * Reads all readEntries batches from a DirectoryReader (browsers may return
5573 * results in chunks; we must keep calling until we get an empty array).
5574 */
5575function readAllEntries (reader)
5576{
5577 return new Promise((resolve, reject) =>
5578 {
5579 const all = [];
5580 function next ()
5581 {
5582 reader.readEntries(batch =>
5583 {
5584 if (!batch.length) { resolve(all); return; }
5585 all.push(...batch);
5586 next();
5587 }, reject);
5588 }
5589 next();
5590 });
5591}
5592
5593/**
5594 * Recursively walk a FileSystemEntry tree, creating server-side directories
5595 * on the fly and collecting { file, targetDir } pairs for upload.
5596 */
5597async function collectEntries (entry, serverDir, toUpload)
5598{
5599 if (entry.isFile)
5600 {
5601 const file = await new Promise((res, rej) => entry.file(res, rej));
5602 toUpload.push({ file, targetDir: serverDir });
5603 } else if (entry.isDirectory)
5604 {
5605 // Ask the server to create the directory; it returns the canonical path.
5606 let newServerDir;
5607 try
5608 {
5609 const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
5610 newServerDir = resp.path;
5611 } catch
5612 {
5613 // Directory may already exist — reconstruct path from what we know.
5614 // The server always returns JSON with {error} on failure, so we can
5615 // still continue by falling back to a best-effort path join.
5616 // We rely on the fact that the server separator is consistent within
5617 // a session (the list/browse API already returned paths in that format).
5618 const sep = serverDir.includes('\\') ? '\\' : '/';
5619 newServerDir = serverDir + sep + entry.name;
5620 }
5621 const reader = entry.createReader();
5622 const subEntries = await readAllEntries(reader);
5623 for (const sub of subEntries)
5624 {
5625 await collectEntries(sub, newServerDir, toUpload);
5626 }
5627 }
5628}
5629
5630async function uploadEntries (entries)
5631{
5632 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
5633 if (!canWrite()) { toast('No write access.', 'err'); return; }
5634
5635 const wrap = document.createElement('div');
5636 wrap.className = 'upload-bar-wrap';
5637 wrap.innerHTML = `<span>Scanning…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
5638 document.body.appendChild(wrap);
5639 STATE.uploadInProgress = true;
5640
5641 try
5642 {
5643 const toUpload = [];
5644 for (const entry of entries)
5645 {
5646 await collectEntries(entry, STATE.currentDir, toUpload);
5647 }
5648
5649 if (!toUpload.length) { toast('No files found.', 'err'); return; }
5650
5651 let done = 0;
5652 const total = toUpload.length;
5653 const updateBar = () =>
5654 {
5655 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
5656 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
5657 };
5658 updateBar();
5659
5660 for (const { file, targetDir } of toUpload)
5661 {
5662 await uploadSingleFile(file, targetDir);
5663 done++;
5664 updateBar();
5665 }
5666
5667 toast(`Uploaded ${total} file(s).`, 'ok');
5668 await navigateTo(STATE.currentDir, STATE.currentRoot);
5669 } catch (err)
5670 {
5671 toast(err.message, 'err');
5672 } finally
5673 {
5674 STATE.uploadInProgress = false;
5675 wrap.remove();
5676 }
5677}
5678
5679// DRAG-AND-DROP
5680// ───────────────────────────────────────────────────────────────────────────
5681
5682function initDragDrop ()
5683{
5684 const main = document.getElementById('main-content');
5685 const dropOvl = document.getElementById('drop-overlay');
5686 let dragDepth = 0;
5687
5688 main.addEventListener('dragenter', e =>
5689 {
5690 e.preventDefault();
5691 dragDepth++;
5692 dropOvl.classList.remove('hidden');
5693 });
5694 main.addEventListener('dragleave', () =>
5695 {
5696 dragDepth--;
5697 if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
5698 });
5699 main.addEventListener('dragover', e => e.preventDefault());
5700 main.addEventListener('drop', async e =>
5701 {
5702 e.preventDefault();
5703 dragDepth = 0;
5704 dropOvl.classList.add('hidden');
5705 if (!canWrite()) { toast('No write access.', 'err'); return; }
5706
5707 const items = Array.from(e.dataTransfer.items || []);
5708 // Use the FileSystem Entry API when available so we can handle folders.
5709 if (items.length && typeof items[0].webkitGetAsEntry === 'function')
5710 {
5711 const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
5712 if (entries.some(en => en.isDirectory))
5713 {
5714 await uploadEntries(entries);
5715 return;
5716 }
5717 }
5718 // Plain files only — use the fast batch path.
5719 const files = e.dataTransfer.files;
5720 if (files.length) await uploadFiles(files);
5721 });
5722}
5723
5724// ───────────────────────────────────────────────────────────────────────────
5725// RENAME
5726// ───────────────────────────────────────────────────────────────────────────
5727
5728function openRenameModal (item)
5729{
5730 const modal = document.getElementById('rename-modal');
5731 modal.classList.remove('hidden');
5732 const input = document.getElementById('rename-input');
5733 input.value = item.name;
5734 input.focus();
5735 input.select();
5736 document.getElementById('rename-error').classList.add('hidden');
5737 document.getElementById('rename-form').onsubmit = async (e) =>
5738 {
5739 e.preventDefault();
5740 const newName = input.value.trim();
5741 if (!newName) return;
5742 try
5743 {
5744 if (item._root)
5745 {
5746 await api('POST', '/files/root-alias', { rootPath: item.path, alias: newName });
5747 } else
5748 {
5749 await api('POST', '/files/rename', { from: item.path, to: newName });
5750 }
5751 modal.classList.add('hidden');
5752 toast(item._root ? 'Alias updated.' : 'Renamed.', 'ok');
5753 if (item._root)
5754 {
5755 await loadRoots({
5756 preferredDir: STATE.currentDir,
5757 preferredRootPath: (STATE.currentRoot && STATE.currentRoot.path) || item.path,
5758 });
5759 } else
5760 {
5761 await navigateTo(STATE.currentDir, STATE.currentRoot);
5762 }
5763 } catch (err)
5764 {
5765 document.getElementById('rename-error').textContent = err.message;
5766 document.getElementById('rename-error').classList.remove('hidden');
5767 }
5768 };
5769}
5770
5771// ───────────────────────────────────────────────────────────────────────────
5772// DELETE
5773// ───────────────────────────────────────────────────────────────────────────
5774
5775async function deleteItem (item)
5776{
5777 if (!await showConfirm('Delete item', `Delete "${item.name}"? This cannot be undone.`)) return;
5778 try
5779 {
5780 await api('POST', '/files/delete', { path: item.path });
5781 toast('Deleted.', 'ok');
5782 closeSidebar();
5783 await navigateTo(STATE.currentDir, STATE.currentRoot);
5784 } catch (err)
5785 {
5786 toast(err.message, 'err');
5787 }
5788}
5789
5790// ───────────────────────────────────────────────────────────────────────────
5791// ADMIN PANEL
5792// ───────────────────────────────────────────────────────────────────────────
5793
5794let _adminUpdateStatus = null;
5795let _debugRefreshTimer = null;
5796let _debugLatestData = null;
5797
5798function formatTimestamp (ms)
5799{
5800 const value = Number(ms || 0);
5801 if (!Number.isFinite(value) || value <= 0) return '—';
5802 try
5803 {
5804 return new Date(value).toLocaleString();
5805 } catch
5806 {
5807 return '—';
5808 }
5809}
5810
5811function renderDebugTable (containerId, columns, rows)
5812{
5813 const container = document.getElementById(containerId);
5814 if (!container) return;
5815
5816 if (!Array.isArray(rows) || rows.length === 0)
5817 {
5818 container.innerHTML = '<div class="muted" style="padding:0.7rem">No data.</div>';
5819 return;
5820 }
5821
5822 const headHtml = columns.map((col) => `<th>${escapeHtml(col.label)}</th>`).join('');
5823 const bodyHtml = rows.map((row) =>
5824 `<tr>${columns.map((col) => `<td>${col.render(row)}</td>`).join('')}</tr>`).join('');
5825
5826 container.innerHTML = `<table class="debug-table"><thead><tr>${headHtml}</tr></thead><tbody>${bodyHtml}</tbody></table>`;
5827}
5828
5829function renderDebugDashboardData (data)
5830{
5831 _debugLatestData = data;
5832
5833 const generatedAt = document.getElementById('debug-generated-at');
5834 if (generatedAt) generatedAt.textContent = `Last update: ${formatTimestamp(data.generatedAt)}`;
5835
5836 const usersEl = document.getElementById('debug-users');
5837 if (usersEl)
5838 {
5839 const users = Array.isArray(data.loggedInUsers) ? data.loggedInUsers : [];
5840 usersEl.innerHTML = users.length
5841 ? users.map((user) => `<span class="debug-chip">${escapeHtml(user.username || 'Unknown')} · ${escapeHtml(formatTimestamp(user.lastSeenAt))}</span>`).join('')
5842 : '<span class="muted">No active sessions.</span>';
5843 }
5844
5845 const summary = document.getElementById('debug-storage-summary');
5846 if (summary)
5847 {
5848 const storage = data.storage || {};
5849 const memory = data.memory || {};
5850 const roots = Array.isArray(storage.roots) ? storage.roots.length : 0;
5851 const activeStreams = Number(data.videoStream && data.videoStream.activeSessionCount) || 0;
5852 const activeLeases = Number(data.videoStream && data.videoStream.activeLeaseCount) || 0;
5853 const segmentRetention = Number(data.videoStream && data.videoStream.streamSegmentRetentionCount) || 0;
5854 summary.innerHTML = [
5855 ['Configured roots', String(roots)],
5856 ['Total used', formatBytes(storage.totalBytes || 0)],
5857 ['Total files', String(storage.totalFiles || 0)],
5858 ['RAM used', `${formatBytes(memory.usedBytes || 0)} / ${formatBytes(memory.totalBytes || 0)} (${Number(memory.usedPercent || 0).toFixed(1)}%)`],
5859 ['Process RSS', formatBytes(memory.processRssBytes || 0)],
5860 ['Active streams', String(activeStreams)],
5861 ['Active viewers', String(activeLeases)],
5862 ['Segment retention', String(segmentRetention)],
5863 ].map(([k, v]) => `<div class="debug-summary-item"><span class="k">${escapeHtml(k)}</span><span class="v">${escapeHtml(v)}</span></div>`).join('');
5864 }
5865
5866 renderDebugTable(
5867 'debug-roots',
5868 [
5869 { label: 'Root', render: (row) => `<span class="debug-path">${escapeHtml(row.path || '')}</span>` },
5870 { label: 'Exists', render: (row) => row.exists ? 'Yes' : 'No' },
5871 { label: 'Used', render: (row) => escapeHtml(formatBytes(row.bytes || 0)) },
5872 { label: 'Files', render: (row) => escapeHtml(String(row.files || 0)) },
5873 { label: 'Folders', render: (row) => escapeHtml(String(row.directories || 0)) },
5874 ],
5875 Array.isArray(data.storage && data.storage.roots) ? data.storage.roots : [],
5876 );
5877
5878 renderDebugTable(
5879 'debug-video-files',
5880 [
5881 { label: 'Video file', render: (row) => `<span class="debug-path">${escapeHtml(row.filePath || '')}</span>` },
5882 { label: 'Viewers', render: (row) => escapeHtml(String(row.viewers || 0)) },
5883 { label: 'Segments', render: (row) => escapeHtml(String(row.stream && row.stream.output ? row.stream.output.segmentFiles : 0)) },
5884 { label: 'Segment bytes', render: (row) => escapeHtml(formatBytes(row.stream && row.stream.output ? row.stream.output.segmentBytes : 0)) },
5885 { label: 'Event cache', render: (row) => escapeHtml(String(row.subtitleCache ? row.subtitleCache.eventEntries : 0)) },
5886 { label: 'Event bytes', render: (row) => escapeHtml(formatBytes(row.subtitleCache ? row.subtitleCache.eventBytes : 0)) },
5887 { label: 'Event PNG bytes', render: (row) => escapeHtml(formatBytes(row.subtitleCache ? row.subtitleCache.eventImageBytes : 0)) },
5888 { label: 'Frame cache', render: (row) => escapeHtml(String(row.subtitleCache ? row.subtitleCache.frameEntries : 0)) },
5889 { label: 'Frame bytes', render: (row) => escapeHtml(formatBytes(row.subtitleCache ? row.subtitleCache.frameBytes : 0)) },
5890 { label: 'Retention', render: (row) => escapeHtml(String(row.stream ? row.stream.segmentRetentionCount : 0)) },
5891 { label: 'Slowest seg', render: (row) => { const v = row.stream ? row.stream.slowestViewerSegmentIndex : -1; return escapeHtml(v === -1 ? '\u2014' : String(v)); } },
5892 { label: 'Pruned until', render: (row) => escapeHtml(String(row.stream ? row.stream.segmentPrunedUntil : 0)) },
5893 { label: 'Session ID', render: (row) => escapeHtml((row.activeSessionIds || []).join(', ') || '—') },
5894 ],
5895 Array.isArray(data.videoFiles) ? data.videoFiles : [],
5896 );
5897
5898 renderDebugTable(
5899 'debug-orphaned-streams',
5900 [
5901 { label: 'Output directory', render: (row) => `<span class="debug-path">${escapeHtml(row.outputDir || '')}</span>` },
5902 { label: 'Files', render: (row) => escapeHtml(String(row.output && row.output.totalFiles || 0)) },
5903 { label: 'Bytes', render: (row) => escapeHtml(formatBytes(row.output && row.output.totalBytes || 0)) },
5904 { label: 'Segments', render: (row) => escapeHtml(String(row.output && row.output.segmentFiles || 0)) },
5905 ],
5906 Array.isArray(data.videoStream && data.videoStream.orphanedOutputDirs) ? data.videoStream.orphanedOutputDirs : [],
5907 );
5908}
5909
5910function csvEscape (value)
5911{
5912 const raw = String(value == null ? '' : value);
5913 if (/[,"\n\r]/.test(raw)) return `"${raw.replace(/"/g, '""')}"`;
5914 return raw;
5915}
5916
5917function toCsv (rows, columns)
5918{
5919 const header = columns.join(',');
5920 const body = rows.map((row) => columns.map((col) => csvEscape(row[col])).join(',')).join('\n');
5921 return `${header}\n${body}`;
5922}
5923
5924async function copyDebugText (text, successMessage)
5925{
5926 const payload = String(text || '');
5927 if (!payload.trim())
5928 {
5929 toast('No debug data to copy yet.', 'err');
5930 return;
5931 }
5932
5933 try
5934 {
5935 await navigator.clipboard.writeText(payload);
5936 toast(successMessage, 'ok');
5937 } catch
5938 {
5939 toast('Could not copy to clipboard.', 'err');
5940 }
5941}
5942
5943function copyDebugUsersJson ()
5944{
5945 const users = Array.isArray(_debugLatestData && _debugLatestData.loggedInUsers)
5946 ? _debugLatestData.loggedInUsers
5947 : [];
5948 void copyDebugText(JSON.stringify(users, null, 2), 'Copied users JSON.');
5949}
5950
5951function copyDebugStorageJson ()
5952{
5953 const payload = {
5954 generatedAt: _debugLatestData && _debugLatestData.generatedAt,
5955 storage: _debugLatestData && _debugLatestData.storage,
5956 memory: _debugLatestData && _debugLatestData.memory,
5957 };
5958 void copyDebugText(JSON.stringify(payload, null, 2), 'Copied storage JSON.');
5959}
5960
5961function copyDebugVideoFilesCsv ()
5962{
5963 const files = Array.isArray(_debugLatestData && _debugLatestData.videoFiles)
5964 ? _debugLatestData.videoFiles
5965 : [];
5966
5967 const rows = files.map((row) => ({
5968 filePath: row.filePath || '',
5969 viewers: Number(row.viewers || 0),
5970 segmentFiles: Number(row.stream && row.stream.output ? row.stream.output.segmentFiles : 0),
5971 segmentBytes: Number(row.stream && row.stream.output ? row.stream.output.segmentBytes : 0),
5972 eventEntries: Number(row.subtitleCache ? row.subtitleCache.eventEntries : 0),
5973 eventBytes: Number(row.subtitleCache ? row.subtitleCache.eventBytes : 0),
5974 eventPngBytes: Number(row.subtitleCache ? row.subtitleCache.eventImageBytes : 0),
5975 frameEntries: Number(row.subtitleCache ? row.subtitleCache.frameEntries : 0),
5976 frameBytes: Number(row.subtitleCache ? row.subtitleCache.frameBytes : 0),
5977 segmentRetentionCount: Number(row.stream ? row.stream.segmentRetentionCount : 0),
5978 slowestViewerSegmentIndex: row.stream ? row.stream.slowestViewerSegmentIndex : -1,
5979 segmentPrunedUntil: Number(row.stream ? row.stream.segmentPrunedUntil : 0),
5980 sessionIds: Array.isArray(row.activeSessionIds) ? row.activeSessionIds.join(';') : '',
5981 }));
5982
5983 const csv = toCsv(rows, [
5984 'filePath',
5985 'viewers',
5986 'segmentFiles',
5987 'segmentBytes',
5988 'eventEntries',
5989 'eventBytes',
5990 'eventPngBytes',
5991 'frameEntries',
5992 'frameBytes',
5993 'segmentRetentionCount',
5994 'slowestViewerSegmentIndex',
5995 'segmentPrunedUntil',
5996 'sessionIds',
5997 ]);
5998 void copyDebugText(csv, 'Copied video/cache CSV.');
5999}
6000
6001function copyDebugOrphanedCsv ()
6002{
6003 const rowsRaw = Array.isArray(_debugLatestData && _debugLatestData.videoStream && _debugLatestData.videoStream.orphanedOutputDirs)
6004 ? _debugLatestData.videoStream.orphanedOutputDirs
6005 : [];
6006
6007 const rows = rowsRaw.map((row) => ({
6008 outputDir: row.outputDir || '',
6009 totalFiles: Number(row.output && row.output.totalFiles || 0),
6010 totalBytes: Number(row.output && row.output.totalBytes || 0),
6011 segmentFiles: Number(row.output && row.output.segmentFiles || 0),
6012 segmentBytes: Number(row.output && row.output.segmentBytes || 0),
6013 }));
6014
6015 const csv = toCsv(rows, ['outputDir', 'totalFiles', 'totalBytes', 'segmentFiles', 'segmentBytes']);
6016 void copyDebugText(csv, 'Copied orphaned output CSV.');
6017}
6018
6019async function refreshDebugDashboard ()
6020{
6021 const data = await api('GET', '/admin/debug/stream-stats');
6022 if (!data) return;
6023 renderDebugDashboardData(data);
6024}
6025
6026async function openDebugModal ()
6027{
6028 const modal = document.getElementById('debug-modal');
6029 if (!modal) return;
6030 modal.classList.remove('hidden');
6031 await refreshDebugDashboard();
6032
6033 if (_debugRefreshTimer) clearInterval(_debugRefreshTimer);
6034 _debugRefreshTimer = setInterval(() =>
6035 {
6036 void refreshDebugDashboard();
6037 }, 5000);
6038}
6039
6040function closeDebugModal ()
6041{
6042 const modal = document.getElementById('debug-modal');
6043 if (modal) modal.classList.add('hidden');
6044 if (_debugRefreshTimer)
6045 {
6046 clearInterval(_debugRefreshTimer);
6047 _debugRefreshTimer = null;
6048 }
6049}
6050
6051function animateBadgeToTarget (targetEl)
6052{
6053 const badge = document.getElementById('admin-update-badge');
6054 if (!badge || !targetEl) return;
6055 if (badge.parentElement === targetEl) return;
6056
6057 const from = badge.getBoundingClientRect();
6058 targetEl.appendChild(badge);
6059 const to = badge.getBoundingClientRect();
6060
6061 const dx = from.left - to.left;
6062 const dy = from.top - to.top;
6063
6064 badge.style.transition = 'none';
6065 badge.style.transform = `translate(${dx}px, ${dy}px)`;
6066 badge.style.willChange = 'transform';
6067
6068 requestAnimationFrame(() =>
6069 {
6070 badge.style.transition = 'transform 240ms cubic-bezier(0.22, 1, 0.36, 1)';
6071 badge.style.transform = 'translate(0, 0)';
6072 });
6073
6074 const cleanup = () =>
6075 {
6076 badge.style.transition = '';
6077 badge.style.transform = '';
6078 badge.style.willChange = '';
6079 badge.removeEventListener('transitionend', cleanup);
6080 };
6081 badge.addEventListener('transitionend', cleanup);
6082}
6083
6084function moveBadgeToTarget (targetEl)
6085{
6086 const badge = document.getElementById('admin-update-badge');
6087 if (!badge || !targetEl) return;
6088 if (badge.parentElement === targetEl) return;
6089
6090 badge.style.transition = '';
6091 badge.style.transform = '';
6092 badge.style.willChange = '';
6093 targetEl.appendChild(badge);
6094}
6095
6096function syncAdminUpdateBadgeAnchor ({ animate = true, forceUserAnchor = false } = {})
6097{
6098 const badge = document.getElementById('admin-update-badge');
6099 const userMenuBtn = document.getElementById('btn-user-menu');
6100 const adminBtn = document.getElementById('btn-admin');
6101 if (!badge || !userMenuBtn || !adminBtn) return;
6102
6103 const userDropdown = userMenuBtn.closest('.topbar-dropdown');
6104 const userMenuOpen = !!(userDropdown && userDropdown.classList.contains('open'));
6105 const target = forceUserAnchor ? userMenuBtn : (userMenuOpen ? adminBtn : userMenuBtn);
6106
6107 if (badge.classList.contains('hidden'))
6108 {
6109 moveBadgeToTarget(userMenuBtn);
6110 return;
6111 }
6112
6113 if (animate) animateBadgeToTarget(target);
6114 else moveBadgeToTarget(target);
6115}
6116
6117function setAdminUpdateBadge (count)
6118{
6119 const badge = document.getElementById('admin-update-badge');
6120 const userMenuBtn = document.getElementById('btn-user-menu');
6121 if (!badge || !userMenuBtn) return;
6122
6123 if (!STATE.isAdmin || !Number.isFinite(count) || count <= 0)
6124 {
6125 badge.classList.add('hidden');
6126 badge.textContent = '';
6127 if (badge.parentElement !== userMenuBtn) userMenuBtn.appendChild(badge);
6128 userMenuBtn.removeAttribute('data-update-count');
6129 return;
6130 }
6131
6132 const whole = Math.floor(count);
6133 const capped = Math.min(whole, 99);
6134 badge.textContent = capped >= 99 ? '99+' : String(capped);
6135 badge.classList.remove('hidden');
6136 userMenuBtn.dataset.updateCount = String(whole);
6137 syncAdminUpdateBadgeAnchor();
6138}
6139
6140function pulseAdminUpdateButton ()
6141{
6142 const btn = document.getElementById('admin-shutdown-btn');
6143 if (!btn) return;
6144
6145 if (typeof btn.scrollIntoView === 'function')
6146 {
6147 btn.scrollIntoView({ behavior: 'smooth', block: 'center' });
6148 }
6149
6150 btn.classList.remove('admin-update-highlight');
6151 // Force reflow so repeated openings can replay the pulse animation.
6152 void btn.offsetWidth;
6153 btn.classList.add('admin-update-highlight');
6154
6155 setTimeout(() =>
6156 {
6157 btn.classList.remove('admin-update-highlight');
6158 }, 1800);
6159}
6160
6161async function openAdminModal ()
6162{
6163 document.getElementById('admin-modal').classList.remove('hidden');
6164 await refreshGlobalFavicon();
6165 await refreshAdminConfig();
6166 await refreshAdminUsers();
6167 await refreshAdminUpdateStatus({ pulseIfUpdateAvailable: true });
6168}
6169
6170async function refreshAdminConfig ()
6171{
6172 const data = await api('GET', '/admin/config');
6173 if (!data) return;
6174
6175 const userPathInput = document.getElementById('admin-user-path');
6176 const sizeInput = document.getElementById('admin-user-size-limit');
6177 if (userPathInput) userPathInput.value = data.userPath || '';
6178 if (sizeInput)
6179 {
6180 sizeInput.value = data.userFolderSizeLimit ? formatBytes(data.userFolderSizeLimit) : '';
6181 updateAdminSizeFeedback(sizeInput.value);
6182 }
6183
6184 const container = document.getElementById('admin-paths');
6185 container.innerHTML = '';
6186 for (const p of data.paths)
6187 {
6188 const row = document.createElement('div');
6189 row.className = 'path-row';
6190 row.innerHTML = `<span>${p}</span><button data-path="${p}" title="Remove">✕</button>`;
6191 row.querySelector('button').addEventListener('click', () =>
6192 {
6193 row.remove();
6194 });
6195 container.appendChild(row);
6196 }
6197}
6198
6199async function refreshAdminUsers ()
6200{
6201 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
6202 const data = await api('GET', '/admin/users');
6203 if (!data) return;
6204 const container = document.getElementById('admin-users-list');
6205 if (!container) return;
6206 container.innerHTML = '';
6207
6208 // Need paths for permission rows
6209 const cfg = await api('GET', '/admin/config');
6210 const paths = cfg ? (cfg.effectivePaths || []) : [];
6211
6212 for (const u of data.users)
6213 {
6214 const row = document.createElement('div');
6215 row.className = 'user-row';
6216 row.innerHTML = `
6217 <span class="user-name">${u.username}</span>
6218 ${u.isAdmin ? '<span class="user-admin-badge">Admin</span>' : ''}
6219 <button data-id="${u.id}" data-action="edit">Edit</button>
6220 ${u.username === STATE.username ? '' : `<button data-id="${u.id}" data-action="delete" class="danger">Delete</button>`}
6221 `;
6222 row.querySelector('[data-action="edit"]').addEventListener('click', () =>
6223 openUserModal(u, paths));
6224 const deleteBtn = row.querySelector('[data-action="delete"]');
6225 if (deleteBtn) deleteBtn.addEventListener('click', async () =>
6226 {
6227 if (!await showConfirm('Delete user', `Delete user "${u.username}"? This cannot be undone.`)) return;
6228 try
6229 {
6230 await api('DELETE', `/admin/users/${u.id}`);
6231 toast('User deleted.', 'ok');
6232 await refreshAdminUsers();
6233 } catch (err) { toast(err.message, 'err'); }
6234 });
6235 container.appendChild(row);
6236 }
6237
6238 await refreshAdminOrphanUserFolders();
6239}
6240
6241async function refreshAdminOrphanUserFolders ()
6242{
6243 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
6244 const section = document.getElementById('admin-orphan-userfolders-section');
6245 const list = document.getElementById('admin-orphan-userfolders-list');
6246 if (!section || !list) return;
6247
6248 let data = null;
6249 try
6250 {
6251 data = await api('GET', '/admin/orphan-userfolders');
6252 } catch
6253 {
6254 section.classList.add('hidden');
6255 list.innerHTML = '';
6256 return;
6257 }
6258
6259 const folders = Array.isArray(data && data.folders) ? data.folders : [];
6260 if (!folders.length)
6261 {
6262 section.classList.add('hidden');
6263 list.innerHTML = '';
6264 return;
6265 }
6266
6267 section.classList.remove('hidden');
6268 list.innerHTML = '';
6269
6270 for (const folder of folders)
6271 {
6272 const row = document.createElement('div');
6273 row.className = 'user-row orphan-folder-row';
6274
6275 const name = document.createElement('span');
6276 name.className = 'user-name';
6277 name.textContent = folder.folderName || 'Unknown folder';
6278
6279 const info = document.createElement('span');
6280 info.className = 'orphan-folder-meta';
6281 const itemCount = Number(folder.itemCount) || 0;
6282 info.textContent = `${itemCount} item${itemCount === 1 ? '' : 's'}`;
6283
6284 const openBtn = document.createElement('button');
6285 openBtn.dataset.action = 'open-orphan-folder';
6286 openBtn.textContent = 'Open folder';
6287 openBtn.addEventListener('click', async () =>
6288 {
6289 const targetPath = String(folder.path || '').trim();
6290 if (!targetPath) return;
6291
6292 try
6293 {
6294 const syntheticRoot = {
6295 label: name.textContent,
6296 originalName: name.textContent,
6297 alias: null,
6298 path: targetPath,
6299 isUserFolder: true,
6300 isOrphanUserFolder: true,
6301 };
6302 await navigateTo(targetPath, syntheticRoot);
6303 document.getElementById('admin-modal').classList.add('hidden');
6304 } catch (err)
6305 {
6306 toast(err.message || 'Failed to open folder.', 'err');
6307 }
6308 });
6309
6310 row.appendChild(name);
6311 row.appendChild(info);
6312 row.appendChild(openBtn);
6313 list.appendChild(row);
6314 }
6315}
6316
6317async function refreshAdminUpdateStatus (opts = {})
6318{
6319 const pulseIfUpdateAvailable = !!opts.pulseIfUpdateAvailable;
6320 const btn = document.getElementById('admin-shutdown-btn');
6321 _adminUpdateStatus = null;
6322 btn.textContent = 'Shut down server';
6323 setAdminUpdateBadge(0);
6324
6325 try
6326 {
6327 const data = await api('GET', '/admin/update-status');
6328 if (!data) return;
6329 _adminUpdateStatus = data;
6330
6331 const updateCount = (data.underSystemd && Array.isArray(data.commitsAhead))
6332 ? data.commitsAhead.length
6333 : 0;
6334 setAdminUpdateBadge(updateCount);
6335
6336 if (!data.underSystemd)
6337 {
6338 btn.textContent = 'Shut down server';
6339 }
6340 else if (data.commitsAhead.length === 0)
6341 {
6342 btn.textContent = 'Restart Server';
6343 }
6344 else
6345 {
6346 btn.textContent = 'Restart & Update';
6347 if (pulseIfUpdateAvailable) pulseAdminUpdateButton();
6348 }
6349 }
6350 catch
6351 {
6352 // Not critical; button stays as "Shut down server".
6353 }
6354}
6355
6356function openUserModal (user, paths)
6357{
6358 const modal = document.getElementById('user-modal');
6359 modal.classList.remove('hidden');
6360 document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
6361 document.getElementById('user-error').classList.add('hidden');
6362
6363 const usernameInput = document.getElementById('user-username');
6364 usernameInput.value = user ? user.username : '';
6365 usernameInput.readOnly = !!user;
6366
6367 document.getElementById('user-password').value = '';
6368 const adminChk = document.getElementById('user-is-admin');
6369 const editingOwnAccount = !!(user
6370 && String(user.username || '').toLowerCase() === String(STATE.username || '').toLowerCase());
6371 adminChk.checked = user ? user.isAdmin : false;
6372 adminChk.disabled = editingOwnAccount;
6373 adminChk.title = editingOwnAccount
6374 ? 'You cannot remove admin privileges from your own account.'
6375 : '';
6376
6377 // Password placeholder
6378 document.getElementById('user-password').placeholder =
6379 user ? 'Leave blank to keep current' : 'Min 8 characters';
6380
6381 // Build permissions grid
6382 const permDiv = document.getElementById('user-permissions');
6383 permDiv.innerHTML = '';
6384 if (paths.length)
6385 {
6386 const heading = document.createElement('h4');
6387 heading.textContent = 'Path Permissions';
6388 permDiv.appendChild(heading);
6389
6390 const isAdminUser = !!(user && user.isAdmin);
6391 // Mirror the is-admin checkbox so toggling it live-updates the perm rows.
6392 const rebuildPermRows = (admin) =>
6393 {
6394 permDiv.querySelectorAll('.perm-row').forEach(r =>
6395 {
6396 r.querySelectorAll('input[type=checkbox]').forEach(cb =>
6397 {
6398 cb.disabled = admin;
6399 if (admin) cb.checked = true;
6400 });
6401 r.title = admin ? 'Admins always have full access' : '';
6402 });
6403 };
6404 adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
6405
6406 const syncReadWriteConstraints = (row, admin = false) =>
6407 {
6408 const readCb = row.querySelector('input[data-type="read"]');
6409 const writeCb = row.querySelector('input[data-type="write"]');
6410 if (!readCb || !writeCb) return;
6411
6412 if (admin)
6413 {
6414 readCb.checked = true;
6415 writeCb.checked = true;
6416 readCb.disabled = true;
6417 writeCb.disabled = true;
6418 return;
6419 }
6420
6421 readCb.disabled = false;
6422 if (!readCb.checked)
6423 {
6424 writeCb.checked = false;
6425 writeCb.disabled = true;
6426 }
6427 else
6428 {
6429 writeCb.disabled = false;
6430 }
6431 };
6432
6433 const syncAllReadWriteConstraints = () =>
6434 {
6435 const admin = adminChk.checked;
6436 permDiv.querySelectorAll('.perm-row').forEach((row) =>
6437 {
6438 syncReadWriteConstraints(row, admin);
6439 });
6440 };
6441
6442 for (const p of paths)
6443 {
6444 const label = p.split(/[\\/]/).pop();
6445 const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
6446 const row = document.createElement('div');
6447 row.className = 'perm-row';
6448 const readChecked = isAdminUser || perms.read;
6449 const writeChecked = isAdminUser || perms.write;
6450 row.innerHTML = `
6451 <span class="perm-label">${label}</span>
6452 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="read" ${readChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Read</label>
6453 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="write" ${writeChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Write</label>
6454 `;
6455 if (isAdminUser) row.title = 'Admins always have full access';
6456 const readCb = row.querySelector('input[data-type="read"]');
6457 if (readCb)
6458 {
6459 readCb.addEventListener('change', () =>
6460 {
6461 syncReadWriteConstraints(row, adminChk.checked);
6462 });
6463 }
6464 permDiv.appendChild(row);
6465 }
6466
6467 syncAllReadWriteConstraints();
6468 adminChk.addEventListener('change', syncAllReadWriteConstraints);
6469 }
6470
6471 document.getElementById('user-form').onsubmit = async (e) =>
6472 {
6473 e.preventDefault();
6474 const password = document.getElementById('user-password').value;
6475 const isAdmin = document.getElementById('user-is-admin').checked;
6476 const permissions = {};
6477 permDiv.querySelectorAll('input[data-label]').forEach(cb =>
6478 {
6479 const lbl = cb.dataset.label;
6480 if (!permissions[lbl]) permissions[lbl] = {};
6481 permissions[lbl][cb.dataset.type] = cb.checked;
6482 });
6483
6484 try
6485 {
6486 if (user)
6487 {
6488 const body = { isAdmin, permissions };
6489 if (password) body.password = password;
6490 await api('PATCH', `/admin/users/${user.id}`, body);
6491 } else
6492 {
6493 const uname = document.getElementById('user-username').value.trim();
6494 await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
6495 }
6496 modal.classList.add('hidden');
6497 toast('User saved.', 'ok');
6498 await refreshAdminUsers();
6499 } catch (err)
6500 {
6501 document.getElementById('user-error').textContent = err.message;
6502 document.getElementById('user-error').classList.remove('hidden');
6503 }
6504 };
6505}
6506
6507// ───────────────────────────────────────────────────────────────────────────
6508// SVG ICONS
6509// ───────────────────────────────────────────────────────────────────────────
6510
6511const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif']);
6512const VIDEO_EXTS = new Set(['mp4', 'webm', 'ogv', 'mov', 'avi', 'mkv']);
6513const AUDIO_EXTS = new Set(['mp3', 'ogg', 'wav', 'flac', 'aac', 'm4a']);
6514const MODEL_EXTS = new Set(['stl', 'obj']);
6515const DOC_EXTS = new Set(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp']);
6516const CODE_EXTS = new Set(['js', 'ts', 'py', 'rb', 'go', 'rs', 'c', 'cpp', 'h', '
6517… afgekapt