BlueGit

timfa filemanager

fixfix

timfa Tim Falken · pushed by timfa

Authored 2026-06-05 · 5 months ago

Hash
ccb65d4a21e984f08acd8e501220e4ac535a6901
Parent
a0162cfc
3 files changed +596 −185
public/app.js +451 −173
@@ -112,6 +112,7 @@ const FOLDER_GROUP_OPTIONS = [
112 112 ];
113 113 const VIDEO_FORWARD_BUFFER_SECONDS = 60 * 60;
114 114 const VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED = false;
115 const VIDEO_PREVIEW_LOAD_TIMEOUT_MS = 120 * 1000;
115 116 const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS = 15;
116 117 const IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS = 60;
117 118 const IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS = 40;
@@ -4152,31 +4153,192 @@ async function fetchPreviewImageBlob (item)
4152 4153 }
4153 4154 }
4154 4155
4155 async function downloadFileItem (item, opts = {})
4156 function attachPreviewLoadingOverlay (targetEl, opts = {})
4156 4157 {
4157 const blob = await fetchFileBlob(item);
4158 if (!blob)
4158 const showPercent = opts.showPercent !== false;
4159 const overlay = document.createElement('div');
4160 overlay.className = 'preview-loading-overlay';
4161 overlay.setAttribute('aria-busy', 'true');
4162 overlay.setAttribute('aria-live', 'polite');
4163
4164 const indicator = document.createElement('div');
4165 indicator.className = 'preview-loading-indicator';
4166
4167 const spinner = document.createElement('div');
4168 spinner.className = 'preview-loading-spinner';
4169 spinner.setAttribute('aria-hidden', 'true');
4170 indicator.appendChild(spinner);
4171
4172 const percentEl = document.createElement('span');
4173 percentEl.className = 'preview-loading-percent';
4174 percentEl.hidden = true;
4175 indicator.appendChild(percentEl);
4176
4177 overlay.appendChild(indicator);
4178 targetEl.appendChild(overlay);
4179
4180 return {
4181 setPercent (value)
4182 {
4183 if (!showPercent) return;
4184 const n = Number(value);
4185 if (!Number.isFinite(n))
4186 {
4187 percentEl.hidden = true;
4188 percentEl.textContent = '';
4189 return;
4190 }
4191 const clamped = Math.max(0, Math.min(100, Math.round(n)));
4192 percentEl.hidden = false;
4193 percentEl.textContent = `${clamped}%`;
4194 },
4195 remove ()
4196 {
4197 if (overlay.isConnected) overlay.remove();
4198 },
4199 };
4200 }
4201
4202 function getVideoPlayerBufferedPercent (player)
4203 {
4204 if (!player) return 0;
4205 try
4159 4206 {
4160 if (opts.popup)
4207 if (typeof player.bufferedPercent === 'function')
4161 4208 {
4162 try { opts.popup.close(); } catch { /* ignore */ }
4209 const ratio = Number(player.bufferedPercent());
4210 if (Number.isFinite(ratio) && ratio >= 0) return Math.min(1, ratio);
4163 4211 }
4164 toast('Download failed.', 'err');
4165 return;
4212 } catch { /* ignore */ }
4213
4214 try
4215 {
4216 const tech = typeof player.tech === 'function' ? player.tech(true) : null;
4217 const el = tech && typeof tech.el === 'function' ? tech.el() : null;
4218 if (!el || !el.buffered || !Number.isFinite(el.duration) || el.duration <= 0) return 0;
4219 let end = 0;
4220 for (let i = 0; i < el.buffered.length; i += 1)
4221 {
4222 end = Math.max(end, el.buffered.end(i));
4223 }
4224 return Math.max(0, Math.min(1, end / el.duration));
4225 } catch
4226 {
4227 return 0;
4166 4228 }
4229 }
4167 4230
4168 const objectUrl = URL.createObjectURL(blob);
4169 if (opts.popup)
4231 function computeVideoPreviewLoadPercent (setupPercent, streamAheadPrefetch, player)
4232 {
4233 let prefetchPercent = 0;
4234 if (streamAheadPrefetch && typeof streamAheadPrefetch.getStatus === 'function')
4170 4235 {
4171 opts.popup.location.href = objectUrl;
4172 setTimeout(() =>
4236 const status = streamAheadPrefetch.getStatus();
4237 const ratio = Number(status && status.cachedThroughRatio);
4238 if (Number.isFinite(ratio) && ratio >= 0)
4173 4239 {
4174 try { opts.popup.close(); } catch { /* ignore */ }
4175 }, 250);
4176 } else
4240 prefetchPercent = Math.min(100, ratio * 100);
4241 }
4242 }
4243
4244 const bufferPercent = getVideoPlayerBufferedPercent(player) * 100;
4245 const combined = Math.max(Number(setupPercent) || 0, prefetchPercent, bufferPercent);
4246 return Math.max(0, Math.min(99, Math.round(combined)));
4247 }
4248
4249 function getVideoJsPlayerErrorMessage (player)
4250 {
4251 if (!player || typeof player.error !== 'function') return '';
4252 try
4253 {
4254 const err = player.error();
4255 if (!err) return '';
4256 const code = err.code != null ? String(err.code) : '';
4257 const message = String(err.message || '').trim();
4258 if (message && code) return `${message} (${code})`;
4259 return message || code;
4260 } catch
4261 {
4262 return '';
4263 }
4264 }
4265
4266 function showVideoPreviewLoadFailure (targetEl, message, resources = {})
4267 {
4268 const {
4269 loading,
4270 player,
4271 streamAheadPrefetch,
4272 sessionPlaylistUrl,
4273 imageSubtitleController,
4274 streamAheadSeekMarker,
4275 trackPrefs,
4276 } = resources;
4277
4278 if (loading)
4279 {
4280 try { loading.remove(); } catch { /* ignore */ }
4281 }
4282 if (targetEl && targetEl.isConnected)
4283 {
4284 targetEl.querySelectorAll('.preview-loading-overlay').forEach((el) => el.remove());
4285 }
4286
4287 if (imageSubtitleController)
4177 4288 {
4178 triggerDownload(item.name, objectUrl);
4289 try { imageSubtitleController.detach(); } catch { /* ignore */ }
4179 4290 }
4291 try { streamAheadSeekMarker && streamAheadSeekMarker.detach(); } catch { /* ignore */ }
4292 try { trackPrefs && trackPrefs.detach(); } catch { /* ignore */ }
4293 try { streamAheadPrefetch && streamAheadPrefetch.stop(); } catch { /* ignore */ }
4294 if (player)
4295 {
4296 try { player.dispose(); } catch { /* ignore */ }
4297 }
4298
4299 if (targetEl && targetEl.isConnected)
4300 {
4301 targetEl.classList.remove('preview-expand-content--video');
4302 targetEl.querySelectorAll('.preview-video-js, video, .preview-media').forEach((el) => el.remove());
4303 if (!targetEl.querySelector('.preview-unsupported'))
4304 {
4305 const msg = document.createElement('p');
4306 msg.className = 'preview-unsupported';
4307 msg.textContent = message;
4308 targetEl.appendChild(msg);
4309 }
4310 }
4311
4312 void clearVideoStreamClientCache(sessionPlaylistUrl);
4313 releaseActivePreviewVideoStreamSession();
4314 STATE.previewCleanup = () =>
4315 {
4316 void clearVideoStreamClientCache(sessionPlaylistUrl);
4317 releaseActivePreviewVideoStreamSession();
4318 };
4319 }
4320
4321 function blobForAttachmentDownload (filename, blob)
4322 {
4323 if (!blob) return blob;
4324 const ext = extOf(filename || '');
4325 if (!VIDEO_EXTS.has(ext) && !AUDIO_EXTS.has(ext)) return blob;
4326 if (String(blob.type || '').toLowerCase() === 'application/octet-stream') return blob;
4327 return new Blob([blob], { type: 'application/octet-stream' });
4328 }
4329
4330 async function downloadFileItem (item)
4331 {
4332 const blob = await fetchFileBlob(item);
4333 if (!blob)
4334 {
4335 toast('Download failed.', 'err');
4336 return;
4337 }
4338
4339 const downloadBlob = blobForAttachmentDownload(item.name, blob);
4340 const objectUrl = URL.createObjectURL(downloadBlob);
4341 triggerDownload(item.name, objectUrl);
4180 4342 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
4181 4343 }
4182 4344
@@ -4188,170 +4350,308 @@ async function renderStreamedVideoPreview (item, targetEl)
4188 4350 || !targetEl
4189 4351 || !targetEl.isConnected;
4190 4352
4191 const videojs = await ensureVideoJsLoaded();
4192 if (isStaleInit()) return;
4193 await enableVideoStreamClientCache();
4194 if (isStaleInit()) return;
4195 const session = await createVideoStreamSessionForItem(item);
4196 if (isStaleInit())
4197 {
4198 void releaseVideoStreamSession(session && session.sessionId, { keepalive: true });
4199 return;
4200 }
4353 targetEl.querySelectorAll('.preview-loading-overlay').forEach((el) => el.remove());
4354 const loading = attachPreviewLoadingOverlay(targetEl, { showPercent: true });
4355 let setupPercent = 2;
4356 loading.setPercent(setupPercent);
4357
4358 const resources = {
4359 loading,
4360 player: null,
4361 streamAheadPrefetch: null,
4362 sessionPlaylistUrl: null,
4363 imageSubtitleController: null,
4364 streamAheadSeekMarker: null,
4365 trackPrefs: null,
4366 };
4367 let previewFailed = false;
4368 let loadTimeoutId = null;
4201 4369
4202 const sessionPlaylistUrl = String(session.playlistUrl || '').trim() || null;
4203 const streamAheadPrefetch = bindStreamAheadPrefetch(sessionPlaylistUrl);
4204 if (isStaleInit())
4370 const clearLoadTimeout = () =>
4205 4371 {
4206 try { streamAheadPrefetch && streamAheadPrefetch.stop(); } catch { /* ignore */ }
4207 void clearVideoStreamClientCache(sessionPlaylistUrl);
4208 void releaseVideoStreamSession(session && session.sessionId, { keepalive: true });
4209 return;
4210 }
4211
4212 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
4213 const prefs = loadUserVideoPrefs();
4214 applyUserVideoTextTrackPrefs();
4372 if (loadTimeoutId != null)
4373 {
4374 window.clearTimeout(loadTimeoutId);
4375 loadTimeoutId = null;
4376 }
4377 };
4215 4378
4216 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
4379 const abortLoading = () =>
4217 4380 {
4218 toast('Some subtitle tracks could not be converted for web playback.', 'err');
4219 }
4381 clearLoadTimeout();
4382 try { loading.remove(); } catch { /* ignore */ }
4383 };
4220 4384
4221 const video = document.createElement('video');
4222 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
4223 video.controls = true;
4224 video.preload = 'auto';
4225 video.playsInline = true;
4226 targetEl.classList.add('preview-expand-content--video');
4227 targetEl.appendChild(video);
4385 const failPreview = (message) =>
4386 {
4387 if (previewFailed || isStaleInit()) return;
4388 previewFailed = true;
4389 clearLoadTimeout();
4390 showVideoPreviewLoadFailure(targetEl, message, resources);
4391 };
4228 4392
4229 const player = videojs(video, {
4230 controls: true,
4231 fluid: false,
4232 fill: true,
4233 responsive: false,
4234 preload: 'auto',
4235 controlBar: {
4236 currentTimeDisplay: true,
4237 timeDivider: true,
4238 durationDisplay: true,
4239 remainingTimeDisplay: false,
4240 },
4241 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
4242 tracks: (session.subtitleTracks || []).map((track) => ({
4243 kind: 'subtitles',
4244 src: track.src,
4245 srclang: track.language || 'und',
4246 label: track.label,
4247 default: !!track.default,
4248 })),
4249 });
4393 const releaseSessionIfNeeded = (session) =>
4394 {
4395 void releaseVideoStreamSession(session && session.sessionId, { keepalive: true });
4396 };
4250 4397
4251 const trackPrefs = bindUserVideoTrackPrefs(player, prefs);
4252 const streamAheadSeekMarker = bindStreamAheadSeekMarker(player, streamAheadPrefetch);
4398 let session;
4399 let videojs;
4253 4400
4254 ensureVideoPlaybackUi(player, session.durationSeconds);
4255 const imageSubtitleController = bindImageSubtitleOverlay(player, videojs, prefs, session, item);
4401 try
4402 {
4403 videojs = await ensureVideoJsLoaded();
4404 if (isStaleInit()) { abortLoading(); return; }
4405 setupPercent = 12;
4406 loading.setPercent(setupPercent);
4256 4407
4257 // -------------------------------------------------------------------------
4408 await enableVideoStreamClientCache();
4409 if (isStaleInit()) { abortLoading(); return; }
4410 setupPercent = 22;
4411 loading.setPercent(setupPercent);
4258 4412
4259 let sentPartway = false;
4260 let sentFully = false;
4261 const markWatch = async () =>
4262 {
4263 let ratio = 0;
4264 try
4413 session = await createVideoStreamSessionForItem(item);
4414 if (!session || !String(session.playlistUrl || '').trim())
4265 4415 {
4266 const duration = Number(player.duration());
4267 const current = Number(player.currentTime());
4268 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
4269 {
4270 ratio = current / duration;
4271 }
4272 } catch
4416 throw new Error('Video stream could not be started.');
4417 }
4418
4419 if (isStaleInit())
4273 4420 {
4421 abortLoading();
4422 releaseSessionIfNeeded(session);
4274 4423 return;
4275 4424 }
4276 4425
4277 if (ratio >= 0.7)
4426 setupPercent = 32;
4427 loading.setPercent(setupPercent);
4428
4429 resources.sessionPlaylistUrl = String(session.playlistUrl || '').trim() || null;
4430 resources.streamAheadPrefetch = bindStreamAheadPrefetch(resources.sessionPlaylistUrl);
4431 if (isStaleInit())
4278 4432 {
4279 if (sentFully) return;
4280 sentPartway = true;
4281 sentFully = true;
4282 void reportWatchProgress(item.path, ratio);
4433 abortLoading();
4434 try { resources.streamAheadPrefetch && resources.streamAheadPrefetch.stop(); } catch { /* ignore */ }
4435 void clearVideoStreamClientCache(resources.sessionPlaylistUrl);
4436 releaseSessionIfNeeded(session);
4283 4437 return;
4284 4438 }
4285 4439
4286 if (ratio >= 0.05)
4440 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
4441 const prefs = loadUserVideoPrefs();
4442 applyUserVideoTextTrackPrefs();
4443
4444 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
4287 4445 {
4288 if (sentPartway) return;
4289 sentPartway = true;
4290 void reportWatchProgress(item.path, ratio);
4446 toast('Some subtitle tracks could not be converted for web playback.', 'err');
4291 4447 }
4292 };
4293 4448
4294 player.ready(() =>
4295 {
4296 const volume = Number(prefs.volume);
4297 if (Number.isFinite(volume))
4449 setupPercent = 40;
4450 loading.setPercent(setupPercent);
4451
4452 const video = document.createElement('video');
4453 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
4454 video.controls = true;
4455 video.preload = 'auto';
4456 video.playsInline = true;
4457 targetEl.classList.add('preview-expand-content--video');
4458 targetEl.appendChild(video);
4459
4460 const player = videojs(video, {
4461 controls: true,
4462 fluid: false,
4463 fill: true,
4464 responsive: false,
4465 preload: 'auto',
4466 controlBar: {
4467 currentTimeDisplay: true,
4468 timeDivider: true,
4469 durationDisplay: true,
4470 remainingTimeDisplay: false,
4471 },
4472 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
4473 tracks: (session.subtitleTracks || []).map((track) => ({
4474 kind: 'subtitles',
4475 src: track.src,
4476 srclang: track.language || 'und',
4477 label: track.label,
4478 default: !!track.default,
4479 })),
4480 });
4481
4482 resources.player = player;
4483 resources.trackPrefs = bindUserVideoTrackPrefs(player, prefs);
4484 resources.streamAheadSeekMarker = bindStreamAheadSeekMarker(player, resources.streamAheadPrefetch);
4485
4486 ensureVideoPlaybackUi(player, session.durationSeconds);
4487 resources.imageSubtitleController = bindImageSubtitleOverlay(player, videojs, prefs, session, item);
4488
4489 setupPercent = 48;
4490 let detachPrefetchProgress = null;
4491 let loadingHidden = false;
4492
4493 const refreshLoadingPercent = () =>
4298 4494 {
4299 player.volume(Math.max(0, Math.min(1, volume)));
4300 }
4495 if (loadingHidden || previewFailed) return;
4496 loading.setPercent(computeVideoPreviewLoadPercent(setupPercent, resources.streamAheadPrefetch, player));
4497 };
4301 4498
4302 const settings = player && player.textTrackSettings;
4303 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
4499 const hidePreviewLoading = () =>
4304 4500 {
4305 settings.setValues({
4306 backgroundColor: '#000',
4307 backgroundOpacity: '0',
4308 edgeStyle: 'uniform',
4309 });
4310 settings.updateDisplay();
4501 if (loadingHidden || previewFailed) return;
4502 loadingHidden = true;
4503 clearLoadTimeout();
4504 if (detachPrefetchProgress)
4505 {
4506 try { detachPrefetchProgress(); } catch { /* ignore */ }
4507 detachPrefetchProgress = null;
4508 }
4509 loading.setPercent(100);
4510 abortLoading();
4511 };
4512
4513 if (resources.streamAheadPrefetch && typeof resources.streamAheadPrefetch.subscribe === 'function')
4514 {
4515 detachPrefetchProgress = resources.streamAheadPrefetch.subscribe(() => refreshLoadingPercent());
4311 4516 }
4517 refreshLoadingPercent();
4312 4518
4313 trackPrefs.applySavedTracks();
4314 });
4519 player.on('progress', refreshLoadingPercent);
4520 player.one('canplay', hidePreviewLoading);
4521 player.one('loadeddata', () =>
4522 {
4523 refreshLoadingPercent();
4524 window.setTimeout(hidePreviewLoading, 350);
4525 });
4526 player.one('error', () =>
4527 {
4528 const detail = getVideoJsPlayerErrorMessage(player);
4529 failPreview(
4530 detail
4531 ? `Video playback failed: ${detail}. You can try again or download the file.`
4532 : 'Video playback failed. You can try again or download the file.',
4533 );
4534 });
4315 4535
4316 player.on('loadedmetadata', trackPrefs.applySavedTracks);
4317 player.on('loadedplaylist', trackPrefs.applySavedTracks);
4318 player.on('timeupdate', markWatch);
4319 player.on('ended', () =>
4320 {
4321 sentPartway = true;
4322 sentFully = true;
4323 void reportWatchProgress(item.path, 1);
4324 });
4325 player.on('volumechange', () =>
4326 {
4327 const v = Number(player.volume());
4328 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
4329 });
4536 loadTimeoutId = window.setTimeout(() =>
4537 {
4538 failPreview('Video preview timed out. You can try again or download the file.');
4539 }, VIDEO_PREVIEW_LOAD_TIMEOUT_MS);
4330 4540
4331 const cleanupPreviewPlayer = () =>
4332 {
4333 if (imageSubtitleController)
4541 // -------------------------------------------------------------------------
4542
4543 let sentPartway = false;
4544 let sentFully = false;
4545 const markWatch = async () =>
4334 4546 {
4335 try { imageSubtitleController.captureSelectedTracks(); } catch { /* ignore */ }
4336 try { imageSubtitleController.detach(); } catch { /* ignore */ }
4547 let ratio = 0;
4548 try
4549 {
4550 const duration = Number(player.duration());
4551 const current = Number(player.currentTime());
4552 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
4553 {
4554 ratio = current / duration;
4555 }
4556 } catch
4557 {
4558 return;
4559 }
4560
4561 if (ratio >= 0.7)
4562 {
4563 if (sentFully) return;
4564 sentPartway = true;
4565 sentFully = true;
4566 void reportWatchProgress(item.path, ratio);
4567 return;
4568 }
4569
4570 if (ratio >= 0.05)
4571 {
4572 if (sentPartway) return;
4573 sentPartway = true;
4574 void reportWatchProgress(item.path, ratio);
4575 }
4576 };
4577
4578 player.ready(() =>
4579 {
4580 const volume = Number(prefs.volume);
4581 if (Number.isFinite(volume))
4582 {
4583 player.volume(Math.max(0, Math.min(1, volume)));
4584 }
4585
4586 const settings = player && player.textTrackSettings;
4587 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
4588 {
4589 settings.setValues({
4590 backgroundColor: '#000',
4591 backgroundOpacity: '0',
4592 edgeStyle: 'uniform',
4593 });
4594 settings.updateDisplay();
4595 }
4596
4597 resources.trackPrefs.applySavedTracks();
4598 });
4599
4600 player.on('loadedmetadata', resources.trackPrefs.applySavedTracks);
4601 player.on('loadedplaylist', resources.trackPrefs.applySavedTracks);
4602 player.on('timeupdate', markWatch);
4603 player.on('ended', () =>
4604 {
4605 sentPartway = true;
4606 sentFully = true;
4607 void reportWatchProgress(item.path, 1);
4608 });
4609 player.on('volumechange', () =>
4610 {
4611 const v = Number(player.volume());
4612 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
4613 });
4614
4615 const cleanupPreviewPlayer = () =>
4616 {
4617 if (!previewFailed) hidePreviewLoading();
4618 if (resources.imageSubtitleController)
4619 {
4620 try { resources.imageSubtitleController.captureSelectedTracks(); } catch { /* ignore */ }
4621 try { resources.imageSubtitleController.detach(); } catch { /* ignore */ }
4622 }
4623 try { resources.streamAheadSeekMarker && resources.streamAheadSeekMarker.detach(); } catch { /* ignore */ }
4624 try { resources.streamAheadPrefetch && resources.streamAheadPrefetch.stop(); } catch { /* ignore */ }
4625 void clearVideoStreamClientCache(resources.sessionPlaylistUrl);
4626 releaseActivePreviewVideoStreamSession();
4627 try { markWatch(); } catch { /* ignore */ }
4628 try { resources.trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
4629 try { resources.trackPrefs.detach(); } catch { /* ignore */ }
4630 try { player.dispose(); } catch { /* ignore */ }
4631 };
4632
4633 if (isStaleInit())
4634 {
4635 cleanupPreviewPlayer();
4636 return;
4337 4637 }
4338 try { streamAheadSeekMarker && streamAheadSeekMarker.detach(); } catch { /* ignore */ }
4339 try { streamAheadPrefetch && streamAheadPrefetch.stop(); } catch { /* ignore */ }
4340 void clearVideoStreamClientCache(sessionPlaylistUrl);
4341 releaseActivePreviewVideoStreamSession();
4342 try { markWatch(); } catch { /* ignore */ }
4343 try { trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
4344 try { trackPrefs.detach(); } catch { /* ignore */ }
4345 try { player.dispose(); } catch { /* ignore */ }
4346 };
4347 4638
4348 if (isStaleInit())
4639 if (!previewFailed)
4640 {
4641 STATE.previewCleanup = cleanupPreviewPlayer;
4642 }
4643 }
4644 catch (err)
4349 4645 {
4350 cleanupPreviewPlayer();
4351 return;
4646 if (isStaleInit())
4647 {
4648 abortLoading();
4649 releaseSessionIfNeeded(session);
4650 return;
4651 }
4652 const fallback = 'Video preview failed to load. You can try again or download the file.';
4653 failPreview(err && err.message ? String(err.message) : fallback);
4352 4654 }
4353
4354 STATE.previewCleanup = cleanupPreviewPlayer;
4355 4655 }
4356 4656
4357 4657 function fileAccentColor (name)
@@ -4488,39 +4788,19 @@ async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewCo
4488 4788 return;
4489 4789 }
4490 4790
4491 const needsAsyncDownload = !previewObjectUrlIsDownloadableOriginal(previewItem);
4492 const popup = needsAsyncDownload ? window.open('', '_blank') : null;
4493 if (popup)
4494 {
4495 try
4496 {
4497 popup.document.title = previewItem.name;
4498 popup.document.body.textContent = 'Preparing download…';
4499 }
4500 catch { /* ignore */ }
4501 }
4502
4503 4791 if (previewObjectUrlIsDownloadableOriginal(previewItem))
4504 4792 {
4505 if (popup)
4506 {
4507 try { popup.close(); } catch { /* ignore */ }
4508 }
4509 4793 triggerDownload(previewItem.name, STATE.previewObjectUrl);
4510 4794 return;
4511 4795 }
4512 4796
4513 if (!needsAsyncDownload)
4797 if (VIDEO_EXTS.has(extOf(previewItem.name)) || AUDIO_EXTS.has(extOf(previewItem.name)))
4514 4798 {
4515 if (popup)
4516 {
4517 try { popup.close(); } catch { /* ignore */ }
4518 }
4519 toast('Preview still loading.', 'err');
4799 void downloadFileItem(previewItem);
4520 4800 return;
4521 4801 }
4522 4802
4523 void downloadFileItem(previewItem, { popup });
4803 toast('Preview still loading.', 'err');
4524 4804 });
4525 4805
4526 4806 const shareBtn = document.createElement('button');
@@ -4551,10 +4831,8 @@ async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewCo
4551 4831 previewMount.className = 'preview-expand-content';
4552 4832 iconEl.appendChild(previewMount);
4553 4833
4554 // Show spinner during expansion animation; content loads after it finishes
4555 const spinner = document.createElement('div');
4556 spinner.className = 'preview-loading-spinner';
4557 previewMount.appendChild(spinner);
4834 // Spinner during expansion; video preview keeps an overlay until the player is ready.
4835 attachPreviewLoadingOverlay(previewMount, { showPercent: VIDEO_EXTS.has(extOf(item.name)) });
4558 4836
4559 4837 tileEl.insertBefore(titleEl, tileEl.firstChild);
4560 4838 tileEl.appendChild(closeBtn);
@@ -5058,7 +5336,7 @@ async function downloadOrView (item, sourceSvgEl = null)
5058 5336 if (VIDEO_EXTS.has(extOf(item.name)))
5059 5337 {
5060 5338 clearPreviewObjectUrl();
5061 previewMount.innerHTML = '';
5339 previewMount.querySelectorAll('.preview-video-js, video, .preview-media').forEach((el) => el.remove());
5062 5340 await renderStreamedVideoPreview(item, previewMount);
5063 5341 return;
5064 5342 }
@@ -112,6 +112,7 @@ const FOLDER_GROUP_OPTIONS = [
112];
112];
113const VIDEO_FORWARD_BUFFER_SECONDS = 60 * 60;
113const VIDEO_FORWARD_BUFFER_SECONDS = 60 * 60;
114const VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED = false;
114const VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED = false;
115const VIDEO_PREVIEW_LOAD_TIMEOUT_MS = 120 * 1000;
115const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS = 15;
116const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS = 15;
116const IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS = 60;
117const IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS = 60;
117const IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS = 40;
118const IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS = 40;
@@ -4152,31 +4153,192 @@ async function fetchPreviewImageBlob (item)
4152 }
4153 }
4153}
4154}
4154
4155
4155async function downloadFileItem (item, opts = {})
4156function attachPreviewLoadingOverlay (targetEl, opts = {})
4156{
4157{
4157 const blob = await fetchFileBlob(item);
4158 const showPercent = opts.showPercent !== false;
4158 if (!blob)
4159 const overlay = document.createElement('div');
4160 overlay.className = 'preview-loading-overlay';
4161 overlay.setAttribute('aria-busy', 'true');
4162 overlay.setAttribute('aria-live', 'polite');
4163
4164 const indicator = document.createElement('div');
4165 indicator.className = 'preview-loading-indicator';
4166
4167 const spinner = document.createElement('div');
4168 spinner.className = 'preview-loading-spinner';
4169 spinner.setAttribute('aria-hidden', 'true');
4170 indicator.appendChild(spinner);
4171
4172 const percentEl = document.createElement('span');
4173 percentEl.className = 'preview-loading-percent';
4174 percentEl.hidden = true;
4175 indicator.appendChild(percentEl);
4176
4177 overlay.appendChild(indicator);
4178 targetEl.appendChild(overlay);
4179
4180 return {
4181 setPercent (value)
4182 {
4183 if (!showPercent) return;
4184 const n = Number(value);
4185 if (!Number.isFinite(n))
4186 {
4187 percentEl.hidden = true;
4188 percentEl.textContent = '';
4189 return;
4190 }
4191 const clamped = Math.max(0, Math.min(100, Math.round(n)));
4192 percentEl.hidden = false;
4193 percentEl.textContent = `${clamped}%`;
4194 },
4195 remove ()
4196 {
4197 if (overlay.isConnected) overlay.remove();
4198 },
4199 };
4200}
4201
4202function getVideoPlayerBufferedPercent (player)
4203{
4204 if (!player) return 0;
4205 try
4159 {
4206 {
4160 if (opts.popup)
4207 if (typeof player.bufferedPercent === 'function')
4161 {
4208 {
4162 try { opts.popup.close(); } catch { /* ignore */ }
4209 const ratio = Number(player.bufferedPercent());
4210 if (Number.isFinite(ratio) && ratio >= 0) return Math.min(1, ratio);
4163 }
4211 }
4164 toast('Download failed.', 'err');
4212 } catch { /* ignore */ }
4165 return;
4213
4214 try
4215 {
4216 const tech = typeof player.tech === 'function' ? player.tech(true) : null;
4217 const el = tech && typeof tech.el === 'function' ? tech.el() : null;
4218 if (!el || !el.buffered || !Number.isFinite(el.duration) || el.duration <= 0) return 0;
4219 let end = 0;
4220 for (let i = 0; i < el.buffered.length; i += 1)
4221 {
4222 end = Math.max(end, el.buffered.end(i));
4223 }
4224 return Math.max(0, Math.min(1, end / el.duration));
4225 } catch
4226 {
4227 return 0;
4166 }
4228 }
4229}
4167
4230
4168 const objectUrl = URL.createObjectURL(blob);
4231function computeVideoPreviewLoadPercent (setupPercent, streamAheadPrefetch, player)
4169 if (opts.popup)
4232{
4233 let prefetchPercent = 0;
4234 if (streamAheadPrefetch && typeof streamAheadPrefetch.getStatus === 'function')
4170 {
4235 {
4171 opts.popup.location.href = objectUrl;
4236 const status = streamAheadPrefetch.getStatus();
4172 setTimeout(() =>
4237 const ratio = Number(status && status.cachedThroughRatio);
4238 if (Number.isFinite(ratio) && ratio >= 0)
4173 {
4239 {
4174 try { opts.popup.close(); } catch { /* ignore */ }
4240 prefetchPercent = Math.min(100, ratio * 100);
4175 }, 250);
4241 }
4176 } else
4242 }
4243
4244 const bufferPercent = getVideoPlayerBufferedPercent(player) * 100;
4245 const combined = Math.max(Number(setupPercent) || 0, prefetchPercent, bufferPercent);
4246 return Math.max(0, Math.min(99, Math.round(combined)));
4247}
4248
4249function getVideoJsPlayerErrorMessage (player)
4250{
4251 if (!player || typeof player.error !== 'function') return '';
4252 try
4253 {
4254 const err = player.error();
4255 if (!err) return '';
4256 const code = err.code != null ? String(err.code) : '';
4257 const message = String(err.message || '').trim();
4258 if (message && code) return `${message} (${code})`;
4259 return message || code;
4260 } catch
4261 {
4262 return '';
4263 }
4264}
4265
4266function showVideoPreviewLoadFailure (targetEl, message, resources = {})
4267{
4268 const {
4269 loading,
4270 player,
4271 streamAheadPrefetch,
4272 sessionPlaylistUrl,
4273 imageSubtitleController,
4274 streamAheadSeekMarker,
4275 trackPrefs,
4276 } = resources;
4277
4278 if (loading)
4279 {
4280 try { loading.remove(); } catch { /* ignore */ }
4281 }
4282 if (targetEl && targetEl.isConnected)
4283 {
4284 targetEl.querySelectorAll('.preview-loading-overlay').forEach((el) => el.remove());
4285 }
4286
4287 if (imageSubtitleController)
4177 {
4288 {
4178 triggerDownload(item.name, objectUrl);
4289 try { imageSubtitleController.detach(); } catch { /* ignore */ }
4179 }
4290 }
4291 try { streamAheadSeekMarker && streamAheadSeekMarker.detach(); } catch { /* ignore */ }
4292 try { trackPrefs && trackPrefs.detach(); } catch { /* ignore */ }
4293 try { streamAheadPrefetch && streamAheadPrefetch.stop(); } catch { /* ignore */ }
4294 if (player)
4295 {
4296 try { player.dispose(); } catch { /* ignore */ }
4297 }
4298
4299 if (targetEl && targetEl.isConnected)
4300 {
4301 targetEl.classList.remove('preview-expand-content--video');
4302 targetEl.querySelectorAll('.preview-video-js, video, .preview-media').forEach((el) => el.remove());
4303 if (!targetEl.querySelector('.preview-unsupported'))
4304 {
4305 const msg = document.createElement('p');
4306 msg.className = 'preview-unsupported';
4307 msg.textContent = message;
4308 targetEl.appendChild(msg);
4309 }
4310 }
4311
4312 void clearVideoStreamClientCache(sessionPlaylistUrl);
4313 releaseActivePreviewVideoStreamSession();
4314 STATE.previewCleanup = () =>
4315 {
4316 void clearVideoStreamClientCache(sessionPlaylistUrl);
4317 releaseActivePreviewVideoStreamSession();
4318 };
4319}
4320
4321function blobForAttachmentDownload (filename, blob)
4322{
4323 if (!blob) return blob;
4324 const ext = extOf(filename || '');
4325 if (!VIDEO_EXTS.has(ext) && !AUDIO_EXTS.has(ext)) return blob;
4326 if (String(blob.type || '').toLowerCase() === 'application/octet-stream') return blob;
4327 return new Blob([blob], { type: 'application/octet-stream' });
4328}
4329
4330async function downloadFileItem (item)
4331{
4332 const blob = await fetchFileBlob(item);
4333 if (!blob)
4334 {
4335 toast('Download failed.', 'err');
4336 return;
4337 }
4338
4339 const downloadBlob = blobForAttachmentDownload(item.name, blob);
4340 const objectUrl = URL.createObjectURL(downloadBlob);
4341 triggerDownload(item.name, objectUrl);
4180 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
4342 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
4181}
4343}
4182
4344
@@ -4188,170 +4350,308 @@ async function renderStreamedVideoPreview (item, targetEl)
4188 || !targetEl
4350 || !targetEl
4189 || !targetEl.isConnected;
4351 || !targetEl.isConnected;
4190
4352
4191 const videojs = await ensureVideoJsLoaded();
4353 targetEl.querySelectorAll('.preview-loading-overlay').forEach((el) => el.remove());
4192 if (isStaleInit()) return;
4354 const loading = attachPreviewLoadingOverlay(targetEl, { showPercent: true });
4193 await enableVideoStreamClientCache();
4355 let setupPercent = 2;
4194 if (isStaleInit()) return;
4356 loading.setPercent(setupPercent);
4195 const session = await createVideoStreamSessionForItem(item);
4357
4196 if (isStaleInit())
4358 const resources = {
4197 {
4359 loading,
4198 void releaseVideoStreamSession(session && session.sessionId, { keepalive: true });
4360 player: null,
4199 return;
4361 streamAheadPrefetch: null,
4200 }
4362 sessionPlaylistUrl: null,
4363 imageSubtitleController: null,
4364 streamAheadSeekMarker: null,
4365 trackPrefs: null,
4366 };
4367 let previewFailed = false;
4368 let loadTimeoutId = null;
4201
4369
4202 const sessionPlaylistUrl = String(session.playlistUrl || '').trim() || null;
4370 const clearLoadTimeout = () =>
4203 const streamAheadPrefetch = bindStreamAheadPrefetch(sessionPlaylistUrl);
4204 if (isStaleInit())
4205 {
4371 {
4206 try { streamAheadPrefetch && streamAheadPrefetch.stop(); } catch { /* ignore */ }
4372 if (loadTimeoutId != null)
4207 void clearVideoStreamClientCache(sessionPlaylistUrl);
4373 {
4208 void releaseVideoStreamSession(session && session.sessionId, { keepalive: true });
4374 window.clearTimeout(loadTimeoutId);
4209 return;
4375 loadTimeoutId = null;
4210 }
4376 }
4211
4377 };
4212 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
4213 const prefs = loadUserVideoPrefs();
4214 applyUserVideoTextTrackPrefs();
4215
4378
4216 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
4379 const abortLoading = () =>
4217 {
4380 {
4218 toast('Some subtitle tracks could not be converted for web playback.', 'err');
4381 clearLoadTimeout();
4219 }
4382 try { loading.remove(); } catch { /* ignore */ }
4383 };
4220
4384
4221 const video = document.createElement('video');
4385 const failPreview = (message) =>
4222 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
4386 {
4223 video.controls = true;
4387 if (previewFailed || isStaleInit()) return;
4224 video.preload = 'auto';
4388 previewFailed = true;
4225 video.playsInline = true;
4389 clearLoadTimeout();
4226 targetEl.classList.add('preview-expand-content--video');
4390 showVideoPreviewLoadFailure(targetEl, message, resources);
4227 targetEl.appendChild(video);
4391 };
4228
4392
4229 const player = videojs(video, {
4393 const releaseSessionIfNeeded = (session) =>
4230 controls: true,
4394 {
4231 fluid: false,
4395 void releaseVideoStreamSession(session && session.sessionId, { keepalive: true });
4232 fill: true,
4396 };
4233 responsive: false,
4234 preload: 'auto',
4235 controlBar: {
4236 currentTimeDisplay: true,
4237 timeDivider: true,
4238 durationDisplay: true,
4239 remainingTimeDisplay: false,
4240 },
4241 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
4242 tracks: (session.subtitleTracks || []).map((track) => ({
4243 kind: 'subtitles',
4244 src: track.src,
4245 srclang: track.language || 'und',
4246 label: track.label,
4247 default: !!track.default,
4248 })),
4249 });
4250
4397
4251 const trackPrefs = bindUserVideoTrackPrefs(player, prefs);
4398 let session;
4252 const streamAheadSeekMarker = bindStreamAheadSeekMarker(player, streamAheadPrefetch);
4399 let videojs;
4253
4400
4254 ensureVideoPlaybackUi(player, session.durationSeconds);
4401 try
4255 const imageSubtitleController = bindImageSubtitleOverlay(player, videojs, prefs, session, item);
4402 {
4403 videojs = await ensureVideoJsLoaded();
4404 if (isStaleInit()) { abortLoading(); return; }
4405 setupPercent = 12;
4406 loading.setPercent(setupPercent);
4256
4407
4257 // -------------------------------------------------------------------------
4408 await enableVideoStreamClientCache();
4409 if (isStaleInit()) { abortLoading(); return; }
4410 setupPercent = 22;
4411 loading.setPercent(setupPercent);
4258
4412
4259 let sentPartway = false;
4413 session = await createVideoStreamSessionForItem(item);
4260 let sentFully = false;
4414 if (!session || !String(session.playlistUrl || '').trim())
4261 const markWatch = async () =>
4262 {
4263 let ratio = 0;
4264 try
4265 {
4415 {
4266 const duration = Number(player.duration());
4416 throw new Error('Video stream could not be started.');
4267 const current = Number(player.currentTime());
4417 }
4268 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
4418
4269 {
4419 if (isStaleInit())
4270 ratio = current / duration;
4271 }
4272 } catch
4273 {
4420 {
4421 abortLoading();
4422 releaseSessionIfNeeded(session);
4274 return;
4423 return;
4275 }
4424 }
4276
4425
4277 if (ratio >= 0.7)
4426 setupPercent = 32;
4427 loading.setPercent(setupPercent);
4428
4429 resources.sessionPlaylistUrl = String(session.playlistUrl || '').trim() || null;
4430 resources.streamAheadPrefetch = bindStreamAheadPrefetch(resources.sessionPlaylistUrl);
4431 if (isStaleInit())
4278 {
4432 {
4279 if (sentFully) return;
4433 abortLoading();
4280 sentPartway = true;
4434 try { resources.streamAheadPrefetch && resources.streamAheadPrefetch.stop(); } catch { /* ignore */ }
4281 sentFully = true;
4435 void clearVideoStreamClientCache(resources.sessionPlaylistUrl);
4282 void reportWatchProgress(item.path, ratio);
4436 releaseSessionIfNeeded(session);
4283 return;
4437 return;
4284 }
4438 }
4285
4439
4286 if (ratio >= 0.05)
4440 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
4441 const prefs = loadUserVideoPrefs();
4442 applyUserVideoTextTrackPrefs();
4443
4444 if ((session.subtitleSummary && session.subtitleSummary.skipped > 0))
4287 {
4445 {
4288 if (sentPartway) return;
4446 toast('Some subtitle tracks could not be converted for web playback.', 'err');
4289 sentPartway = true;
4290 void reportWatchProgress(item.path, ratio);
4291 }
4447 }
4292 };
4293
4448
4294 player.ready(() =>
4449 setupPercent = 40;
4295 {
4450 loading.setPercent(setupPercent);
4296 const volume = Number(prefs.volume);
4451
4297 if (Number.isFinite(volume))
4452 const video = document.createElement('video');
4453 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
4454 video.controls = true;
4455 video.preload = 'auto';
4456 video.playsInline = true;
4457 targetEl.classList.add('preview-expand-content--video');
4458 targetEl.appendChild(video);
4459
4460 const player = videojs(video, {
4461 controls: true,
4462 fluid: false,
4463 fill: true,
4464 responsive: false,
4465 preload: 'auto',
4466 controlBar: {
4467 currentTimeDisplay: true,
4468 timeDivider: true,
4469 durationDisplay: true,
4470 remainingTimeDisplay: false,
4471 },
4472 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
4473 tracks: (session.subtitleTracks || []).map((track) => ({
4474 kind: 'subtitles',
4475 src: track.src,
4476 srclang: track.language || 'und',
4477 label: track.label,
4478 default: !!track.default,
4479 })),
4480 });
4481
4482 resources.player = player;
4483 resources.trackPrefs = bindUserVideoTrackPrefs(player, prefs);
4484 resources.streamAheadSeekMarker = bindStreamAheadSeekMarker(player, resources.streamAheadPrefetch);
4485
4486 ensureVideoPlaybackUi(player, session.durationSeconds);
4487 resources.imageSubtitleController = bindImageSubtitleOverlay(player, videojs, prefs, session, item);
4488
4489 setupPercent = 48;
4490 let detachPrefetchProgress = null;
4491 let loadingHidden = false;
4492
4493 const refreshLoadingPercent = () =>
4298 {
4494 {
4299 player.volume(Math.max(0, Math.min(1, volume)));
4495 if (loadingHidden || previewFailed) return;
4300 }
4496 loading.setPercent(computeVideoPreviewLoadPercent(setupPercent, resources.streamAheadPrefetch, player));
4497 };
4301
4498
4302 const settings = player && player.textTrackSettings;
4499 const hidePreviewLoading = () =>
4303 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
4304 {
4500 {
4305 settings.setValues({
4501 if (loadingHidden || previewFailed) return;
4306 backgroundColor: '#000',
4502 loadingHidden = true;
4307 backgroundOpacity: '0',
4503 clearLoadTimeout();
4308 edgeStyle: 'uniform',
4504 if (detachPrefetchProgress)
4309 });
4505 {
4310 settings.updateDisplay();
4506 try { detachPrefetchProgress(); } catch { /* ignore */ }
4507 detachPrefetchProgress = null;
4508 }
4509 loading.setPercent(100);
4510 abortLoading();
4511 };
4512
4513 if (resources.streamAheadPrefetch && typeof resources.streamAheadPrefetch.subscribe === 'function')
4514 {
4515 detachPrefetchProgress = resources.streamAheadPrefetch.subscribe(() => refreshLoadingPercent());
4311 }
4516 }
4517 refreshLoadingPercent();
4312
4518
4313 trackPrefs.applySavedTracks();
4519 player.on('progress', refreshLoadingPercent);
4314 });
4520 player.one('canplay', hidePreviewLoading);
4521 player.one('loadeddata', () =>
4522 {
4523 refreshLoadingPercent();
4524 window.setTimeout(hidePreviewLoading, 350);
4525 });
4526 player.one('error', () =>
4527 {
4528 const detail = getVideoJsPlayerErrorMessage(player);
4529 failPreview(
4530 detail
4531 ? `Video playback failed: ${detail}. You can try again or download the file.`
4532 : 'Video playback failed. You can try again or download the file.',
4533 );
4534 });
4315
4535
4316 player.on('loadedmetadata', trackPrefs.applySavedTracks);
4536 loadTimeoutId = window.setTimeout(() =>
4317 player.on('loadedplaylist', trackPrefs.applySavedTracks);
4537 {
4318 player.on('timeupdate', markWatch);
4538 failPreview('Video preview timed out. You can try again or download the file.');
4319 player.on('ended', () =>
4539 }, VIDEO_PREVIEW_LOAD_TIMEOUT_MS);
4320 {
4321 sentPartway = true;
4322 sentFully = true;
4323 void reportWatchProgress(item.path, 1);
4324 });
4325 player.on('volumechange', () =>
4326 {
4327 const v = Number(player.volume());
4328 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
4329 });
4330
4540
4331 const cleanupPreviewPlayer = () =>
4541 // -------------------------------------------------------------------------
4332 {
4542
4333 if (imageSubtitleController)
4543 let sentPartway = false;
4544 let sentFully = false;
4545 const markWatch = async () =>
4334 {
4546 {
4335 try { imageSubtitleController.captureSelectedTracks(); } catch { /* ignore */ }
4547 let ratio = 0;
4336 try { imageSubtitleController.detach(); } catch { /* ignore */ }
4548 try
4549 {
4550 const duration = Number(player.duration());
4551 const current = Number(player.currentTime());
4552 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
4553 {
4554 ratio = current / duration;
4555 }
4556 } catch
4557 {
4558 return;
4559 }
4560
4561 if (ratio >= 0.7)
4562 {
4563 if (sentFully) return;
4564 sentPartway = true;
4565 sentFully = true;
4566 void reportWatchProgress(item.path, ratio);
4567 return;
4568 }
4569
4570 if (ratio >= 0.05)
4571 {
4572 if (sentPartway) return;
4573 sentPartway = true;
4574 void reportWatchProgress(item.path, ratio);
4575 }
4576 };
4577
4578 player.ready(() =>
4579 {
4580 const volume = Number(prefs.volume);
4581 if (Number.isFinite(volume))
4582 {
4583 player.volume(Math.max(0, Math.min(1, volume)));
4584 }
4585
4586 const settings = player && player.textTrackSettings;
4587 if (settings && typeof settings.setValues === 'function' && typeof settings.updateDisplay === 'function')
4588 {
4589 settings.setValues({
4590 backgroundColor: '#000',
4591 backgroundOpacity: '0',
4592 edgeStyle: 'uniform',
4593 });
4594 settings.updateDisplay();
4595 }
4596
4597 resources.trackPrefs.applySavedTracks();
4598 });
4599
4600 player.on('loadedmetadata', resources.trackPrefs.applySavedTracks);
4601 player.on('loadedplaylist', resources.trackPrefs.applySavedTracks);
4602 player.on('timeupdate', markWatch);
4603 player.on('ended', () =>
4604 {
4605 sentPartway = true;
4606 sentFully = true;
4607 void reportWatchProgress(item.path, 1);
4608 });
4609 player.on('volumechange', () =>
4610 {
4611 const v = Number(player.volume());
4612 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
4613 });
4614
4615 const cleanupPreviewPlayer = () =>
4616 {
4617 if (!previewFailed) hidePreviewLoading();
4618 if (resources.imageSubtitleController)
4619 {
4620 try { resources.imageSubtitleController.captureSelectedTracks(); } catch { /* ignore */ }
4621 try { resources.imageSubtitleController.detach(); } catch { /* ignore */ }
4622 }
4623 try { resources.streamAheadSeekMarker && resources.streamAheadSeekMarker.detach(); } catch { /* ignore */ }
4624 try { resources.streamAheadPrefetch && resources.streamAheadPrefetch.stop(); } catch { /* ignore */ }
4625 void clearVideoStreamClientCache(resources.sessionPlaylistUrl);
4626 releaseActivePreviewVideoStreamSession();
4627 try { markWatch(); } catch { /* ignore */ }
4628 try { resources.trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
4629 try { resources.trackPrefs.detach(); } catch { /* ignore */ }
4630 try { player.dispose(); } catch { /* ignore */ }
4631 };
4632
4633 if (isStaleInit())
4634 {
4635 cleanupPreviewPlayer();
4636 return;
4337 }
4637 }
4338 try { streamAheadSeekMarker && streamAheadSeekMarker.detach(); } catch { /* ignore */ }
4339 try { streamAheadPrefetch && streamAheadPrefetch.stop(); } catch { /* ignore */ }
4340 void clearVideoStreamClientCache(sessionPlaylistUrl);
4341 releaseActivePreviewVideoStreamSession();
4342 try { markWatch(); } catch { /* ignore */ }
4343 try { trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
4344 try { trackPrefs.detach(); } catch { /* ignore */ }
4345 try { player.dispose(); } catch { /* ignore */ }
4346 };
4347
4638
4348 if (isStaleInit())
4639 if (!previewFailed)
4640 {
4641 STATE.previewCleanup = cleanupPreviewPlayer;
4642 }
4643 }
4644 catch (err)
4349 {
4645 {
4350 cleanupPreviewPlayer();
4646 if (isStaleInit())
4351 return;
4647 {
4648 abortLoading();
4649 releaseSessionIfNeeded(session);
4650 return;
4651 }
4652 const fallback = 'Video preview failed to load. You can try again or download the file.';
4653 failPreview(err && err.message ? String(err.message) : fallback);
4352 }
4654 }
4353
4354 STATE.previewCleanup = cleanupPreviewPlayer;
4355}
4655}
4356
4656
4357function fileAccentColor (name)
4657function fileAccentColor (name)
@@ -4488,39 +4788,19 @@ async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewCo
4488 return;
4788 return;
4489 }
4789 }
4490
4790
4491 const needsAsyncDownload = !previewObjectUrlIsDownloadableOriginal(previewItem);
4492 const popup = needsAsyncDownload ? window.open('', '_blank') : null;
4493 if (popup)
4494 {
4495 try
4496 {
4497 popup.document.title = previewItem.name;
4498 popup.document.body.textContent = 'Preparing download…';
4499 }
4500 catch { /* ignore */ }
4501 }
4502
4503 if (previewObjectUrlIsDownloadableOriginal(previewItem))
4791 if (previewObjectUrlIsDownloadableOriginal(previewItem))
4504 {
4792 {
4505 if (popup)
4506 {
4507 try { popup.close(); } catch { /* ignore */ }
4508 }
4509 triggerDownload(previewItem.name, STATE.previewObjectUrl);
4793 triggerDownload(previewItem.name, STATE.previewObjectUrl);
4510 return;
4794 return;
4511 }
4795 }
4512
4796
4513 if (!needsAsyncDownload)
4797 if (VIDEO_EXTS.has(extOf(previewItem.name)) || AUDIO_EXTS.has(extOf(previewItem.name)))
4514 {
4798 {
4515 if (popup)
4799 void downloadFileItem(previewItem);
4516 {
4517 try { popup.close(); } catch { /* ignore */ }
4518 }
4519 toast('Preview still loading.', 'err');
4520 return;
4800 return;
4521 }
4801 }
4522
4802
4523 void downloadFileItem(previewItem, { popup });
4803 toast('Preview still loading.', 'err');
4524 });
4804 });
4525
4805
4526 const shareBtn = document.createElement('button');
4806 const shareBtn = document.createElement('button');
@@ -4551,10 +4831,8 @@ async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewCo
4551 previewMount.className = 'preview-expand-content';
4831 previewMount.className = 'preview-expand-content';
4552 iconEl.appendChild(previewMount);
4832 iconEl.appendChild(previewMount);
4553
4833
4554 // Show spinner during expansion animation; content loads after it finishes
4834 // Spinner during expansion; video preview keeps an overlay until the player is ready.
4555 const spinner = document.createElement('div');
4835 attachPreviewLoadingOverlay(previewMount, { showPercent: VIDEO_EXTS.has(extOf(item.name)) });
4556 spinner.className = 'preview-loading-spinner';
4557 previewMount.appendChild(spinner);
4558
4836
4559 tileEl.insertBefore(titleEl, tileEl.firstChild);
4837 tileEl.insertBefore(titleEl, tileEl.firstChild);
4560 tileEl.appendChild(closeBtn);
4838 tileEl.appendChild(closeBtn);
@@ -5058,7 +5336,7 @@ async function downloadOrView (item, sourceSvgEl = null)
5058 if (VIDEO_EXTS.has(extOf(item.name)))
5336 if (VIDEO_EXTS.has(extOf(item.name)))
5059 {
5337 {
5060 clearPreviewObjectUrl();
5338 clearPreviewObjectUrl();
5061 previewMount.innerHTML = '';
5339 previewMount.querySelectorAll('.preview-video-js, video, .preview-media').forEach((el) => el.remove());
5062 await renderStreamedVideoPreview(item, previewMount);
5340 await renderStreamedVideoPreview(item, previewMount);
5063 return;
5341 return;
5064 }
5342 }
public/drag-move.css +34 −0
@@ -337,6 +337,22 @@
337 337 }
338 338
339 339 /* Spinner shown inside the expanded tile while content is loading */
340 .preview-loading-overlay {
341 position: absolute;
342 inset: 0;
343 z-index: 5;
344 display: flex;
345 align-items: center;
346 justify-content: center;
347 pointer-events: none;
348 }
349
350 .preview-loading-indicator {
351 position: relative;
352 width: 52px;
353 height: 52px;
354 }
355
340 356 .preview-loading-spinner {
341 357 width: 40px;
342 358 height: 40px;
@@ -346,6 +362,24 @@
346 362 animation: preview-spin 0.7s linear infinite;
347 363 }
348 364
365 .preview-loading-indicator .preview-loading-spinner {
366 width: 100%;
367 height: 100%;
368 }
369
370 .preview-loading-percent {
371 position: absolute;
372 inset: 0;
373 display: flex;
374 align-items: center;
375 justify-content: center;
376 font-size: 0.68rem;
377 font-weight: 600;
378 letter-spacing: -0.02em;
379 color: rgba(255, 255, 255, 0.88);
380 text-shadow: 0 1px 4px rgba(0, 0, 0, 0.55);
381 }
382
349 383 @keyframes preview-spin {
350 384 to {
351 385 transform: rotate(360deg);
@@ -337,6 +337,22 @@
337}
337}
338
338
339/* Spinner shown inside the expanded tile while content is loading */
339/* Spinner shown inside the expanded tile while content is loading */
340.preview-loading-overlay {
341 position: absolute;
342 inset: 0;
343 z-index: 5;
344 display: flex;
345 align-items: center;
346 justify-content: center;
347 pointer-events: none;
348}
349
350.preview-loading-indicator {
351 position: relative;
352 width: 52px;
353 height: 52px;
354}
355
340.preview-loading-spinner {
356.preview-loading-spinner {
341 width: 40px;
357 width: 40px;
342 height: 40px;
358 height: 40px;
@@ -346,6 +362,24 @@
346 animation: preview-spin 0.7s linear infinite;
362 animation: preview-spin 0.7s linear infinite;
347}
363}
348
364
365.preview-loading-indicator .preview-loading-spinner {
366 width: 100%;
367 height: 100%;
368}
369
370.preview-loading-percent {
371 position: absolute;
372 inset: 0;
373 display: flex;
374 align-items: center;
375 justify-content: center;
376 font-size: 0.68rem;
377 font-weight: 600;
378 letter-spacing: -0.02em;
379 color: rgba(255, 255, 255, 0.88);
380 text-shadow: 0 1px 4px rgba(0, 0, 0, 0.55);
381}
382
349@keyframes preview-spin {
383@keyframes preview-spin {
350 to {
384 to {
351 transform: rotate(360deg);
385 transform: rotate(360deg);
tests/page.load.test.js +111 −12
@@ -265,6 +265,8 @@ describe('page load smoke test', () =>
265 265 let blobCounter = 0;
266 266 window.URL.createObjectURL = () => `blob:mock-${blobCounter++}`;
267 267 window.URL.revokeObjectURL = () => { };
268 window.__mockVideoJsSuppressReadyEvents = false;
269 window.__mockVideoJsError = null;
268 270 window.__lastVideoJsOptions = null;
269 271 window.__lastVideoJsVolumeSet = null;
270 272 window.__lastVideoJsPlayer = null;
@@ -349,6 +351,20 @@ describe('page load smoke test', () =>
349 351 if (!listenersByType.has(type)) listenersByType.set(type, new Set());
350 352 listenersByType.get(type).add(fn);
351 353 },
354 one (type, fn)
355 {
356 const wrapper = () =>
357 {
358 const listeners = listenersByType.get(type);
359 if (listeners) listeners.delete(wrapper);
360 fn();
361 };
362 this.on(type, wrapper);
363 },
364 bufferedPercent ()
365 {
366 return 0.35;
367 },
352 368 trigger (type)
353 369 {
354 370 const listeners = listenersByType.get(type);
@@ -371,9 +387,22 @@ describe('page load smoke test', () =>
371 387 window.__lastVideoJsVolumeSet = volumeValue;
372 388 return volumeValue;
373 389 },
390 error ()
391 {
392 return window.__mockVideoJsError || null;
393 },
374 394 dispose () { },
375 395 };
396 window.__mockVideoJsError = null;
376 397 window.__lastVideoJsPlayer = player;
398 if (!window.__mockVideoJsSuppressReadyEvents)
399 {
400 window.setTimeout(() =>
401 {
402 player.trigger('canplay');
403 player.trigger('loadeddata');
404 }, 0);
405 }
377 406 return player;
378 407 };
379 408
@@ -1666,6 +1695,78 @@ describe('page load smoke test', () =>
1666 1695 dom.window.close();
1667 1696 });
1668 1697
1698 test('expanded video preview shows an error when the stream session fails', async () =>
1699 {
1700 jest.setTimeout(15000);
1701 listFixture['/data'] = [
1702 {
1703 name: 'clip.mkv',
1704 path: '/data/clip.mkv',
1705 isDir: false,
1706 size: 64,
1707 mtime: Date.now(),
1708 },
1709 ];
1710
1711 const { dom, runtimeErrors } = await bootClient();
1712 expect(runtimeErrors).toEqual([]);
1713
1714 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1715
1716 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1717 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1718
1719 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
1720 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1721 expect(fallback.textContent).toMatch(/stream not found|could not be started/i);
1722 expect(dom.window.document.querySelector('.preview-loading-overlay')).toBeFalsy();
1723 expect(dom.window.document.querySelector('.preview-video-js')).toBeFalsy();
1724
1725 dom.window.close();
1726 });
1727
1728 test('expanded video preview shows an error when video.js reports a playback error', async () =>
1729 {
1730 listFixture['/data'] = [
1731 {
1732 name: 'clip.mkv',
1733 path: '/data/clip.mkv',
1734 isDir: false,
1735 size: 64,
1736 mtime: Date.now(),
1737 },
1738 ];
1739 videoStreamFixture['/data/clip.mkv'] = {
1740 sessionId: 'video-session',
1741 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1742 durationSeconds: 120,
1743 subtitleTracks: [],
1744 };
1745
1746 const { dom, runtimeErrors } = await bootClient();
1747 expect(runtimeErrors).toEqual([]);
1748
1749 dom.window.__mockVideoJsError = { code: 4, message: 'MEDIA_ERR_SRC_NOT_SUPPORTED' };
1750 dom.window.__mockVideoJsSuppressReadyEvents = true;
1751
1752 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1753
1754 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1755 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1756 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1757
1758 dom.window.__lastVideoJsPlayer.trigger('error');
1759
1760 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
1761 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1762 expect(fallback.textContent).toMatch(/playback failed/i);
1763 expect(dom.window.document.querySelector('.preview-loading-overlay')).toBeFalsy();
1764
1765 dom.window.__mockVideoJsSuppressReadyEvents = false;
1766 dom.window.__mockVideoJsError = null;
1767 dom.window.close();
1768 });
1769
1669 1770 test('expanded video preview download fetches the original file', async () =>
1670 1771 {
1671 1772 listFixture['/data'] = [
@@ -1692,18 +1793,13 @@ describe('page load smoke test', () =>
1692 1793 expect(runtimeErrors).toEqual([]);
1693 1794
1694 1795 const downloadUrls = [];
1695 let popupHref = '';
1696 const popup = {
1697 location: {},
1698 close () { },
1699 };
1700 Object.defineProperty(popup.location, 'href', {
1701 get () { return popupHref; },
1702 set (value) { popupHref = String(value || ''); },
1703 configurable: true,
1704 });
1796 let openCalled = false;
1705 1797 const nativeFetch = dom.window.fetch.bind(dom.window);
1706 dom.window.open = () => popup;
1798 dom.window.open = () =>
1799 {
1800 openCalled = true;
1801 return null;
1802 };
1707 1803 dom.window.fetch = (input, init) =>
1708 1804 {
1709 1805 const url = typeof input === 'string' ? input : input.url;
@@ -1723,8 +1819,10 @@ describe('page load smoke test', () =>
1723 1819 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
1724 1820 downloadBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1725 1821
1726 await waitFor(dom, () => downloadUrls.length > 0 && popupHref.startsWith('blob:'));
1822 await waitFor(dom, () => downloadUrls.length > 0);
1727 1823 expect(downloadUrls[0]).toContain(encodeURIComponent('/data/clip.mkv'));
1824 expect(openCalled).toBe(false);
1825 await new Promise((resolve) => { dom.window.setTimeout(resolve, 50); });
1728 1826
1729 1827 dom.window.close();
1730 1828 });
@@ -1801,6 +1899,7 @@ describe('page load smoke test', () =>
1801 1899
1802 1900 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1803 1901 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1902 await waitFor(dom, () => !dom.window.document.querySelector('.preview-loading-overlay'));
1804 1903
1805 1904 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
1806 1905 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
@@ -265,6 +265,8 @@ describe('page load smoke test', () =>
265 let blobCounter = 0;
265 let blobCounter = 0;
266 window.URL.createObjectURL = () => `blob:mock-${blobCounter++}`;
266 window.URL.createObjectURL = () => `blob:mock-${blobCounter++}`;
267 window.URL.revokeObjectURL = () => { };
267 window.URL.revokeObjectURL = () => { };
268 window.__mockVideoJsSuppressReadyEvents = false;
269 window.__mockVideoJsError = null;
268 window.__lastVideoJsOptions = null;
270 window.__lastVideoJsOptions = null;
269 window.__lastVideoJsVolumeSet = null;
271 window.__lastVideoJsVolumeSet = null;
270 window.__lastVideoJsPlayer = null;
272 window.__lastVideoJsPlayer = null;
@@ -349,6 +351,20 @@ describe('page load smoke test', () =>
349 if (!listenersByType.has(type)) listenersByType.set(type, new Set());
351 if (!listenersByType.has(type)) listenersByType.set(type, new Set());
350 listenersByType.get(type).add(fn);
352 listenersByType.get(type).add(fn);
351 },
353 },
354 one (type, fn)
355 {
356 const wrapper = () =>
357 {
358 const listeners = listenersByType.get(type);
359 if (listeners) listeners.delete(wrapper);
360 fn();
361 };
362 this.on(type, wrapper);
363 },
364 bufferedPercent ()
365 {
366 return 0.35;
367 },
352 trigger (type)
368 trigger (type)
353 {
369 {
354 const listeners = listenersByType.get(type);
370 const listeners = listenersByType.get(type);
@@ -371,9 +387,22 @@ describe('page load smoke test', () =>
371 window.__lastVideoJsVolumeSet = volumeValue;
387 window.__lastVideoJsVolumeSet = volumeValue;
372 return volumeValue;
388 return volumeValue;
373 },
389 },
390 error ()
391 {
392 return window.__mockVideoJsError || null;
393 },
374 dispose () { },
394 dispose () { },
375 };
395 };
396 window.__mockVideoJsError = null;
376 window.__lastVideoJsPlayer = player;
397 window.__lastVideoJsPlayer = player;
398 if (!window.__mockVideoJsSuppressReadyEvents)
399 {
400 window.setTimeout(() =>
401 {
402 player.trigger('canplay');
403 player.trigger('loadeddata');
404 }, 0);
405 }
377 return player;
406 return player;
378 };
407 };
379
408
@@ -1666,6 +1695,78 @@ describe('page load smoke test', () =>
1666 dom.window.close();
1695 dom.window.close();
1667 });
1696 });
1668
1697
1698 test('expanded video preview shows an error when the stream session fails', async () =>
1699 {
1700 jest.setTimeout(15000);
1701 listFixture['/data'] = [
1702 {
1703 name: 'clip.mkv',
1704 path: '/data/clip.mkv',
1705 isDir: false,
1706 size: 64,
1707 mtime: Date.now(),
1708 },
1709 ];
1710
1711 const { dom, runtimeErrors } = await bootClient();
1712 expect(runtimeErrors).toEqual([]);
1713
1714 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1715
1716 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1717 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1718
1719 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
1720 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1721 expect(fallback.textContent).toMatch(/stream not found|could not be started/i);
1722 expect(dom.window.document.querySelector('.preview-loading-overlay')).toBeFalsy();
1723 expect(dom.window.document.querySelector('.preview-video-js')).toBeFalsy();
1724
1725 dom.window.close();
1726 });
1727
1728 test('expanded video preview shows an error when video.js reports a playback error', async () =>
1729 {
1730 listFixture['/data'] = [
1731 {
1732 name: 'clip.mkv',
1733 path: '/data/clip.mkv',
1734 isDir: false,
1735 size: 64,
1736 mtime: Date.now(),
1737 },
1738 ];
1739 videoStreamFixture['/data/clip.mkv'] = {
1740 sessionId: 'video-session',
1741 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1742 durationSeconds: 120,
1743 subtitleTracks: [],
1744 };
1745
1746 const { dom, runtimeErrors } = await bootClient();
1747 expect(runtimeErrors).toEqual([]);
1748
1749 dom.window.__mockVideoJsError = { code: 4, message: 'MEDIA_ERR_SRC_NOT_SUPPORTED' };
1750 dom.window.__mockVideoJsSuppressReadyEvents = true;
1751
1752 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1753
1754 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1755 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1756 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1757
1758 dom.window.__lastVideoJsPlayer.trigger('error');
1759
1760 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
1761 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1762 expect(fallback.textContent).toMatch(/playback failed/i);
1763 expect(dom.window.document.querySelector('.preview-loading-overlay')).toBeFalsy();
1764
1765 dom.window.__mockVideoJsSuppressReadyEvents = false;
1766 dom.window.__mockVideoJsError = null;
1767 dom.window.close();
1768 });
1769
1669 test('expanded video preview download fetches the original file', async () =>
1770 test('expanded video preview download fetches the original file', async () =>
1670 {
1771 {
1671 listFixture['/data'] = [
1772 listFixture['/data'] = [
@@ -1692,18 +1793,13 @@ describe('page load smoke test', () =>
1692 expect(runtimeErrors).toEqual([]);
1793 expect(runtimeErrors).toEqual([]);
1693
1794
1694 const downloadUrls = [];
1795 const downloadUrls = [];
1695 let popupHref = '';
1796 let openCalled = false;
1696 const popup = {
1697 location: {},
1698 close () { },
1699 };
1700 Object.defineProperty(popup.location, 'href', {
1701 get () { return popupHref; },
1702 set (value) { popupHref = String(value || ''); },
1703 configurable: true,
1704 });
1705 const nativeFetch = dom.window.fetch.bind(dom.window);
1797 const nativeFetch = dom.window.fetch.bind(dom.window);
1706 dom.window.open = () => popup;
1798 dom.window.open = () =>
1799 {
1800 openCalled = true;
1801 return null;
1802 };
1707 dom.window.fetch = (input, init) =>
1803 dom.window.fetch = (input, init) =>
1708 {
1804 {
1709 const url = typeof input === 'string' ? input : input.url;
1805 const url = typeof input === 'string' ? input : input.url;
@@ -1723,8 +1819,10 @@ describe('page load smoke test', () =>
1723 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
1819 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
1724 downloadBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1820 downloadBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1725
1821
1726 await waitFor(dom, () => downloadUrls.length > 0 && popupHref.startsWith('blob:'));
1822 await waitFor(dom, () => downloadUrls.length > 0);
1727 expect(downloadUrls[0]).toContain(encodeURIComponent('/data/clip.mkv'));
1823 expect(downloadUrls[0]).toContain(encodeURIComponent('/data/clip.mkv'));
1824 expect(openCalled).toBe(false);
1825 await new Promise((resolve) => { dom.window.setTimeout(resolve, 50); });
1728
1826
1729 dom.window.close();
1827 dom.window.close();
1730 });
1828 });
@@ -1801,6 +1899,7 @@ describe('page load smoke test', () =>
1801
1899
1802 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1900 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1803 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1901 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1902 await waitFor(dom, () => !dom.window.document.querySelector('.preview-loading-overlay'));
1804
1903
1805 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
1904 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
1806 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
1905 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');