daniel-c-harvey
77 lines
3.5 KiB
C#
77 lines
3.5 KiB
C#
using DeepDrftModels.DTOs;
|
|
using DeepDrftPublic.Client.ViewModels;
|
|
using Microsoft.AspNetCore.Components;
|
|
|
|
namespace DeepDrftPublic.Client.Pages;
|
|
|
|
/// <summary>
|
|
/// Shared load + prerender-bridge logic for the single-release detail pages (Session, Mix).
|
|
/// Subclasses supply only their markup; this base loads the release through
|
|
/// <see cref="ReleaseDetailViewModel"/> and bridges the prerendered release across the prerender ->
|
|
/// WASM seam so the WASM pass does not re-fetch (see the MediumBrowseBase seam). The playable track is
|
|
/// re-resolved on a restore miss only.
|
|
/// </summary>
|
|
public abstract class ReleaseDetailBase : ComponentBase, IDisposable
|
|
{
|
|
[Parameter] public string EntryKey { get; set; } = string.Empty;
|
|
[Inject] public required ReleaseDetailViewModel ViewModel { get; set; }
|
|
[Inject] public required PersistentComponentState PersistentState { get; set; }
|
|
|
|
private PersistingComponentStateSubscription _persistingSubscription;
|
|
|
|
// The release EntryKey the ViewModel currently holds. Tracks param-only navigations (e.g.
|
|
// /mixes/{a} -> /mixes/{b}) which reuse this component instance and fire OnParametersSet
|
|
// without re-running OnInitialized — without this, the page would keep the prior
|
|
// release's track and Play would stream the wrong audio.
|
|
private string? _loadedKey;
|
|
private bool _loaded;
|
|
|
|
// Distinct keys per medium so a Session restore never lands on a Mix page.
|
|
protected abstract string PersistKey { get; }
|
|
|
|
protected override void OnInitialized()
|
|
=> _persistingSubscription = PersistentState.RegisterOnPersisting(Persist);
|
|
|
|
protected override async Task OnParametersSetAsync()
|
|
{
|
|
// Re-run whenever the route key changes. Component instances are reused across
|
|
// same-template navigations, so the load decision must live here, not in
|
|
// OnInitialized (which fires once per instance).
|
|
if (_loaded && _loadedKey == EntryKey) return;
|
|
|
|
// Capture the key synchronously before any await so that a re-entrant call
|
|
// (rapid navigation or a re-render that changes EntryKey while Load is in flight)
|
|
// sees the correct guard state. Without this, a second OnParametersSetAsync
|
|
// for the same key would bypass the guard above and start a second Load,
|
|
// causing two ViewModel.Load calls to race on the single scoped instance.
|
|
_loadedKey = EntryKey;
|
|
_loaded = true;
|
|
|
|
// The bridged payload carries both the release and its resolved track so the interactive
|
|
// pass renders identically without a second round-trip. Guard on the key: a payload for a
|
|
// different release must not seed this page (stale-bridge bleed across navigation).
|
|
if (PersistentState.TryTakeFromJson<BridgedDetail>(PersistKey, out var restored)
|
|
&& restored?.Release is not null
|
|
&& restored.Release.EntryKey == EntryKey)
|
|
{
|
|
ViewModel.Restore(restored.Release, restored.Track);
|
|
}
|
|
else
|
|
{
|
|
await ViewModel.Load(EntryKey);
|
|
}
|
|
}
|
|
|
|
private Task Persist()
|
|
{
|
|
if (ViewModel.Release is not null)
|
|
PersistentState.PersistAsJson(PersistKey, new BridgedDetail(ViewModel.Release, ViewModel.Track));
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public void Dispose() => _persistingSubscription.Dispose();
|
|
|
|
// JSON-serializable bridge payload. Round-trips through PersistentComponentState's serializer.
|
|
protected sealed record BridgedDetail(ReleaseDto Release, TrackDto? Track);
|
|
}
|