diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridAllowUnsortedTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridAllowUnsortedTest.razor new file mode 100644 index 000000000000..0efe1414ddd3 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridAllowUnsortedTest.razor @@ -0,0 +1,26 @@ + + + + + + + + +@code { + [Parameter] + public bool AllowUnsorted { get; set; } = true; + + private readonly List _items = new List + { + new("C", 42, "555"), + new("A", 73, "7"), + new("B", 11, "4444"), + }; + + public class Item(string name, int value, string misc) + { + public string Name { get; set; } = name; + public int Value { get; set; } = value; + public string Misc { get; set; } = misc; + } +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridDateOnlyFilterTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridDateOnlyFilterTest.razor new file mode 100644 index 000000000000..8b0b73eca422 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridDateOnlyFilterTest.razor @@ -0,0 +1,20 @@ + + + + + + + + +@code { + public static string __description__ = @"Test DateOnly filtering in DataGrid"; + public record Model(string Name, int? Age, DateOnly? HiredOn); + + private readonly IEnumerable _people = + [ + new("Sam", 56, new DateOnly(2020, 3, 10)), + new("Alicia", 54, null), + new("Ira", 27, new DateOnly(2011, 1, 2)), + new("John", 32, new DateOnly(2022, 6, 15)) + ]; +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Dialog/DialogCloseOnEscapeTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Dialog/DialogCloseOnEscapeTest.razor new file mode 100644 index 000000000000..e2234160cf6b --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Dialog/DialogCloseOnEscapeTest.razor @@ -0,0 +1,45 @@ +@inject IDialogService DialogService +@inject ISnackbar Snackbar + +Open Dialog (Test Esc Key) + +@code { + public static string __description__ = "Open Dialog -> Click overlay -> Press Esc"; + + private async Task OpenDialog() + { + var options = new DialogOptions + { + CloseOnEscapeKey = true, + BackdropClick = true, + }; + + // Define a RenderFragment for the dialog content directly + RenderFragment dialogContent = builder => + { + builder.OpenComponent(0); + builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(2, "Click the overlay (I shouldn't close), then press Esc. Or click inside me, then press Esc."))); + builder.CloseComponent(); + // Add a button to ensure focus can shift to an interactive element within the dialog + builder.OpenComponent(3); + builder.AddAttribute(4, "Variant", Variant.Filled); + builder.AddAttribute(5, "Class", "ma-4"); + builder.AddAttribute(6, "OnClick", EventCallback.Factory.Create(this, () => Snackbar.Add("Button clicked", Severity.Info))); + builder.AddAttribute(7, "ChildContent", (RenderFragment)(b => b.AddContent(8, "Test Button"))); + builder.CloseComponent(); + }; + + var parameters = new DialogParameters + { + [nameof(MudDialog.DialogContent)] = dialogContent, // Pass the RenderFragment + [nameof(MudDialog.OnBackdropClick)] = new EventCallback(null, (MouseEventArgs args) => + { + Snackbar.Add("Overlay clicked! Dialog should still be open. Now try pressing Escape.", Severity.Info); + // This handler intentionally does not close the dialog, to test refocus. + }) + }; + + // Use the built-in MudDialog and pass content and handlers through parameters + var dialog = await DialogService.ShowAsync("Test Escape Key", parameters, options); + } +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Dialog/InlineDialogTitleRefreshTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Dialog/InlineDialogTitleRefreshTest.razor new file mode 100644 index 000000000000..971330d7b547 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Dialog/InlineDialogTitleRefreshTest.razor @@ -0,0 +1,45 @@ +

+ + Show Dialog + +

+ + + + + @DialogTitle + + + + + + + +@code { + public static string __description__ = "Dialog title should update along with Progress Bar content"; + + private readonly DialogOptions _dialogOptions = new() { FullWidth = true }; + private int DialogProgress { get; set; } = 0; + private bool DialogVisible { get; set; } = false; + private string DialogTitle { get; set; } = "Initial state"; + + private async Task OpenDialog() + { + DialogVisible = true; + + for (int i = 0; i <= 10; i++) + { + await Task.Delay(150); // Simulate some work + DialogProgress = i * 10; // Simulate progress update + DialogTitle = $"Progress: {DialogProgress}%"; + StateHasChanged(); + } + + // Keep dialog open for a bit to observe final title + await Task.Delay(2000); + + DialogVisible = false; + DialogProgress = 0; + DialogTitle = "Initial state"; + } +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/ExpansionPanel/ExpansionPanelKeyboardTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/ExpansionPanel/ExpansionPanelKeyboardTest.razor new file mode 100644 index 000000000000..c9cf484dca70 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/ExpansionPanel/ExpansionPanelKeyboardTest.razor @@ -0,0 +1,8 @@ + + + Button 1 + + + Button 2 + + diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Highlighter/HtmlEncodeTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Highlighter/HtmlEncodeTest.razor new file mode 100644 index 000000000000..4147855063b2 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Highlighter/HtmlEncodeTest.razor @@ -0,0 +1,34 @@ + + + @foreach (var paragraph in paragraphs) + { + + + + } + + + + + + +@code { + public static string __description__ = "Style (color and formatting) should be present"; + + string highlightedText = "'"; + bool untilNextBoundary; + bool caseSensitive; + bool markup = true; + IEnumerable paragraphs = new List + { + $"MudBlazor is an Material Design component framework for Blazor with an emphasis on ease of use and clear structure.", + $"MudLists are easily customizable and scrollable lists. Make them suit your needs with avatars, icons, or something like checkboxes.", + $"Use mud-* classes to customize your MudBlazor components.", + $"'text in single quote'" + }; +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Mask/AutoFillMaskTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Mask/AutoFillMaskTest.razor new file mode 100644 index 000000000000..f5c0892fc8a6 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Mask/AutoFillMaskTest.razor @@ -0,0 +1,23 @@ + + + + + + +@_phone + + +@code { + private string? _phone; +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Progress/MudProgressCircularWidthTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Progress/MudProgressCircularWidthTest.razor new file mode 100644 index 000000000000..6f0bad5d6e86 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Progress/MudProgressCircularWidthTest.razor @@ -0,0 +1,12 @@ + + + @_width + + +@($"Stroke-Width: {_width}") + +@code { + public static string __description__ = "Circle should render correctly with increasing stroke width"; + + int _width = 2; +} diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Select/SelectMultiSelectFieldChangedTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Select/SelectMultiSelectFieldChangedTest.razor new file mode 100644 index 000000000000..094fe1fffbc1 --- /dev/null +++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Select/SelectMultiSelectFieldChangedTest.razor @@ -0,0 +1,51 @@ +@using MudBlazor.Utilities + + + + + @foreach (var state in States) + { + @state + } + + + +@code { + public static string __description__ = "FieldChanged should trigger when T != string and MultiSelect=true"; + private IEnumerable _options = new HashSet { new("Alaska") }; + + public State[] States { get; init; } = + [ + new("Alabama"), new("Alaska"), new("Arizona"), new("Arkansas"), new("California"), + new("Colorado"), new("Connecticut"), new("Delaware"), new("Florida"), new("Georgia"), + new("Hawaii"), new("Idaho"), new("Illinois"), new("Indiana"), new("Iowa"), new("Kansas"), + new("Kentucky"), new("Louisiana"), new("Maine"), new("Maryland"), new("Massachusetts"), + new("Michigan"), new("Minnesota"), new("Mississippi"), new("Missouri"), new("Montana"), + new("Nebraska"), new("Nevada"), new("New Hampshire"), new("New Jersey"), new("New Mexico"), + new("New York"), new("North Carolina"), new("North Dakota"), new("Ohio"), new("Oklahoma"), + new("Oregon"), new("Pennsylvania"), new("Rhode Island"), new("South Carolina"), new("South Dakota"), + new("Tennessee"), new("Texas"), new("Utah"), new("Vermont"), new("Virginia"), + new("Washington"), new("West Virginia"), new("Wisconsin"), new("Wyoming") + ]; + + public class State(string name) : IEquatable + { + + public string Name { get; } = name; + + public bool Equals(State? other) + { + if (ReferenceEquals(null, other)) return false; + if (ReferenceEquals(this, other)) return true; + return Name == other.Name; + } + + public override bool Equals(object? obj) => obj is State state && Equals(state); + + public override int GetHashCode() => Name.GetHashCode(); + + public override string ToString() => Name; + } + + public FormFieldChangedEventArgs? FormFieldChangedEventArgs { get; private set; } +} diff --git a/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs b/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs index 926cbfaac0a0..13c65fdf6496 100644 --- a/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs +++ b/src/MudBlazor.UnitTests/Components/AutocompleteTests.cs @@ -1491,7 +1491,7 @@ public async Task AutocompleteStrictFalseTest(int index) var items = comp.FindComponents>().ToArray(); items.Length.Should().Be(10); var item = items.SingleOrDefault(x => x.Markup.Contains(californiaString)); - items.ToList().IndexOf(item).Should().Be(4); + items.ToList().IndexOf(item).Should().Be(5); comp.WaitForAssertion(() => items.Single(s => s.Markup.Contains(californiaString)).Find(listItemQuerySelector).ClassList.Should().Contain(selectedItemClassName)); await comp.InvokeAsync(async () => await autocompleteComponent.Find("input").KeyUpAsync(new KeyboardEventArgs() { Key = "Escape" })); // Close autocomplete. diff --git a/src/MudBlazor.UnitTests/Components/DataGridTests.cs b/src/MudBlazor.UnitTests/Components/DataGridTests.cs index bb8c2b1a3fb0..bf05dd6ba7e3 100644 --- a/src/MudBlazor.UnitTests/Components/DataGridTests.cs +++ b/src/MudBlazor.UnitTests/Components/DataGridTests.cs @@ -2235,6 +2235,285 @@ public void FilterDefinitionDateTimeTest() func.Invoke(new("Joe", 45, null, null, null, null)).Should().BeTrue(); } + [Test] + public void FilterDefinitionDateOnlyTest() + { + var comp = Context.RenderComponent(); + var dataGrid = comp.FindComponent>(); + var dateColumn = dataGrid.Instance.GetColumnByPropertyName("HiredOn"); + var testDate = new DateOnly(2020, 3, 10); + + #region FilterOperator.DateOnly.Is + + var filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.Is, + Value = testDate + }; + var func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + func.Invoke(new("Ira", 27, new DateOnly(2011, 1, 2))).Should().BeFalse(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.Is, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.IsNot + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.IsNot, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeFalse(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + func.Invoke(new("Ira", 27, new DateOnly(2011, 1, 2))).Should().BeTrue(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.IsNot, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.After + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.After, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeFalse(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + func.Invoke(new("John", 32, new DateOnly(2022, 6, 15))).Should().BeTrue(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.After, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.OnOrAfter + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.OnOrAfter, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + func.Invoke(new("John", 32, new DateOnly(2022, 6, 15))).Should().BeTrue(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.OnOrAfter, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.Before + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.Before, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeFalse(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + func.Invoke(new("Ira", 27, new DateOnly(2011, 1, 2))).Should().BeTrue(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.Before, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.OnOrBefore + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.OnOrBefore, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + func.Invoke(new("Ira", 27, new DateOnly(2011, 1, 2))).Should().BeTrue(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.OnOrBefore, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.Empty + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.Empty, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeFalse(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + func.Invoke(new("Ira", 27, new DateOnly(2011, 1, 2))).Should().BeFalse(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.Empty, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeFalse(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + + #endregion + + #region FilterOperator.DateOnly.NotEmpty + + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.NotEmpty, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + func.Invoke(new("Ira", 27, new DateOnly(2011, 1, 2))).Should().BeTrue(); + + // null value + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = FilterOperator.DateOnly.NotEmpty, + Value = null + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeFalse(); + + #endregion + + // null operator + filterDefinition = new FilterDefinition + { + Column = dateColumn, + Operator = null, + Value = testDate + }; + func = filterDefinition.GenerateFilterFunction(new FilterOptions + { + FilterCaseSensitivity = dataGrid.Instance.FilterCaseSensitivity + }); + func.Invoke(new("Sam", 56, testDate)).Should().BeTrue(); + func.Invoke(new("Joe", 32, null)).Should().BeTrue(); + } + [Test] public void FilterDefinitionNumberTest() { @@ -2511,6 +2790,9 @@ public async Task DataGridCloseFiltersTest() // check the number of filters displayed in the filters panel is 1 comp.FindAll(".filters-panel .mud-grid-item.d-flex").Count.Should().Be(1); + // Wait for the filter panel to render properly + comp.WaitForState(() => comp.FindAll(".filter-operator").Count > 0, timeout: TimeSpan.FromSeconds(5)); + await comp.Find(".filter-operator").MouseDownAsync(new MouseEventArgs()); //set operator to CONTAINS @@ -2524,6 +2806,9 @@ public async Task DataGridCloseFiltersTest() //set operator to NOT CONTAINS FilterButton().Click(); + // Wait for the filter panel to render properly + comp.WaitForState(() => comp.FindAll(".filter-operator").Count > 0, timeout: TimeSpan.FromSeconds(5)); + await comp.Find(".filter-operator").MouseDownAsync(new MouseEventArgs()); comp.FindAll(".mud-list .mud-list-item")[1].Click(); @@ -4936,5 +5221,61 @@ public void DataGrid_HierarchyExpandSingleRowTest() dataGrid.Instance._openHierarchies.First().Should().Be(item); } + + [Test] + public async Task DataGridShouldAllowUnsortedAscDescOnly() + { + var comp = Context.RenderComponent(parameters => parameters + .Add(p => p.AllowUnsorted, false)); + var dataGrid = comp.FindComponent>(); + var headerCell = dataGrid.FindComponents>()[0]; + + await comp.InvokeAsync(() => headerCell.Instance.SortChangedAsync(new MouseEventArgs() { Button = 0 })); + headerCell.Instance.SortDirection.Should().Be(SortDirection.Ascending); + var cells = dataGrid.FindAll("td"); + cells[0].TextContent.Should().Be("A"); + cells[3].TextContent.Should().Be("B"); + cells[6].TextContent.Should().Be("C"); + + await comp.InvokeAsync(() => headerCell.Instance.SortChangedAsync(new MouseEventArgs() { Button = 0 })); + headerCell.Instance.SortDirection.Should().Be(SortDirection.Descending); + cells = dataGrid.FindAll("td"); + cells[0].TextContent.Should().Be("C"); + cells[3].TextContent.Should().Be("B"); + cells[6].TextContent.Should().Be("A"); + + await comp.InvokeAsync(() => headerCell.Instance.SortChangedAsync(new MouseEventArgs() { Button = 0 })); + headerCell.Instance.SortDirection.Should().Be(SortDirection.Ascending); + cells = dataGrid.FindAll("td"); + cells[0].TextContent.Should().Be("A"); + cells[3].TextContent.Should().Be("B"); + cells[6].TextContent.Should().Be("C"); + + comp = Context.RenderComponent(parameters => parameters + .Add(p => p.AllowUnsorted, true)); + dataGrid = comp.FindComponent>(); + headerCell = dataGrid.FindComponents>()[0]; + + await comp.InvokeAsync(() => headerCell.Instance.SortChangedAsync(new MouseEventArgs() { Button = 0 })); + headerCell.Instance.SortDirection.Should().Be(SortDirection.Ascending); + cells = dataGrid.FindAll("td"); + cells[0].TextContent.Should().Be("A"); + cells[3].TextContent.Should().Be("B"); + cells[6].TextContent.Should().Be("C"); + + await comp.InvokeAsync(() => headerCell.Instance.SortChangedAsync(new MouseEventArgs() { Button = 0 })); + headerCell.Instance.SortDirection.Should().Be(SortDirection.Descending); + cells = dataGrid.FindAll("td"); + cells[0].TextContent.Should().Be("C"); + cells[3].TextContent.Should().Be("B"); + cells[6].TextContent.Should().Be("A"); + + await comp.InvokeAsync(() => headerCell.Instance.SortChangedAsync(new MouseEventArgs() { Button = 0 })); + headerCell.Instance.SortDirection.Should().Be(SortDirection.None); + cells = dataGrid.FindAll("td"); + cells[0].TextContent.Should().Be("C"); + cells[3].TextContent.Should().Be("A"); + cells[6].TextContent.Should().Be("B"); + } } } diff --git a/src/MudBlazor.UnitTests/Components/DialogTests.cs b/src/MudBlazor.UnitTests/Components/DialogTests.cs index d76adfcd0a9b..545083f7c278 100644 --- a/src/MudBlazor.UnitTests/Components/DialogTests.cs +++ b/src/MudBlazor.UnitTests/Components/DialogTests.cs @@ -1,8 +1,11 @@ using Bunit; using FluentAssertions; +using Microsoft.AspNetCore.Components; using Microsoft.AspNetCore.Components.Web; using Microsoft.Extensions.DependencyInjection; -using MudBlazor.UnitTests.TestComponents; +using Microsoft.JSInterop; +using Microsoft.JSInterop.Infrastructure; +using Moq; using MudBlazor.UnitTests.TestComponents.Dialog; using NUnit.Framework; @@ -148,7 +151,7 @@ public void InlineDialogShowMethodTest() // close by click on ok button comp.Find(".mud-message-box button").Click(); - comp.Markup.Trim().Should().BeEmpty(); + comp.WaitForAssertion(() => comp.Markup.Trim().Should().BeEmpty(), timeout: TimeSpan.FromSeconds(5)); } ///

@@ -1341,8 +1344,124 @@ public async Task DuplicateDialogTest() await Task.Delay(1000); comp.FindComponents().Count.Should().Be(1); } - } + [Test] + public async Task Dialog_TitleContent_And_ProgressBar_ShouldUpdate() + { + var comp = Context.RenderComponent(); + comp.Markup.Trim().Should().BeEmpty(); + + var service = Context.Services.GetRequiredService(); + + var comp1 = Context.RenderComponent(); + + comp1.Find("button").Click(); + + var dialog = comp.Find("div.mud-dialog"); + + dialog.Should().NotBeNull(); + dialog.TextContent.Trim().Should().Be("Initial state"); // Initial title + comp.FindComponent().Instance.Value.Should().Be(0); // Initial progress value - 0 + + // Wait for mid-progress (simulate that loop is progressing) + await Task.Delay(1000); + //comp.Render(); + + dialog = comp.Find("div.mud-dialog"); + dialog.TextContent.Should().Contain("Progress"); //change from "Initial state" to "Progress" + + var progressComponent = comp.FindComponent(); + var progressValue = progressComponent.Instance.Value; + progressValue.Should().BeGreaterThan(0).And.BeLessThan(100); + + // Wait for dialog to close and state reset + await Task.Delay(3000); // Ensure loop finishes + comp.Render(); + + // Assert the dialog is now hidden + comp.Markup.Trim().Should().NotContain("mud-dialog"); + } + + [Test] + public async Task HandleBackgroundClickAsync_Should_Call_RefocusDialogAsync_When_BackdropClick_Disabled() + { + // Arrange + IDialogReference dialogReference = null; + + var jsRuntimeMock = new Mock(); + + jsRuntimeMock.Setup(x => x.InvokeAsync("Blazor._internal.domWrapper.focus", It.IsAny())); + + Context.Services.AddSingleton(jsRuntimeMock.Object); + + var comp = Context.RenderComponent(); + var service = Context.Services.GetRequiredService(); + var dialogOptions = new DialogOptions { BackdropClick = false, CloseOnEscapeKey = true }; + + //Act + await comp.InvokeAsync(async () => dialogReference = await service.ShowAsync("Test Dialog True", dialogOptions)); + + jsRuntimeMock.Verify(x => x.InvokeAsync("Blazor._internal.domWrapper.focus", + It.Is(args => + args.Length == 2 && + args[0] is ElementReference && + args[1] is bool)), + Times.AtMost(1)); // Focus should be called once when dialog is opened (FocusTrap) + + comp.Find("div.mud-dialog-container").Should().NotBeNull(); // Dialog is open + comp.Find("div.mud-overlay").Click(); // Simulate a click on the backdrop + + //Assert + comp.Find("div.mud-dialog-container").Should().NotBeNull(); // Dialog should still be open + + jsRuntimeMock.Verify(x => x.InvokeAsync("Blazor._internal.domWrapper.focus", + It.Is(args => + args.Length == 2 && + args[0] is ElementReference && + args[1] is bool)), + Times.AtMost(2)); // Focus should be called once when dialog is opened and once when backdrop is clicked (refouus) + } + + [Test] + public async Task HandleBackgroundClickAsync_Should_Call_OnBackdropClick_And_RefocusDialog_When_Delegate_Defined() + { + // Arrange + var jsRuntimeMock = new Mock(); + + jsRuntimeMock.Setup(x => x.InvokeAsync("Blazor._internal.domWrapper.focus", It.IsAny())); + + Context.Services.AddSingleton(jsRuntimeMock.Object); + + var comp = Context.RenderComponent(); + + // Create a dialog component with OnBackdropClick delegate + var dialogComponent = Context.RenderComponent(); + + // Act + await dialogComponent.FindComponent().Find("button").ClickAsync(new MouseEventArgs()); // Open the dialog + + jsRuntimeMock.Verify(x => x.InvokeAsync("Blazor._internal.domWrapper.focus", + It.Is(args => + args.Length == 2 && + args[0] is ElementReference && + args[1] is bool)), + Times.AtMost(1)); // Focus should be called once when dialog is opened + + comp.Find("div.mud-dialog-container").Should().NotBeNull(); // Dialog is open + + await comp.Find("div.mud-overlay").ClickAsync(new MouseEventArgs()); // Simulate a click on the backdrop + + // Assert + comp.Find("div.mud-dialog-container").Should().NotBeNull(); // Dialog should still be open (not closed) + + jsRuntimeMock.Verify(x => x.InvokeAsync("Blazor._internal.domWrapper.focus", + It.Is(args => + args.Length == 2 && + args[0] is ElementReference && + args[1] is bool)), + Times.AtMost(2)); // Focus should be called once when dialog opens and once for refocus after backdrop click + } + } internal class CustomDialogService : DialogService { public override IDialogReference CreateReference() => new CustomDialogReference(Guid.NewGuid(), this); diff --git a/src/MudBlazor.UnitTests/Components/ExpansionPanelTests.cs b/src/MudBlazor.UnitTests/Components/ExpansionPanelTests.cs index 1d9682ebff12..f4c7ec2860fd 100644 --- a/src/MudBlazor.UnitTests/Components/ExpansionPanelTests.cs +++ b/src/MudBlazor.UnitTests/Components/ExpansionPanelTests.cs @@ -1,9 +1,7 @@ -using System.Collections.Generic; -using System.Linq; -using System.Threading.Tasks; +using AngleSharp.Dom; using Bunit; using FluentAssertions; -using MudBlazor.UnitTests.TestComponents; +using Microsoft.AspNetCore.Components.Web; using MudBlazor.UnitTests.TestComponents.ExpansionPanel; using NUnit.Framework; @@ -299,5 +297,94 @@ public async Task MudExpansionPanel_TwoWayBinding() comp.WaitForAssertion(() => comp.Instance.Expansion[2].Should().BeFalse()); comp.WaitForAssertion(() => comp.Instance.Expansion[3].Should().BeFalse()); } + + ///

+ /// Tests that the panel toggles expansion state when the Enter and Space keys are pressed. + ///

+ [Test] + public async Task MudExpansionPanel_Handles_KeyDown_For_Toggle() + { + var comp = Context.RenderComponent(); + var header = comp.Find(".mud-expand-panel-header"); + + comp.Markup.Should().NotContain("mud-panel-expanded"); + await header.TriggerEventAsync("onkeydown", new KeyboardEventArgs { Key = "Enter" }); + comp.Markup.Should().Contain("mud-panel-expanded"); + await header.TriggerEventAsync("onkeydown", new KeyboardEventArgs { Key = " " }); + comp.Markup.Should().NotContain("mud-panel-expanded"); + } + + ///

+ /// Tests that buttons and other interactive content within a collapsed expansion panel + /// are properly hidden from accessibility tools and keyboard navigation by being placed + /// in a container with the hidden attribute. + ///

+ [Test] + public void MudExpansionPanel_Button_IsInHiddenContainer_When_Panel_Collapsed() + { + var comp = Context.RenderComponent(); + var button = comp.Find("button"); + var hiddenParent = button + .GetAncestors() + .OfType() + .FirstOrDefault(e => e.HasAttribute("hidden")); + + hiddenParent.Should().NotBeNull("button should not be accessible when the panel is collapsed"); + } + + ///

+ /// Tests that HandleKeyDownAsync ignores key presses when the panel is disabled. + ///

+ [Test] + public async Task MudExpansionPanel_HandleKeyDownAsync_IgnoresKeys_When_Disabled() + { + var comp = Context.RenderComponent(parameters => parameters + .Add(p => p.Disabled, true) + .Add(p => p.Text, "Disabled Panel")); + + var header = comp.Find(".mud-expand-panel-header"); + comp.Markup.Should().NotContain("mud-panel-expanded"); + + // Try to expand with Enter key - should be ignored + await header.TriggerEventAsync("onkeydown", new KeyboardEventArgs { Key = "Enter" }); + comp.Markup.Should().NotContain("mud-panel-expanded"); + + // Try to expand with Space key - should be ignored + await header.TriggerEventAsync("onkeydown", new KeyboardEventArgs { Key = " " }); + comp.Markup.Should().NotContain("mud-panel-expanded"); + } + + ///

+ /// Tests that content is rendered even when collapsed when KeepContentAlive is true. + ///

+ [Test] + public void MudExpansionPanel_KeepContentAlive_True_RendersContentWhenCollapsed() + { + var comp = Context.RenderComponent(parameters => parameters + .Add(p => p.Text, "Test Panel") + .Add(p => p.KeepContentAlive, true) + .Add(p => p.ChildContent, builder => builder.AddMarkupContent(0, ""))); + + comp.Markup.Should().NotContain("mud-panel-expanded"); + comp.Find("button").Should().NotBeNull(); + + var contentDiv = comp.Find(".mud-expand-panel-content"); + contentDiv.HasAttribute("hidden").Should().BeTrue(); + } + + ///

+ /// Tests that content is not rendered when collapsed when KeepContentAlive is false. + ///

+ [Test] + public void MudExpansionPanel_KeepContentAlive_False_DoesNotRenderContentWhenCollapsed() + { + var comp = Context.RenderComponent(parameters => parameters + .Add(p => p.Text, "Test Panel") + .Add(p => p.KeepContentAlive, false) + .Add(p => p.ChildContent, builder => builder.AddMarkupContent(0, ""))); + + comp.Markup.Should().NotContain("mud-panel-expanded"); + comp.FindAll("button").Should().BeEmpty(); + } } } diff --git a/src/MudBlazor.UnitTests/Components/HighlighterTests.cs b/src/MudBlazor.UnitTests/Components/HighlighterTests.cs index a524852a8f72..f7b27dcb4e54 100644 --- a/src/MudBlazor.UnitTests/Components/HighlighterTests.cs +++ b/src/MudBlazor.UnitTests/Components/HighlighterTests.cs @@ -1,7 +1,6 @@ - -using System.Collections.Generic; -using Bunit; +using Bunit; using FluentAssertions; +using MudBlazor.Components.Highlighter; using NUnit.Framework; using static Bunit.ComponentParameterFactory; using static MudBlazor.Components.Highlighter.Splitter; @@ -113,6 +112,161 @@ public void DontMessWithDuplicatedHighlightPatternsInHighlightedTextParameterAnd result.Should().BeEquivalentTo(new List { "This is the first ", "item" }); regex.Should().Be("((?:item)|(?:item))"); } + + [Test] + public void GetFragments_NoHighlightTerms_ReturnsOriginalTextAsSingleFragment() + { + var inputText = "This is some sample text."; + string highlightedText = null; + string[] highlightedTexts = null; + + var result = GetFragments(inputText, highlightedText, highlightedTexts, out var outRegex).ToArray(); + + result.Should().HaveCount(1); + result[0].Should().Be(inputText); + outRegex.Should().Be(string.Empty); + } + + [Test] + public void GetHtmlAwareFragments_NullOrEmptyText_ReturnsEmptyList() + { + var resultNull = GetHtmlAwareFragments(null, "any", null, out var outRegex, false, false); + resultNull.Should().BeEmpty(); + outRegex.Should().Be(string.Empty); + + + // Test with empty text + var resultEmpty = GetHtmlAwareFragments(string.Empty, "any", null, out outRegex, false, false); + resultEmpty.Should().BeEmpty(); + // As per L59, regex is set to string.Empty at the start of the method before the null check. + outRegex.Should().Be(string.Empty); + } + + [Test] + public void GetHtmlAwareFragments_InvalidTag_IsEncodedAsText() + { + var text = "This is text."; + var highlightedText = "text"; + + var fragments = GetHtmlAwareFragments(text, highlightedText, null, out var outRegex, false, false); + + fragments.Should().Contain(new FragmentInfo("", FragmentType.Text)); + + // Verify surrounding text and highlight + var expectedFullSequence = new[] { + new FragmentInfo("This is ", FragmentType.Text), + new FragmentInfo("", FragmentType.Text), + new FragmentInfo(" ", FragmentType.Text), + new FragmentInfo("text", FragmentType.HighlightedText), + new FragmentInfo(".", FragmentType.Text) + }; + fragments.Should().BeEquivalentTo(expectedFullSequence, options => options.WithStrictOrdering()); + } + + [Test] + public void GetHtmlAwareFragments_SelfClosingTag_IsPreservedAsMarkup() + { + var text = "Text with
a line break."; + var highlightedText = "Text"; + + var fragments = GetHtmlAwareFragments(text, highlightedText, null, out var outRegex, false, false); + + var expectedFullSequence = new[] { + new FragmentInfo("Text", FragmentType.HighlightedText), + new FragmentInfo(" with ", FragmentType.Text), + new FragmentInfo("
", FragmentType.Markup), + new FragmentInfo(" a line break.", FragmentType.Text) + }; + fragments.Should().BeEquivalentTo(expectedFullSequence, options => options.WithStrictOrdering()); + } + + [Test] + public void GetHtmlAwareFragments_MismatchedClosingTag_IsEncodedAsText() + { + var text = "

Content

"; + var highlightedText = "Content"; + var fragments = GetHtmlAwareFragments(text, highlightedText, null, out var outRegex, false, false); + + var expectedFullSequence = new[] { + new FragmentInfo("

", FragmentType.Text), + new FragmentInfo("", FragmentType.Markup), + new FragmentInfo("Content", FragmentType.HighlightedText), + new FragmentInfo(System.Net.WebUtility.HtmlEncode("

"), FragmentType.Text), + new FragmentInfo("", FragmentType.Markup) + }; + fragments.Should().BeEquivalentTo(expectedFullSequence, options => options.WithStrictOrdering()); + } + + [Test] + public void GetHtmlAwareFragments_UnmatchedTagWithHighlightAndTrailingText_CorrectlyFragments() + { + var text = "unclosed highlight then_text"; // Simplified input + var highlightedText = "highlight"; + + var fragments = GetHtmlAwareFragments(text, highlightedText, null, out var outRegex, caseSensitive: false, untilNextBoundary: false); + + var expectedSequence = new[] { + new FragmentInfo("", FragmentType.Text), // The unmatched opening tag becomes text + new FragmentInfo("unclosed ", FragmentType.Text), + new FragmentInfo("highlight", FragmentType.HighlightedText), + new FragmentInfo(" then_text", FragmentType.Text) + }; + + fragments.Should().BeEquivalentTo(expectedSequence, options => options.WithStrictOrdering()); + } + + [Test] + public void GetFragments_WithManyTerms_ExercisesStringBuilderCaching() + { + var text = "The quick brown fox jumps over the lazy dog and repeats."; + var highlightedTexts1 = new[] { "quick", "brown", "fox", "jumps", "lazy", "dog", "repeats" }; + + var fragments1 = GetFragments(text, null, highlightedTexts1, out var outRegex1, caseSensitive: false, untilNextBoundary: false).ToArray(); + + fragments1.Should().NotBeEmpty(); + outRegex1.Should().NotBeEmpty(); + outRegex1.Should().ContainAll(highlightedTexts1); + fragments1.Length.Should().Be(highlightedTexts1.Length * 2 - 1 + 2); + + var text2 = "Another test sentence with new words like example and cache."; + var highlightedTexts2 = new[] { "sentence", "words", "example", "cache" }; + var fragments2 = GetFragments(text2, null, highlightedTexts2, out var outRegex2, caseSensitive: false, untilNextBoundary: false).ToArray(); + + fragments2.Should().NotBeEmpty(); + outRegex2.Should().NotBeEmpty(); + outRegex2.Should().ContainAll(highlightedTexts2); + fragments2.Length.Should().Be(highlightedTexts2.Length * 2 - 1 + 2); + + var text3 = "No highlights here."; + var fragments3 = GetFragments(text3, null, [], out var outRegex3, caseSensitive: false, untilNextBoundary: false).ToArray(); + fragments3.Should().HaveCount(1); + fragments3[0].Should().Be(text3); + outRegex3.Should().BeEmpty(); + } + + [Test] + public void GetHtmlAwareFragments_CaseSensitivity_ProducesCorrectFragments() + { + var text = "Highlight highlight"; + var highlightTerm = "Highlight"; + + // Case Sensitive + var fragmentsSensitive = GetHtmlAwareFragments(text, highlightTerm, null, out var outRegex, caseSensitive: true, untilNextBoundary: false); + var expectedSensitive = new[] { + new FragmentInfo("Highlight", FragmentType.HighlightedText), + new FragmentInfo(" highlight", FragmentType.Text) + }; + fragmentsSensitive.Should().BeEquivalentTo(expectedSensitive, options => options.WithStrictOrdering()); + + // Case Insensitive + var fragmentsInsensitive = GetHtmlAwareFragments(text, highlightTerm, null, out outRegex, caseSensitive: false, untilNextBoundary: false); + var expectedInsensitive = new[] { + new FragmentInfo("Highlight", FragmentType.HighlightedText), + new FragmentInfo(" ", FragmentType.Text), + new FragmentInfo("highlight", FragmentType.HighlightedText) + }; + fragmentsInsensitive.Should().BeEquivalentTo(expectedInsensitive, options => options.WithStrictOrdering()); + } } [TestFixture] @@ -261,5 +415,188 @@ public void MudHighlighterMarkupRenderFragmentTest() comp = Context.RenderComponent(text, highlightedText, textAsMarkupTrue); comp.MarkupMatches(formattedOutput); } + + [Test] + public void MudHighlighter_MarkupTrue_HtmlInText_ShouldHighlightCorrectly() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello World"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "Hello"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Hello World"); + } + + [Test] + public void MudHighlighter_MarkupTrue_HtmlSensitiveCharInHighlightedText_ShouldEncodeAndHighlight() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello "); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), ""); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Hello <World>"); + } + + [Test] + public void MudHighlighter_MarkupTrue_HtmlInText_ShouldNotHighlightInTags() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "
div content div
"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "div"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("
div content div
"); + } + + [Test] + public void MudHighlighter_MarkupTrue_HtmlTag_ShouldNotHighlight() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello Mud World"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), ""); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Hello Mud World"); + } + + [Test] + public void MudHighlighter_MarkupTrue_TextWithHtmlEntities_HighlightedTextIsEntityText() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello & World"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "&"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + // Adjusted to match BUnit's actual output. This implies that when FragmentInfo.Content = "&", + // the rendered @FragmentInfo.Content is captured by BUnit as &. + comp.MarkupMatches("Hello & World"); + } + + [Test] + public void MudHighlighter_MarkupTrue_HighlightedTextWithSingleQuotes_ShouldHighlight() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "This is a 'quoted' text and a \"double quoted\" text."); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "'quoted'"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("This is a 'quoted' text and a \"double quoted\" text."); + } + + [Test] + public void MudHighlighter_MarkupTrue_HighlightedTextWithDoubleQuotes_ShouldHighlight() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "This is a 'quoted' text and a \"double quoted\" text."); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "\"double quoted\""); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("This is a 'quoted' text and a "double quoted" text."); + } + + [Test] + public void MudHighlighter_MarkupTrue_HighlightedTextAsAttributeValue_ShouldNotHighlightInAttribute() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "nothing"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "nothing"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("nothing"); + } + + [Test] + public void MudHighlighter_MarkupTrue_FormattingPreservation_ItalicsAndColor() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "MudBlazor is important"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "MudBlazor"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("MudBlazor is important"); + } + + [Test] + public void MudHighlighter_MarkupTrue_FormattingPreservation_Bold() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Normal bold normal"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "bold"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Normal bold normal"); + } + + [Test] + public void MudHighlighter_MarkupTrue_NonStandardTag_NoHighlight() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello world"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), ""); // Or null, effectively no highlight + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Hello <ambitious> world"); + } + + [Test] + public void MudHighlighter_MarkupTrue_NonStandardTag_WithHighlightAfterTag() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello world"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "world"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Hello <ambitious> world"); + } + + [Test] + public void MudHighlighter_MarkupTrue_NonStandardTag_WithHighlightInsideTag() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Hello world"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "bit"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + comp.MarkupMatches("Hello <ambitious> world"); + } + + [Test] + public void MudHighlighter_MarkupTrue_NoFragments_RendersTextAsMarkupString() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Some text"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "zip"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam); + + comp.MarkupMatches("Some text"); + } + + [Test] + public void MudHighlighter_MarkupTrue_WithClass_RendersMarkWithClass() + { + var textParam = Parameter(nameof(MudHighlighter.Text), "Highlight this"); + var highlightedTextParam = Parameter(nameof(MudHighlighter.HighlightedText), "Highlight"); + var markupParam = Parameter(nameof(MudHighlighter.Markup), true); + var classParam = Parameter(nameof(MudHighlighter.Class), "my-custom-class"); + + var comp = Context.RenderComponent(textParam, highlightedTextParam, markupParam, classParam); + + comp.MarkupMatches("Highlight this"); + } + + [Test] + public void MudHighlighter_MarkupFalse_AfterMarkupTrue_ClearsHtmlAwareFragmentsAndRendersCorrectly() + { + var initialText = "Test with HTML and highlight"; + var initialHighlightedText = "highlight"; + + // 1. Render initially with Markup = true + var comp = Context.RenderComponent(parameters => parameters + .Add(p => p.Text, initialText) + .Add(p => p.HighlightedText, initialHighlightedText) + .Add(p => p.Markup, true) + ); + + comp.MarkupMatches("Test with HTML and highlight"); + + // 2. Re-render with Markup = false + comp.SetParametersAndRender(parameters => parameters + .Add(p => p.Text, initialText) // Keep text and highlight the same + .Add(p => p.HighlightedText, initialHighlightedText) + .Add(p => p.Markup, false) + ); + + var expectedMarkup = "Test with <b>HTML</b> and highlight"; + comp.MarkupMatches(expectedMarkup); + } } } diff --git a/src/MudBlazor.UnitTests/Components/MaskTests.cs b/src/MudBlazor.UnitTests/Components/MaskTests.cs index da892d3d4508..182b59a81b75 100644 --- a/src/MudBlazor.UnitTests/Components/MaskTests.cs +++ b/src/MudBlazor.UnitTests/Components/MaskTests.cs @@ -4,6 +4,7 @@ using Bunit; using FluentAssertions; +using Microsoft.AspNetCore.Components; using Microsoft.AspNetCore.Components.Web; using MudBlazor.UnitTests.TestComponents.Mask; using NUnit.Framework; @@ -1068,5 +1069,28 @@ await comp.InvokeAsync(() => Context.JSInterop.VerifyInvoke("mudWindow.copyToClipboard", 2); Context.JSInterop.Invocations["mudWindow.copyToClipboard"][1].Arguments.Should().BeEquivalentTo(["c"]); } + + [Test] + public async Task Mask_Autofill_ShouldUpdateValueAndText_WhenAutofilled() + { + // Arrange + var mask = new PatternMask("(000) 000-0000"); + var autofillValue = "(123) 456-7890"; + + var comp = Context.RenderComponent>(parameters => parameters + .Add(p => p.Mask, mask) + .Add(p => p.DebounceInterval, 0) + ); + + var textField = comp.Instance; + var inputElement = comp.Find("input"); + + // Act + // Simulate the 'oninput' event that occurs during browser autofill + await inputElement.InputAsync(new ChangeEventArgs() { Value = autofillValue }); + + // Assert + textField.Text.Should().Be(autofillValue); + } } } diff --git a/src/MudBlazor.UnitTests/Components/ProgressCircularTests.cs b/src/MudBlazor.UnitTests/Components/ProgressCircularTests.cs index e568bd8e6ead..fa8ce199ef70 100644 --- a/src/MudBlazor.UnitTests/Components/ProgressCircularTests.cs +++ b/src/MudBlazor.UnitTests/Components/ProgressCircularTests.cs @@ -1,7 +1,4 @@ - -using System; -using System.Globalization; -using Bunit; +using Bunit; using FluentAssertions; using NUnit.Framework; @@ -76,7 +73,7 @@ public void DefaultStructure(bool indeterminate) [Test] [TestCase(true)] - [TestCase(true)] + [TestCase(false)] public void TestClassesForRounded(bool rounded) { var comp = Context.RenderComponent(x => x.Add(y => y.Rounded, rounded)); @@ -95,7 +92,7 @@ public void TestClassesForRounded(bool rounded) [Test] [TestCase(true)] - [TestCase(true)] + [TestCase(false)] public void TestClassesForIntermediate(bool indeterminate) { var comp = Context.RenderComponent(x => x.Add(y => y.Indeterminate, indeterminate)); @@ -105,10 +102,12 @@ public void TestClassesForIntermediate(bool indeterminate) if (indeterminate) { container.ClassList.Should().Contain("mud-progress-indeterminate"); + container.ClassList.Should().NotContain("mud-progress-static"); } else { - container.ClassList.Should().NotContain("mud-progress-static"); + container.ClassList.Should().Contain("mud-progress-static"); + container.ClassList.Should().NotContain("mud-progress-indeterminate"); } var circleContainer = comp.Find(".mud-progress-circular-circle"); @@ -116,10 +115,12 @@ public void TestClassesForIntermediate(bool indeterminate) if (indeterminate) { circleContainer.ClassList.Should().Contain("mud-progress-indeterminate"); + circleContainer.ClassList.Should().NotContain("mud-progress-static"); } else { - circleContainer.ClassList.Should().NotContain("mud-progress-static"); + circleContainer.ClassList.Should().Contain("mud-progress-static"); + circleContainer.ClassList.Should().NotContain("mud-progress-indeterminate"); } } @@ -148,5 +149,38 @@ public void TestClassesForColor(Color color, string expectedString) container.ClassList.Should().Contain($"mud-{expectedString}-text"); } + + [Test] + [TestCase(3, "22.5 22.5 43 43")] + [TestCase(5, "21.5 21.5 45 45")] + [TestCase(10, "19 19 50 50")] + [TestCase(1, "23.5 23.5 41 41")] + [TestCase(0, "24 24 40 40")] + public void MudProgressCircular_ShouldHaveCorrectViewBox_BasedOnStrokeWidth(int strokeWidth, string expectedViewBox) + { + var comp = Context.RenderComponent(parameters => parameters + .Add(p => p.StrokeWidth, strokeWidth) + ); + + // Find the SVG element + var svgElement = comp.Find("svg"); + svgElement.Should().NotBeNull(); + + // Check the viewBox attribute + var viewBoxAttribute = svgElement.GetAttribute("viewBox"); + viewBoxAttribute.Should().Be(expectedViewBox); + + // Test with Indeterminate = true as well + var compIndeterminate = Context.RenderComponent(parameters => parameters + .Add(p => p.StrokeWidth, strokeWidth) + .Add(p => p.Indeterminate, true) + ); + + var svgElementIndeterminate = compIndeterminate.Find("svg"); + svgElementIndeterminate.Should().NotBeNull(); + + var viewBoxAttributeIndeterminate = svgElementIndeterminate.GetAttribute("viewBox"); + viewBoxAttributeIndeterminate.Should().Be(expectedViewBox); + } } } diff --git a/src/MudBlazor.UnitTests/Components/SelectTests.cs b/src/MudBlazor.UnitTests/Components/SelectTests.cs index a3f99c3c9d05..5c08a3884050 100644 --- a/src/MudBlazor.UnitTests/Components/SelectTests.cs +++ b/src/MudBlazor.UnitTests/Components/SelectTests.cs @@ -1609,6 +1609,25 @@ public async Task Select_HandleMouseDown(MouseEventArgs args) break; } } + + [Test] + public void SelectMultiSelectFieldChangedTest() + { + var comp = Context.RenderComponent(); + + //default values + comp.Instance.FormFieldChangedEventArgs.Should().BeNull(); + + //open the popover + var input = comp.Find("div.mud-input-control"); + input.MouseDown(); + + //click an item and see the value change + comp.WaitForAssertion(() => comp.FindAll("div.mud-list-item").Count.Should().BeGreaterThan(0)); + comp.Find(".mud-list-item").Click(); + + comp.Instance.FormFieldChangedEventArgs.NewValue.Should().BeEquivalentTo(comp.Instance.States.Take(2).Reverse()); + } #nullable disable } } diff --git a/src/MudBlazor.UnitTests/Other/TypeIdentifierTests.cs b/src/MudBlazor.UnitTests/Other/TypeIdentifierTests.cs index b5cbfd82cab1..56fc0f290a5b 100644 --- a/src/MudBlazor.UnitTests/Other/TypeIdentifierTests.cs +++ b/src/MudBlazor.UnitTests/Other/TypeIdentifierTests.cs @@ -93,6 +93,20 @@ public void IsBoolean_Test(Type type, bool expected) isBoolean.Should().Be(expected); } + [Test] + [TestCase(null, false)] + [TestCase(typeof(int), false)] + [TestCase(typeof(int?), false)] + [TestCase(typeof(DateOnly), true)] + [TestCase(typeof(DateOnly?), true)] + [TestCase(typeof(DateTime), false)] + [TestCase(typeof(DateTime?), false)] + public void IsDateOnly_Test(Type type, bool expected) + { + var isDateOnly = TypeIdentifier.IsDateOnly(type); + isDateOnly.Should().Be(expected); + } + [Test] [TestCase(null, false)] [TestCase(typeof(int), false)] diff --git a/src/MudBlazor/Components/Autocomplete/MudAutocomplete.razor.cs b/src/MudBlazor/Components/Autocomplete/MudAutocomplete.razor.cs index 79a8264be093..ca5e91eba4e5 100644 --- a/src/MudBlazor/Components/Autocomplete/MudAutocomplete.razor.cs +++ b/src/MudBlazor/Components/Autocomplete/MudAutocomplete.razor.cs @@ -742,10 +742,25 @@ public async Task OpenMenuAsync() // Get range of items based off selected item so the selected item can be scrolled to when strict is set to false if (!Strict && searchedItems.Length != 0 && !EqualityComparer.Default.Equals(Value, default(T))) { - int split = (MaxItems.Value / 2) + 1; + int maxItems = MaxItems.Value; int valueIndex = Array.IndexOf(searchedItems, Value); - int endIndex = Math.Min(valueIndex + split, searchedItems.Length); - int startIndex = endIndex - Math.Min(MaxItems.Value, searchedItems.Length); + + // Center the selected item in the list if possible + int half = maxItems / 2; + int startIndex = valueIndex - half; + int endIndex = startIndex + maxItems; + + // Adjust if out of bounds + if (startIndex < 0) + { + startIndex = 0; + endIndex = Math.Min(maxItems, searchedItems.Length); + } + else if (endIndex > searchedItems.Length) + { + endIndex = searchedItems.Length; + startIndex = Math.Max(0, endIndex - maxItems); + } searchedItems = searchedItems.Take(new Range(startIndex, endIndex)).ToArray(); } diff --git a/src/MudBlazor/Components/DataGrid/FieldType.cs b/src/MudBlazor/Components/DataGrid/FieldType.cs index 5c9140d711e4..652ba140afce 100644 --- a/src/MudBlazor/Components/DataGrid/FieldType.cs +++ b/src/MudBlazor/Components/DataGrid/FieldType.cs @@ -37,6 +37,11 @@ public class FieldType ///

public bool IsDateTime { get; init; } + ///
+ /// Whether the represents a date only. + ///
+ public bool IsDateOnly { get; init; } + ///
/// Whether the represents a true/false value. ///
@@ -59,6 +64,7 @@ public static FieldType Identify(Type? type) IsNumber = TypeIdentifier.IsNumber(type), IsEnum = TypeIdentifier.IsEnum(type), IsDateTime = TypeIdentifier.IsDateTime(type), + IsDateOnly = TypeIdentifier.IsDateOnly(type), IsBoolean = TypeIdentifier.IsBoolean(type), IsGuid = TypeIdentifier.IsGuid(type) }; diff --git a/src/MudBlazor/Components/DataGrid/FilterExpressionGenerator.cs b/src/MudBlazor/Components/DataGrid/FilterExpressionGenerator.cs index 8f314cf37cbd..e2b24cfc3f29 100644 --- a/src/MudBlazor/Components/DataGrid/FilterExpressionGenerator.cs +++ b/src/MudBlazor/Components/DataGrid/FilterExpressionGenerator.cs @@ -103,6 +103,25 @@ public static class FilterExpressionGenerator }; } + if (fieldType.IsDateOnly) + { + if (filter.Value is null && filter.Operator != FilterOperator.DateOnly.Empty && filter.Operator != FilterOperator.DateOnly.NotEmpty) + return x => true; + + return filter.Operator switch + { + FilterOperator.DateOnly.Is => propertyExpression.GenerateBinary(ExpressionType.Equal, filter.Value), + FilterOperator.DateOnly.IsNot => propertyExpression.GenerateBinary(ExpressionType.NotEqual, filter.Value), + FilterOperator.DateOnly.After => propertyExpression.GenerateBinary(ExpressionType.GreaterThan, filter.Value), + FilterOperator.DateOnly.OnOrAfter => propertyExpression.GenerateBinary(ExpressionType.GreaterThanOrEqual, filter.Value), + FilterOperator.DateOnly.Before => propertyExpression.GenerateBinary(ExpressionType.LessThan, filter.Value), + FilterOperator.DateOnly.OnOrBefore => propertyExpression.GenerateBinary(ExpressionType.LessThanOrEqual, filter.Value), + FilterOperator.DateOnly.Empty => propertyExpression.GenerateBinary(ExpressionType.Equal, null), + FilterOperator.DateOnly.NotEmpty => propertyExpression.GenerateBinary(ExpressionType.NotEqual, null), + _ => x => true + }; + } + if (fieldType.IsDateTime) { if (filter.Value is null && filter.Operator != FilterOperator.DateTime.Empty && filter.Operator != FilterOperator.DateTime.NotEmpty) diff --git a/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor b/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor index 02c730712bd6..e75c876ce733 100644 --- a/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor +++ b/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor @@ -42,11 +42,15 @@ @Localizer[LanguageResource.MudDataGrid_False] } + else if (fieldType.IsDateOnly && !(@operator ?? "").EndsWith("empty")) + { + + } else if (fieldType.IsDateTime && !(@operator ?? "").EndsWith("empty")) { - + diff --git a/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor.cs b/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor.cs index 0a7566adfdfb..d4babc69793e 100644 --- a/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor.cs +++ b/src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor.cs @@ -75,7 +75,8 @@ private IReadOnlyCollection operators private double? valueNumber => fieldType.IsNumber ? (double?)Column.FilterContext.FilterDefinition.Value : default; private bool? valueBool => fieldType.IsBoolean && Column.FilterContext.FilterDefinition.Value is not null ? (bool?)Column.FilterContext.FilterDefinition.Value : default; private Enum valueEnum => fieldType.IsEnum && Column.FilterContext.FilterDefinition.Value is not null ? (Enum)Column.FilterContext.FilterDefinition.Value : default; - private DateTime? valueDate => fieldType.IsDateTime ? (DateTime?)Column.FilterContext.FilterDefinition.Value : default; + private DateTime? valueDateTimeForPicker => fieldType.IsDateTime ? (DateTime?)Column.FilterContext.FilterDefinition.Value : default; + private DateTime? valueDateOnlyForPicker => fieldType.IsDateOnly && Column.FilterContext.FilterDefinition.Value != null ? ((DateOnly)Column.FilterContext.FilterDefinition.Value).ToDateTime(TimeOnly.MinValue) : null; private TimeSpan? valueTime => fieldType.IsDateTime && Column.FilterContext.FilterDefinition.Value is not null ? ((DateTime?)Column.FilterContext.FilterDefinition.Value).Value.TimeOfDay : null; private string @operator => Column.FilterContext.FilterDefinition.Operator ?? operators.FirstOrDefault(); @@ -118,8 +119,9 @@ internal async Task BoolValueChangedAsync(bool? value) await ApplyFilterAsync(Column.FilterContext.FilterDefinition); } - internal async Task DateValueChangedAsync(DateTime? value) + internal async Task DateTimeValueChangedAsync(DateTime? value) { + // For DateTime fields, handle both date and time components if (value != null) { var date = value.Value.Date; @@ -127,29 +129,44 @@ internal async Task DateValueChangedAsync(DateTime? value) // get the time component and add it to the date. if (valueTime != null) { - date.Add(valueTime.Value); + date = date.Add(valueTime.Value); } Column.FilterContext.FilterDefinition.Value = date; - await ApplyFilterAsync(Column.FilterContext.FilterDefinition); } else { Column.FilterContext.FilterDefinition.Value = value; - await ApplyFilterAsync(Column.FilterContext.FilterDefinition); } + + await ApplyFilterAsync(Column.FilterContext.FilterDefinition); + } + + internal async Task DateOnlyValueChangedAsync(DateTime? value) + { + // For DateOnly fields, convert DateTime to DateOnly + if (value != null) + { + var dateOnly = DateOnly.FromDateTime(value.Value); + Column.FilterContext.FilterDefinition.Value = dateOnly; + } + else + { + Column.FilterContext.FilterDefinition.Value = null; + } + await ApplyFilterAsync(Column.FilterContext.FilterDefinition); } internal async Task TimeValueChangedAsync(TimeSpan? value) { - if (valueDate != null) + if (valueDateTimeForPicker != null) { - var date = valueDate.Value.Date; + var date = valueDateTimeForPicker.Value.Date; // get the time component and add it to the date. - if (valueTime != null) + if (value != null) { - date = date.Add(valueTime.Value); + date = date.Add(value.Value); } Column.FilterContext.FilterDefinition.Value = date; diff --git a/src/MudBlazor/Components/DataGrid/FilterOperator.cs b/src/MudBlazor/Components/DataGrid/FilterOperator.cs index e16f1e0e0df0..68d8f580b016 100644 --- a/src/MudBlazor/Components/DataGrid/FilterOperator.cs +++ b/src/MudBlazor/Components/DataGrid/FilterOperator.cs @@ -184,6 +184,52 @@ public static class DateTime public const string NotEmpty = "is not empty"; } + ///
+ /// Represents filters which are available for date only values. + ///
+ public static class DateOnly + { + ///
+ /// Find values matching the filter date. + ///
+ public const string Is = "is"; + + ///
+ /// Find values different from the filter date. + ///
+ public const string IsNot = "is not"; + + ///
+ /// Find values after the filter date. + ///
+ public const string After = "is after"; + + ///
+ /// Find values on or after the filter date. + ///
+ public const string OnOrAfter = "is on or after"; + + ///
+ /// Find values before the filter date. + ///
+ public const string Before = "is before"; + + ///
+ /// Find values on or before the filter date. + ///
+ public const string OnOrBefore = "is on or before"; + + ///
+ /// Find null values. + ///
+ public const string Empty = "is empty"; + + ///
+ /// Find any non-null value. + ///
+ public const string NotEmpty = "is not empty"; + } + ///
/// Represents filters which are available for Guid values. ///
@@ -250,6 +296,20 @@ internal static string[] GetOperatorByDataType(FieldType fieldType) Boolean.Is, }; } + if (fieldType.IsDateOnly) + { + return new[] + { + DateOnly.Is, + DateOnly.IsNot, + DateOnly.After, + DateOnly.OnOrAfter, + DateOnly.Before, + DateOnly.OnOrBefore, + DateOnly.Empty, + DateOnly.NotEmpty, + }; + } if (fieldType.IsDateTime) { return new[] diff --git a/src/MudBlazor/Components/DataGrid/HeaderCell.razor.cs b/src/MudBlazor/Components/DataGrid/HeaderCell.razor.cs index f6a79585edfc..9d392712cd61 100644 --- a/src/MudBlazor/Components/DataGrid/HeaderCell.razor.cs +++ b/src/MudBlazor/Components/DataGrid/HeaderCell.razor.cs @@ -376,7 +376,9 @@ internal async Task SortChangedAsync(MouseEventArgs args) SortDirection = SortDirection switch { SortDirection.Ascending => SortDirection.Descending, - SortDirection.Descending => SortDirection.None, + SortDirection.Descending => DataGrid?.AllowUnsorted ?? false + ? SortDirection.None + : SortDirection.Ascending, _ => SortDirection.Ascending }; @@ -386,9 +388,9 @@ internal async Task SortChangedAsync(MouseEventArgs args) return; } - DataGrid.DropContainerHasChanged(); + DataGrid?.DropContainerHasChanged(); - if ((args.MetaKey || args.CtrlKey) && DataGrid.SortMode == SortMode.Multiple) + if ((args.MetaKey || args.CtrlKey) && DataGrid?.SortMode == SortMode.Multiple) await InvokeAsync(() => DataGrid.ExtendSortAsync(Column.PropertyName, SortDirection, Column.GetLocalSortFunc(), Column.Comparer)); else await InvokeAsync(() => DataGrid.SetSortAsync(Column.PropertyName, SortDirection, Column.GetLocalSortFunc(), Column.Comparer)); diff --git a/src/MudBlazor/Components/DataGrid/MudDataGrid.razor.cs b/src/MudBlazor/Components/DataGrid/MudDataGrid.razor.cs index 2ccad9b67d51..7ffd277efd98 100644 --- a/src/MudBlazor/Components/DataGrid/MudDataGrid.razor.cs +++ b/src/MudBlazor/Components/DataGrid/MudDataGrid.razor.cs @@ -1101,6 +1101,15 @@ public bool Groupable #endregion + ///
+ /// Allows a sort direction of in addition to and . + ///
+ /// + /// Defaults to true. When false, the sort mode will only toggle between and . + /// + [Parameter] + public bool AllowUnsorted { get; set; } = true; + #region Properties internal IEnumerable CurrentPageItems diff --git a/src/MudBlazor/Components/DataGrid/TypeIdentifier.cs b/src/MudBlazor/Components/DataGrid/TypeIdentifier.cs index 64d111268504..680824d4c25b 100644 --- a/src/MudBlazor/Components/DataGrid/TypeIdentifier.cs +++ b/src/MudBlazor/Components/DataGrid/TypeIdentifier.cs @@ -88,6 +88,23 @@ public static bool IsDateTime(Type? type) return underlyingType is not null && underlyingType == typeof(DateTime); } + public static bool IsDateOnly(Type? type) + { + if (type is null) + { + return false; + } + + if (type == typeof(DateOnly)) + { + return true; + } + + var underlyingType = Nullable.GetUnderlyingType(type); + + return underlyingType is not null && underlyingType == typeof(DateOnly); + } + public static bool IsBoolean(Type? type) { if (type is null) diff --git a/src/MudBlazor/Components/Dialog/MudDialog.razor.cs b/src/MudBlazor/Components/Dialog/MudDialog.razor.cs index 683bd7b335a4..7eb16b262b1a 100644 --- a/src/MudBlazor/Components/Dialog/MudDialog.razor.cs +++ b/src/MudBlazor/Components/Dialog/MudDialog.razor.cs @@ -275,6 +275,10 @@ protected override async Task OnAfterRenderAsync(bool firstRender) { // Forward render update to instance (_reference.Dialog as IMudStateHasChanged)?.StateHasChanged(); + + //forward render update to instance container + if (_reference.Dialog is MudDialog { DialogInstance: not null } dialog) + await InvokeAsync(dialog.DialogInstance!.StateHasChanged); } else { diff --git a/src/MudBlazor/Components/Dialog/MudDialogContainer.razor b/src/MudBlazor/Components/Dialog/MudDialogContainer.razor index 6ee05cd0298c..eea75629412a 100644 --- a/src/MudBlazor/Components/Dialog/MudDialogContainer.razor +++ b/src/MudBlazor/Components/Dialog/MudDialogContainer.razor @@ -8,8 +8,8 @@ }
- -
+ +
@if (!GetHideHeader()) {
diff --git a/src/MudBlazor/Components/Dialog/MudDialogContainer.razor.cs b/src/MudBlazor/Components/Dialog/MudDialogContainer.razor.cs index 828d220523f6..d798e7ddd46a 100644 --- a/src/MudBlazor/Components/Dialog/MudDialogContainer.razor.cs +++ b/src/MudBlazor/Components/Dialog/MudDialogContainer.razor.cs @@ -26,6 +26,7 @@ public partial class MudDialogContainer : MudComponentBase, IMudDialogInstanceIn { private bool _disposed; private MudDialog? _dialog; + private ElementReference _dialogContainerReference; private readonly ParameterState _dialogOptionsState; private readonly ParameterState _titleState; private readonly string _elementId = Identifier.Create("dialog"); @@ -159,6 +160,12 @@ internal async Task HandleKeyDownAsync(KeyboardEventArgs args) } } + public async void OnMouseUp(MouseEventArgs args) + { + if (args.Button > 0) + await RefocusDialogAsync(); + } + internal async Task HandleKeyUpAsync(KeyboardEventArgs args) { if (_dialog is not null && _dialog.OnKeyUp.HasDelegate) @@ -217,15 +224,28 @@ private bool GetCloseOnEscapeKey() private async Task HandleBackgroundClickAsync(MouseEventArgs args) { if (!GetBackdropClick()) + { + await RefocusDialogAsync(); return; + } - if (_dialog is null || !_dialog.OnBackdropClick.HasDelegate) + if (_dialog is not null && _dialog.OnBackdropClick.HasDelegate) + { + await _dialog.OnBackdropClick.InvokeAsync(args); + await RefocusDialogAsync(); + } + else { ((IMudDialogInstance)this).Cancel(); - return; } + } - await _dialog.OnBackdropClick.InvokeAsync(args); + private async Task RefocusDialogAsync() + { + if (GetCloseOnEscapeKey() && !_disposed) + { + await _dialogContainerReference.FocusAsync(); + } } private string GetPosition() diff --git a/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor b/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor index 29b4f5cd9ca3..a2c1c9cdfc1a 100644 --- a/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor +++ b/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor @@ -2,7 +2,7 @@ @inherits MudComponentBase
-
+

@if (TitleContent is not null) { @@ -15,12 +15,15 @@
@if (!HideIcon) { - + }
-
- @ChildContent -
+ @if (KeepContentAlive || _expandedState.Value) + { + + }
diff --git a/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor.cs b/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor.cs index 6e2cf55e221d..b72c7986769e 100644 --- a/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor.cs +++ b/src/MudBlazor/Components/ExpansionPanel/MudExpansionPanel.razor.cs @@ -1,6 +1,5 @@ -using System; -using System.Threading.Tasks; -using Microsoft.AspNetCore.Components; +using Microsoft.AspNetCore.Components; +using Microsoft.AspNetCore.Components.Web; using MudBlazor.State; using MudBlazor.Utilities; @@ -154,6 +153,13 @@ public partial class MudExpansionPanel : MudComponentBase, IDisposable [Category(CategoryTypes.ExpansionPanel.Behavior)] public RenderFragment? ChildContent { get; set; } + ///
+ /// When true, the content remains in the DOM even when the panel is collapsed. + ///
+ [Parameter] + [Category(CategoryTypes.ExpansionPanel.Behavior)] + public bool KeepContentAlive { get; set; } = true; + ///
/// The next panel is currently expanded. ///
@@ -253,5 +259,18 @@ protected virtual void Dispose(bool disposing) Parent?.RemovePanel(this); } } + + private async Task HandleKeyDownAsync(KeyboardEventArgs e) + { + if (Disabled) + { + return; + } + + if (e.Key == "Enter" || e.Key == " ") + { + await ToggleExpansionAsync(); + } + } } } diff --git a/src/MudBlazor/Components/Highlighter/MudHighlighter.razor b/src/MudBlazor/Components/Highlighter/MudHighlighter.razor index 7d1dae07ded8..b34629df01ea 100644 --- a/src/MudBlazor/Components/Highlighter/MudHighlighter.razor +++ b/src/MudBlazor/Components/Highlighter/MudHighlighter.razor @@ -1,20 +1,78 @@ @namespace MudBlazor @inherits MudComponentBase @using System.Text.RegularExpressions -@using static MudBlazor.Components.Highlighter.Splitter +@using MudBlazor.Components.Highlighter +@using System.Text -@foreach (var fragment in _fragments.Span) +@if (Markup) { - if (IsMatch(fragment)) - { - @fragment - } - else if (Markup) - { - @ToRenderFragment(fragment) - } - else - { - @fragment - } + if (_htmlAwareFragments != null) + { + @CreateFragmentContent(); + } + else if (!string.IsNullOrEmpty(Text)) + { + @((MarkupString)Text) + } +} +else if (_fragments.Length > 0) +{ + foreach (var fragment in _fragments.Span) + { + if (IsMatch(fragment)) + { + @fragment + } + else + { + @fragment + } + } +} +else if (!string.IsNullOrEmpty(Text)) +{ + @Text +} + +@code { + private RenderFragment CreateFragmentContent() => builder => + { + int sequence = 0; + + foreach (var fragmentInfo in _htmlAwareFragments) + { + switch (fragmentInfo.Type) + { + case FragmentType.HighlightedText: + if (IsMatch(fragmentInfo.Content)) + { + builder.OpenElement(sequence++, "mark"); + + if (!string.IsNullOrWhiteSpace(Class)) + builder.AddAttribute(sequence++, "class", Class); + + if (!string.IsNullOrWhiteSpace(Style)) + builder.AddAttribute(sequence++, "style", Style); + + if (UserAttributes != null || UserAttributes.Count != 0) + builder.AddMultipleAttributes(sequence++, UserAttributes); + + builder.AddContent(sequence++, fragmentInfo.Content); + builder.CloseElement(); + } + else + { + builder.AddContent(sequence++, fragmentInfo.Content); + } + break; + case FragmentType.Markup: + builder.AddMarkupContent(sequence++, fragmentInfo.Content); + break; + case FragmentType.Text: + default: + builder.AddContent(sequence++, fragmentInfo.Content); + break; + } + } + }; } diff --git a/src/MudBlazor/Components/Highlighter/MudHighlighter.razor.cs b/src/MudBlazor/Components/Highlighter/MudHighlighter.razor.cs index 7798be2b071e..4a013cd026e1 100644 --- a/src/MudBlazor/Components/Highlighter/MudHighlighter.razor.cs +++ b/src/MudBlazor/Components/Highlighter/MudHighlighter.razor.cs @@ -2,12 +2,11 @@ // MudBlazor licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -using System; -using System.Collections.Generic; -using System.Linq; using System.Text.RegularExpressions; using Microsoft.AspNetCore.Components; -using static MudBlazor.Components.Highlighter.Splitter; +using MudBlazor.Components.Highlighter; // Added for FragmentInfo +// Removed: using static MudBlazor.Components.Highlighter.Splitter; +// We will call Splitter methods statically: Splitter.GetFragments, Splitter.GetHtmlAwareFragments namespace MudBlazor; @@ -20,6 +19,7 @@ public partial class MudHighlighter : MudComponentBase { private Memory _fragments; private string? _regex; + private List _htmlAwareFragments = []; ///
/// The text to consider for highlighting. @@ -40,7 +40,7 @@ public partial class MudHighlighter : MudComponentBase ///
[Parameter] [Category(CategoryTypes.Highlighter.Behavior)] - public IEnumerable HighlightedTexts { get; set; } = Enumerable.Empty(); + public IEnumerable HighlightedTexts { get; set; } = []; ///
/// Whether highlighted text is case sensitive. @@ -79,12 +79,23 @@ public partial class MudHighlighter : MudComponentBase protected override void OnParametersSet() { base.OnParametersSet(); - _fragments = GetFragments(Text, HighlightedText, HighlightedTexts, out _regex, CaseSensitive, UntilNextBoundary); + if (Markup) + { + _htmlAwareFragments = Splitter.GetHtmlAwareFragments(Text, HighlightedText, HighlightedTexts, out _regex, CaseSensitive, UntilNextBoundary); + _fragments = Memory.Empty; + } + else + { + _fragments = Splitter.GetFragments(Text, HighlightedText, HighlightedTexts, out _regex, CaseSensitive, UntilNextBoundary); + + if (_htmlAwareFragments == null) + _htmlAwareFragments = []; + else + _htmlAwareFragments.Clear(); + } } bool IsMatch(string fragment) => !string.IsNullOrWhiteSpace(fragment) && !string.IsNullOrWhiteSpace(_regex) && Regex.IsMatch(fragment, _regex, CaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase); - - static RenderFragment ToRenderFragment(string markupContent) => builder => { builder.AddMarkupContent(0, markupContent); }; } diff --git a/src/MudBlazor/Components/Highlighter/Splitter.cs b/src/MudBlazor/Components/Highlighter/Splitter.cs index ff02f18cb6c8..b31d29af17a9 100644 --- a/src/MudBlazor/Components/Highlighter/Splitter.cs +++ b/src/MudBlazor/Components/Highlighter/Splitter.cs @@ -1,122 +1,360 @@ -using System; -using System.Collections.Generic; +using System.Net; using System.Text; using System.Text.RegularExpressions; -using System.Threading; -namespace MudBlazor.Components.Highlighter -{ #nullable enable +namespace MudBlazor.Components.Highlighter; + +public enum FragmentType { Text, HighlightedText, Markup } +public record FragmentInfo(string Content, FragmentType Type); + +public static partial class Splitter +{ + private static readonly TimeSpan _regexTimeout = TimeSpan.FromSeconds(5); + + private static readonly Regex _htmlTagRegex = HtmlTagMatcher(); + + private static readonly Regex _tagParser = HtmlTagParser(); + + private static readonly HashSet _voidElements = new(StringComparer.OrdinalIgnoreCase) + { + "area", "base", "br", "col", "embed", "hr", "img", + "input", "link", "meta", "source", "track", "wbr" + }; + + private const string NextBoundary = ".*?\\b"; + private static StringBuilder? _stringBuilderCached; + + public static Memory GetFragments(string? text, string? highlightedText, + IEnumerable? highlightedTexts, out string regex, + bool caseSensitive = false, bool untilNextBoundary = false) + { + if (string.IsNullOrEmpty(text)) + { + regex = string.Empty; + return Memory.Empty; + } + + var highlightTerms = BuildHighlightTermsList(highlightedText, highlightedTexts); + if (highlightTerms.Count == 0) + { + regex = string.Empty; + return new[] { text }; + } + + regex = BuildRegexPattern(highlightTerms, untilNextBoundary); + var splits = Regex.Split(text, regex, GetRegexOptions(caseSensitive) | RegexOptions.NonBacktracking, _regexTimeout); + var nonEmpty = splits.Where(s => !string.IsNullOrEmpty(s)).ToArray(); + + return new Memory(nonEmpty); + } - ///
- /// Splits text into fragments based on text to be highlighted. - ///
- public static class Splitter - { - private const string NextBoundary = ".*?\\b"; - - private static StringBuilder? s_stringBuilderCached; - - ///
- /// Splits text into fragments based on text to be highlighted. - ///
- /// The text to examine. - /// The text to be highlighted. - /// The multiple texts to be highlighted. - /// The regular expression used to split text into fragments. - /// Uses a case-sensitive check for highlighted text. - /// Highlights text until the next regular expression boundary. - /// A block of memory with the matched text to highlight. - public static Memory GetFragments(string? text, - string? highlightedText, - IEnumerable? highlightedTexts, - out string regex, - bool caseSensitive = false, - bool untilNextBoundary = false) - { - if (string.IsNullOrEmpty(text)) + public static List GetHtmlAwareFragments(string? text, string? highlightedText, + IEnumerable? highlightedTexts, out string regex, + bool caseSensitive, bool untilNextBoundary) + { + regex = string.Empty; + + if (string.IsNullOrEmpty(text)) + return []; + + var highlightTerms = BuildHighlightTermsList(highlightedText, highlightedTexts); + var highlightRegex = BuildHighlightRegex(highlightTerms, caseSensitive, untilNextBoundary, out regex); + var stringComparison = GetStringComparison(caseSensitive); + + var rawFragments = _htmlTagRegex.Split(text); + var tempFragments = ProcessRawFragments(rawFragments, highlightTerms, highlightRegex, stringComparison); + + return SanitizeFragments(tempFragments, highlightTerms, highlightRegex); + } + + private static List BuildHighlightTermsList(string? single, IEnumerable? multiple) + { + var terms = new List(); + + AddTermIfNotEmpty(terms, single); + + if (multiple != null) + { + foreach (var term in multiple.Where(s => !string.IsNullOrEmpty(s))) { - regex = string.Empty; - return Memory.Empty; + AddTermIfNotEmpty(terms, term); } + } - var builder = Interlocked.Exchange(ref s_stringBuilderCached, null) ?? new(); - //the first brace in the pattern is to keep the patten when splitting, - //the `(?:` in the pattern is to accept multiple highlightedTexts but not capture them. - builder.Append("((?:"); + return terms; + + static void AddTermIfNotEmpty(List terms, string? term) + { + if (string.IsNullOrEmpty(term)) return; - //this becomes true if `AppendPattern` was called at least once. - var hasAtLeastOnePattern = false; - if (!string.IsNullOrEmpty(highlightedText)) + terms.Add(term); + + var encoded = WebUtility.HtmlEncode(term); + if (encoded != term) { - AppendPattern(highlightedText); + terms.Add(encoded); } + } + } + + private static string BuildRegexPattern(List terms, bool untilNextBoundary) + { + var builder = GetStringBuilder(); - if (highlightedTexts is not null) + try + { + builder.Append("((?:"); + + for (var i = 0; i < terms.Count; i++) { - foreach (var substring in highlightedTexts) - { - if (string.IsNullOrEmpty(substring)) - continue; - - //split pattern if we already added an string to search. - if (hasAtLeastOnePattern) - { - builder.Append(")|(?:"); - } - - AppendPattern(substring); - } + if (i > 0) builder.Append(")|(?:"); + builder.Append(Regex.Escape(terms[i])); + if (untilNextBoundary) builder.Append(NextBoundary); } - if (hasAtLeastOnePattern) + builder.Append("))"); + return builder.ToString(); + } + finally + { + ReturnStringBuilder(builder); + } + } + + private static Regex BuildHighlightRegex(List terms, bool caseSensitive, bool untilNextBoundary, out string regex) + { + regex = string.Empty; + + if (terms.Count == 0) return new Regex("^$", RegexOptions.NonBacktracking, _regexTimeout); + + regex = BuildRegexPattern(terms, untilNextBoundary); + + return new Regex(regex, GetRegexOptions(caseSensitive) | RegexOptions.Singleline | RegexOptions.NonBacktracking, _regexTimeout); + } + + private static List ProcessRawFragments( + string[] rawFragments, + List highlightTerms, + Regex highlightRegex, + StringComparison stringComparison) + { + var tempFragments = new List(); + + foreach (var fragment in rawFragments.Where(s => !string.IsNullOrEmpty(s))) + { + if (_htmlTagRegex.IsMatch(fragment)) + { + tempFragments.Add(new FragmentInfo(fragment, FragmentType.Markup)); + } + else if (IsDirectMatch(fragment, highlightTerms, stringComparison)) { - //close the last pattern group and the capture group. - builder.Append("))"); + tempFragments.Add(new FragmentInfo(fragment, FragmentType.HighlightedText)); } else { - builder.Clear(); - s_stringBuilderCached = builder; + tempFragments.AddRange(ProcessTextSegment(fragment, highlightRegex)); + } + } + + return tempFragments; + } + + private static bool IsDirectMatch(string segment, List highlightTerms, StringComparison comparison) + { + return highlightTerms.Any(term => string.Equals(segment, term, comparison)); + } + + private static IEnumerable ProcessTextSegment(string segment, Regex highlightRegex) + { + var fragments = new List(); + var lastIndex = 0; + + foreach (Match match in highlightRegex.Matches(segment)) + { + if (match.Index > lastIndex) + { + var textPart = segment.Substring(lastIndex, match.Index - lastIndex); + fragments.Add(new FragmentInfo(textPart, FragmentType.Text)); + } + + fragments.Add(new FragmentInfo(match.Value, FragmentType.HighlightedText)); + lastIndex = match.Index + match.Length; + } + + if (lastIndex < segment.Length) + { + fragments.Add(new FragmentInfo(segment.Substring(lastIndex), FragmentType.Text)); + } + + return fragments; + } + + private static List SanitizeFragments( + List fragments, + List highlightTerms, + Regex highlightRegex) + { + var result = new List(); + var tagStack = new Stack(); + + foreach (var fragment in fragments) + { + if (fragment.Type != FragmentType.Markup) + { + result.Add(fragment); + continue; + } + + ProcessMarkupFragment(fragment, result, tagStack); + } - //all patterns were empty or null. - regex = string.Empty; - return new[] { text }; + ProcessUnmatchedTags(result, tagStack, highlightTerms, highlightRegex); + return result; + } + + private static void ProcessMarkupFragment(FragmentInfo fragment, List result, Stack tagStack) + { + if (!TryParseTag(fragment.Content, out var tagInfo)) + { + result.Add(HtmlEncodeFragment(fragment)); + return; + } + + if (tagInfo.IsSelfClosing) + { + result.Add(fragment); + } + else if (tagInfo.IsClosing) + { + if (tagStack.Count > 0 && string.Equals(tagStack.Peek(), tagInfo.Name, StringComparison.OrdinalIgnoreCase)) + { + tagStack.Pop(); + result.Add(fragment); } + else + { + result.Add(HtmlEncodeFragment(fragment)); + } + } + else // opening tag + { + tagStack.Push(tagInfo.Name); + result.Add(fragment); + } + } - regex = builder.ToString(); - builder.Clear(); - s_stringBuilderCached = builder; - - var splits = Regex - .Split(text, - regex, - caseSensitive - ? RegexOptions.None - : RegexOptions.IgnoreCase); - var length = 0; - for (var i = 0; i < splits.Length; i++) + private static void ProcessUnmatchedTags(List result, Stack tagStack, List highlightTerms, Regex highlightRegex) + { + while (tagStack.Count > 0) + { + var unmatchedTag = tagStack.Pop(); + ProcessUnmatchedTag(result, unmatchedTag, highlightTerms, highlightRegex); + } + } + + private static void ProcessUnmatchedTag(List result, string unmatchedTag, List highlightTerms, Regex highlightRegex) + { + for (var i = result.Count - 1; i >= 0; i--) + { + var fragment = result[i]; + + if (fragment.Type != FragmentType.Markup) continue; + if (!TryParseTag(fragment.Content, out var tagInfo)) continue; + if (tagInfo.IsClosing || !string.Equals(tagInfo.Name, unmatchedTag, StringComparison.OrdinalIgnoreCase)) continue; + + var processedFragments = ProcessTextSegmentForUnmatched(fragment.Content, highlightRegex); + + if (processedFragments.Count > 0) + { + result.RemoveAt(i); + result.InsertRange(i, processedFragments); + } + else { - var s = splits[i]; - if (!string.IsNullOrEmpty(s)) - { - splits[length++] = s; - } + var isHighlight = highlightTerms.Contains(fragment.Content); + result[i] = new FragmentInfo(fragment.Content, isHighlight ? FragmentType.HighlightedText : FragmentType.Text); } - Array.Clear(splits, length, splits.Length - length); - return splits.AsMemory(0, length); + break; + } + } + + private static List ProcessTextSegmentForUnmatched(string segment, Regex highlightRegex) + { + var tempFragments = new List(); + var lastIndex = 0; - void AppendPattern(string value) + foreach (Match match in highlightRegex.Matches(segment)) + { + if (match.Index > lastIndex) { - hasAtLeastOnePattern = true; - //escapes the text for regex - value = Regex.Escape(value); - builder.Append(value); - if (untilNextBoundary) - { - builder.Append(NextBoundary); - } + var unmatchedSegment = segment.Substring(lastIndex, match.Index - lastIndex); + tempFragments.Add(new FragmentInfo(unmatchedSegment, FragmentType.Text)); } + + tempFragments.Add(new FragmentInfo(match.Value, FragmentType.HighlightedText)); + lastIndex = match.Index + match.Length; + } + + if (lastIndex > 0 && lastIndex < segment.Length) + { + tempFragments.Add(new FragmentInfo(segment.Substring(lastIndex), FragmentType.Text)); + } + + return tempFragments; + } + + private static FragmentInfo HtmlEncodeFragment(FragmentInfo original) + { + var encoded = WebUtility.HtmlEncode(original.Content); + var type = original.Type == FragmentType.HighlightedText ? FragmentType.HighlightedText : FragmentType.Text; + return new FragmentInfo(encoded, type); + } + + private static bool TryParseTag(string markup, out TagInfo tagInfo) + { + var match = _tagParser.Match(markup); + + if (match.Success) + { + var isClosing = match.Groups[1].Success; + var tagName = match.Groups[2].Value; + var isSelfClosing = match.Groups[3].Success || _voidElements.Contains(tagName); + + tagInfo = new TagInfo(tagName, isClosing, isSelfClosing); + return true; } + + tagInfo = default; + return false; + } + + private static StringBuilder GetStringBuilder() + { + return Interlocked.Exchange(ref _stringBuilderCached, null) ?? new StringBuilder(); + } + + private static void ReturnStringBuilder(StringBuilder builder) + { + builder.Clear(); + _stringBuilderCached = builder; } + + private static RegexOptions GetRegexOptions(bool caseSensitive) + { + return caseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase; + } + + private static StringComparison GetStringComparison(bool caseSensitive) + { + return caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; + } + + private readonly record struct TagInfo(string Name, bool IsClosing, bool IsSelfClosing); + + [GeneratedRegex(@"(<\s*/?\s*\w+[^>]*?/?>)", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline, "en-US")] + private static partial Regex HtmlTagMatcher(); + + [GeneratedRegex(@"^<\s*(/)?\s*(\w+)[^>]*?(\/)?\s*>$", RegexOptions.IgnoreCase | RegexOptions.Compiled, "en-US")] + private static partial Regex HtmlTagParser(); } diff --git a/src/MudBlazor/Components/Mask/MudMask.razor b/src/MudBlazor/Components/Mask/MudMask.razor index 3faefd64710b..cd580a3503be 100644 --- a/src/MudBlazor/Components/Mask/MudMask.razor +++ b/src/MudBlazor/Components/Mask/MudMask.razor @@ -32,6 +32,7 @@ @onfocus="OnFocused" @oncut="OnCut" @oncopy="OnCopy" + @oninput="OnInputAsync" inputmode="@InputMode.ToDescriptionString()" aria-describedby="@GetAriaDescribedByString()" aria-invalid="@Error.ToString().ToLowerInvariant()" @@ -55,6 +56,7 @@ @onfocus="OnFocused" @oncut="OnCut" @oncopy="OnCopy" + @oninput="OnInputAsync" inputmode="@InputMode.ToDescriptionString()" aria-describedby="@GetAriaDescribedByString()" aria-invalid="@Error.ToString().ToLowerInvariant()" diff --git a/src/MudBlazor/Components/Mask/MudMask.razor.cs b/src/MudBlazor/Components/Mask/MudMask.razor.cs index 447849393f82..435c24e9e0dc 100644 --- a/src/MudBlazor/Components/Mask/MudMask.razor.cs +++ b/src/MudBlazor/Components/Mask/MudMask.razor.cs @@ -195,6 +195,17 @@ await _jsEvent.Connect(_elementId, await base.OnAfterRenderAsync(firstRender); } + protected internal async Task OnInputAsync(ChangeEventArgs e) + { + var inputValue = e.Value?.ToString(); + + if (inputValue == null) + return; + + Mask.SetText(inputValue); + await UpdateAsync(); + } + protected internal async Task HandleKeyDown(KeyboardEventArgs e) { try diff --git a/src/MudBlazor/Components/Progress/MudProgressCircular.razor b/src/MudBlazor/Components/Progress/MudProgressCircular.razor index 82bccd5d499b..de7b068706a0 100644 --- a/src/MudBlazor/Components/Progress/MudProgressCircular.razor +++ b/src/MudBlazor/Components/Progress/MudProgressCircular.razor @@ -12,7 +12,7 @@ @attributes="UserAttributes"> @if (Indeterminate) { -