MudDialogProvider: Add CloseOnNavigation to DialogOptions to optionally close dialogs on navigation

src/MudBlazor.Docs/Pages/Components/Dialog/Examples/DialogSetOptionsExample_Dialog.razor

@@ -1,4 +1,7 @@
-@namespace MudBlazor.Docs.Examples
+@using System.Web
+@namespace MudBlazor.Docs.Examples
+
+@inject NavigationManager NavigationManager
 
 <MudDialog>
     <DialogContent>
@@ -7,6 +10,8 @@
             <MudButton OnClick="ToggleCloseButtonAsync">Toggle Close Button</MudButton>
             <MudButton OnClick="ToggleFullWidthAsync">Toggle Full Width</MudButton>
             <MudButton OnClick="ToggleHeaderAsync">Toggle Header</MudButton>
+            <MudCheckBox TriState="true" T="bool?" Value="MudDialog.Options.CloseOnNavigation" ValueChanged="@(async v => await CloseOnNavigationChangedAsync(v))">Close On Navigation</MudCheckBox>
+            <MudButton OnClick="ChangeUrl">Change Url</MudButton>
         </div>
     </DialogContent>
     <DialogActions>
@@ -18,6 +23,13 @@
     [CascadingParameter]
     private IMudDialogInstance MudDialog { get; set; }
 
+    [SupplyParameterFromQuery(Name = "example")]
+    public int? QueryParameterExample { get; set; }
+
+    protected override void OnParametersSet() {
+        QueryParameterExample ??= 0;
+    }
+
     private void Close() => MudDialog.Close(DialogResult.Ok(true));
 
     private Task ChangeTitleAsync() => MudDialog.SetTitleAsync($"Current time is: {DateTime.Now}");
@@ -51,4 +63,26 @@
 
         return MudDialog.SetOptionsAsync(options);
     }
+
+    private void ChangeUrl() {
+        var uri = new Uri(NavigationManager.Uri);
+
+        var query = HttpUtility.ParseQueryString(uri.Query);
+
+        query["example"] = (QueryParameterExample + 1).ToString();
+
+        var newUri = $"{uri.GetLeftPart(UriPartial.Path)}?{query}";
+
+        NavigationManager.NavigateTo(newUri);
+    }
+
+    private Task CloseOnNavigationChangedAsync(bool? closeOnNavigation)
+    {
+        var options = MudDialog.Options with
+        {
+            CloseOnNavigation = closeOnNavigation
+        };
+
+        return MudDialog.SetOptionsAsync(options);
+    }
 }

src/MudBlazor.UnitTests.Shared/Extensions/TestContextExtensions.cs

@@ -1,8 +1,8 @@
 using Bunit;
+using Bunit.TestDoubles;
 using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.DependencyInjection;
 using MudBlazor.Services;
-using MudBlazor.UnitTests.Shared.Mocks;
 
 namespace MudBlazor.UnitTests.Shared.Extensions
 {
@@ -11,7 +11,7 @@ public static class TestContextExtensions
         public static void AddTestServices(this BunitContext ctx)
         {
             ctx.JSInterop.Mode = JSRuntimeMode.Loose;
-            ctx.Services.AddSingleton<NavigationManager>(new MockNavigationManager());
+            ctx.Services.AddSingleton<NavigationManager>(new BunitNavigationManager(ctx));
             ctx.Services.AddMudServices(options =>
             {
                 options.SnackbarConfiguration.ShowTransitionDuration = 0;

src/MudBlazor.UnitTests/Components/DialogTests.cs

@@ -1,4 +1,5 @@
-using AwesomeAssertions;
+using System.Web;
+using AwesomeAssertions;
 using Bunit;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
@@ -91,6 +92,39 @@ public async Task Simple()
             result.Canceled.Should().BeFalse();
         }
 
+        /// <summary>
+        /// Opening and closing dialogs via navigation.
+        /// </summary>
+        [Test]
+        public async Task CloseOnNavigationTest()
+        {
+            var comp = Context.Render<MudDialogProvider>();
+            comp.Markup.Trim().Should().BeEmpty();
+            var dialogService = Context.Services.GetRequiredService<IDialogService>();
+            dialogService.Should().NotBe(null);
+            var navigationManager = Context.Services.GetRequiredService<NavigationManager>();
+            navigationManager.Should().NotBe(null);
+
+            //create 2 instances and dismiss all except for one with CloseOnNavigation = false
+            var closeOnNavigationOptions = new DialogOptions
+            {
+                CloseOnNavigation = false
+            };
+            await comp.InvokeAsync(async () => _ = await dialogService.ShowAsync<DialogOkCancel>("test", options: closeOnNavigationOptions));
+            await comp.InvokeAsync(async () => _ = await dialogService.ShowAsync<DialogOkCancel>());
+            var cont = comp.FindAll("div.mud-dialog-container");
+            cont.Count.Should().Be(2);
+
+            var uri = new Uri(navigationManager.Uri);
+            var query = HttpUtility.ParseQueryString(uri.Query);
+            query["query"] = Guid.NewGuid().ToString();
+            var newUri = $"{uri.GetLeftPart(UriPartial.Path)}?{query}";
+            await comp.InvokeAsync(() => navigationManager.NavigateTo(newUri));
+
+            cont = comp.FindAll("div.mud-dialog-container");
+            cont.Count.Should().Be(1);
+        }
+
         /// <summary>
         /// <para>Opening and closing an inline dialog. Click on open will open the inlined dialog.</para>
         /// <para>
@@ -1497,6 +1531,170 @@ await comp.InvokeAsync(async () =>
             closeBtn.Should().NotBeNull();
             closeBtn.GetAttribute("blazor:onmousedown:preventdefault").Should().Be("");
         }
+
+        /// <summary>
+        /// InjectOptions() should set the options of the calling IDialogReference.
+        /// </summary>
+        [Test]
+        public async Task InjectOptions_ShouldNotBeNull()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+
+            reference.InjectOptions(new DialogOptions());
+            reference.Options.Should().NotBe(null);
+        }
+
+        /// <summary>
+        /// SetOptions() should set the options of the dialog reference that corresponds to the given id.
+        /// </summary>
+        [Test]
+        public async Task SetOptions_ShouldNotBeNull()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+
+            provider.Instance.SetOptions(reference.Id, new DialogOptions());
+            reference.Options.Should().NotBe(null);
+        }
+
+        /// <summary>
+        /// ShouldDismissOnNavigation() should return true if the dialog reference's options CloseOnNavigation is set to true.
+        /// </summary>
+        [Test]
+        public async Task ShouldDismissOnNavigation_ShouldBeTrue()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var options = new DialogOptions
+            {
+                CloseOnNavigation = true
+            };
+            var reference = await service.ShowAsync<DialogOkCancel>("test", options: options);
+
+            provider.Instance.ShouldDismissOnNavigation(reference, "/test").Should().BeTrue();
+        }
+
+        /// <summary>
+        /// ShouldDismissOnNavigation() should return false if the dialog reference's options CloseOnNavigation is set to false.
+        /// </summary>
+        [Test]
+        public async Task ShouldDismissOnNavigation_ShouldBeFalse()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+            var options = new DialogOptions
+            {
+                CloseOnNavigation = false
+            };
+            reference.InjectOptions(options);
+
+            provider.Instance.ShouldDismissOnNavigation(reference, "/test").Should().BeFalse();
+        }
+
+        /// <summary>
+        /// HasRouteChanged() should return true if the dialog reference's options
+        /// CloseOnNavigation is set to null and the absolute path has changed.
+        /// </summary>
+        [Test]
+        public async Task HasRouteChanged_ShouldBeTrueWhenCloseOnNavigationIsNullAndRouteChanged()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var navigationManager = Context.Services.GetRequiredService<NavigationManager>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var currentRoute = navigationManager.ToAbsoluteUri($"/test/{Guid.NewGuid()}").ToString();
+            navigationManager.NavigateTo(currentRoute);
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+            var options = new DialogOptions
+            {
+                CloseOnNavigation = null
+            };
+            reference.InjectOptions(options);
+
+            var changedRoute = navigationManager.ToAbsoluteUri($"{currentRoute}/{Guid.NewGuid()}").AbsolutePath.TrimEnd('/');
+            provider.Instance.HasRouteChanged(changedRoute).Should().BeTrue();
+        }
+
+        /// <summary>
+        /// HasRouteChanged() should return false if the dialog reference's options
+        /// CloseOnNavigation is set to null and only the query or fragment has changed.
+        /// </summary>
+        [Test]
+        public async Task HasRouteChanged_ShouldBeFalseWhenCloseOnNavigationIsNullAndQueryOrFragmentChanged()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var navigationManager = Context.Services.GetRequiredService<NavigationManager>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var currentRoute = navigationManager.ToAbsoluteUri($"/test/{Guid.NewGuid()}").ToString();
+            navigationManager.NavigateTo(currentRoute);
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+            var options = new DialogOptions
+            {
+                CloseOnNavigation = null
+            };
+            reference.InjectOptions(options);
+
+            var changedQuery = navigationManager.ToAbsoluteUri($"{currentRoute}?query={Guid.NewGuid()}").AbsolutePath;
+            provider.Instance.HasRouteChanged(changedQuery).Should().BeFalse();
+
+            var changedFragment = navigationManager.ToAbsoluteUri($"{currentRoute}#{Guid.NewGuid()}").AbsolutePath;
+            provider.Instance.HasRouteChanged(changedFragment).Should().BeFalse();
+        }
+
+        /// <summary>
+        /// HasRouteChanged() should return true if the dialog reference's options is set to null
+        /// and the absolute path has changed.
+        /// </summary>
+        [Test]
+        public async Task HasRouteChanged_ShouldBeTrueWhenOptionsIsNullAndRouteChanged()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var navigationManager = Context.Services.GetRequiredService<NavigationManager>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var currentRoute = navigationManager.ToAbsoluteUri($"/test/{Guid.NewGuid()}").ToString();
+            navigationManager.NavigateTo(currentRoute);
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+            reference.InjectOptions(null);
+
+            var changedRoute = navigationManager.ToAbsoluteUri($"{currentRoute}/{Guid.NewGuid()}").AbsolutePath.TrimEnd('/');
+            provider.Instance.HasRouteChanged(changedRoute).Should().BeTrue();
+        }
+
+        /// <summary>
+        /// HasRouteChanged() should return false if the dialog reference's options is set to null
+        /// and only the query or fragment has changed.
+        /// </summary>
+        [Test]
+        public async Task HasRouteChanged_ShouldBeFalseWhenOptionsIsNullAndQueryOrFragmentChanged()
+        {
+            var service = Context.Services.GetRequiredService<IDialogService>();
+            var navigationManager = Context.Services.GetRequiredService<NavigationManager>();
+            var provider = Context.Render<MudDialogProvider>();
+
+            var currentRoute = navigationManager.ToAbsoluteUri($"/test/{Guid.NewGuid()}").ToString();
+            navigationManager.NavigateTo(currentRoute);
+
+            var reference = await service.ShowAsync<DialogOkCancel>();
+            reference.InjectOptions(null);
+
+            var changedQuery = navigationManager.ToAbsoluteUri($"{currentRoute}?query={Guid.NewGuid()}").AbsolutePath;
+            provider.Instance.HasRouteChanged(changedQuery).Should().BeFalse();
+
+            var changedFragment = navigationManager.ToAbsoluteUri($"{currentRoute}#{Guid.NewGuid()}").AbsolutePath;
+            provider.Instance.HasRouteChanged(changedFragment).Should().BeFalse();
+        }
     }
     internal class CustomDialogService : DialogService
     {

src/MudBlazor/Components/Dialog/MudDialogContainer.razor.cs

@@ -334,6 +334,7 @@ public async ValueTask DisposeAsync()
         async Task IMudDialogInstance.SetOptionsAsync(DialogOptions options)
         {
             await _dialogOptionsState.SetValueAsync(options);
+            Parent.SetOptions(Id, options);
             await InvokeAsync(StateHasChanged);
         }
 

src/MudBlazor/Components/Dialog/MudDialogProvider.razor.cs

@@ -25,6 +25,7 @@ public partial class MudDialogProvider : IDisposable
     {
         private DialogOptions _globalDialogOptions = new();
         private readonly List<IDialogReference> _dialogs = [];
+        private string? _currentUri;
 
         [Inject]
         private IDialogService DialogService { get; set; } = null!;
@@ -154,13 +155,40 @@ protected override Task OnAfterRenderAsync(bool firstRender)
             return base.OnAfterRenderAsync(firstRender);
         }
 
+        internal void SetOptions(Guid id, DialogOptions options)
+        {
+            var reference = GetDialogReference(id);
+            if (reference != null)
+                reference.InjectOptions(options);
+        }
+
         internal void DismissInstance(Guid id, DialogResult result)
         {
             var reference = GetDialogReference(id);
             if (reference != null)
                 DismissInstance(reference, result);
         }
 
+        internal bool ShouldDismissOnNavigation(IDialogReference dialog, string newUri)
+        {
+            if (dialog.Options?.CloseOnNavigation == null)
+            {
+                return HasRouteChanged(newUri);
+            }
+
+            return dialog.Options.CloseOnNavigation.Value;
+        }
+
+        internal bool HasRouteChanged(string newUri)
+        {
+            if (_currentUri == null)
+            {
+                return true;
+            }
+
+            return !string.Equals(_currentUri, newUri, StringComparison.OrdinalIgnoreCase);
+        }
+
         private Task AddInstanceAsync(IDialogReference dialog)
         {
             _dialogs.Add(dialog);
@@ -194,7 +222,15 @@ private void DismissInstance(IDialogReference dialog, DialogResult? result)
 
         private void LocationChanged(object? sender, LocationChangedEventArgs args)
         {
-            DismissAll();
+            var newUri = NavigationManager.ToAbsoluteUri(args.Location).AbsolutePath.TrimEnd('/');
+
+            foreach (var dialog in _dialogs.ToArray().Where(d => ShouldDismissOnNavigation(d, newUri)))
+            {
+                DismissInstance(dialog, DialogResult.Cancel());
+            }
+
+            _currentUri = newUri;
+            StateHasChanged();
         }
 
         protected virtual void Dispose(bool disposing)

src/MudBlazor/Services/Dialog/DialogOptions.cs

@@ -52,6 +52,15 @@ public record DialogOptions
         /// </summary>
         public bool? CloseOnEscapeKey { get; init; }
 
+        /// <summary>
+        /// Determines if the dialog should close on navigation.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to <c>null</c>.
+        /// When <c>null</c> this option is considered <c>true</c> if the absolute path changes and <c>false</c> if only the query or fragment changes.
+        /// </remarks>
+        public bool? CloseOnNavigation { get; init; }
+
         /// <summary>
         /// Hides the dialog header.
         /// </summary>