Blazor base path case sensitivity can be configured

src/Components/Components/src/NavigationManager.cs

@@ -256,15 +256,26 @@ public Uri ToAbsoluteUri(string? relativeUri)
         return new Uri(_baseUri!, relativeUri);
     }
 
+    /// <summary>Holds the active <see cref="StringComparison"/> used for base URI matching.</summary>
+    private StringComparison _pathBaseComparison = StringComparison.Ordinal;
+
+    /// <summary>
+    /// Sets the string comparison used for base URI matching.
+    /// </summary>
+    protected internal StringComparison PathBaseComparison
+    {
+        set => _pathBaseComparison = value;
+    }
+
     /// <summary>
     /// Given a base URI (e.g., one previously returned by <see cref="BaseUri"/>),
     /// converts an absolute URI into one relative to the base URI prefix.
     /// </summary>
     /// <param name="uri">An absolute URI that is within the space of the base URI.</param>
-    /// <returns>A relative URI path.</returns>
+    /// <returns>The portion of <paramref name="uri"/> that follows the <see cref="BaseUri"/> prefix.</returns>
     public string ToBaseRelativePath(string uri)
     {
-        if (uri.StartsWith(_baseUri!.OriginalString, StringComparison.Ordinal))
+        if (uri.StartsWith(_baseUri!.OriginalString, _pathBaseComparison))
         {
             // The absolute URI must be of the form "{baseUri}something" (where
             // baseUri ends with a slash), and from that we return "something"
@@ -273,7 +284,7 @@ public string ToBaseRelativePath(string uri)
 
         var pathEndIndex = uri.AsSpan().IndexOfAny('#', '?');
         var uriPathOnly = pathEndIndex < 0 ? uri : uri.AsSpan(0, pathEndIndex);
-        if (_baseUri.OriginalString.EndsWith('/') && uriPathOnly.Equals(_baseUri.OriginalString.AsSpan(0, _baseUri.OriginalString.Length - 1), StringComparison.Ordinal))
+        if (_baseUri.OriginalString.EndsWith('/') && uriPathOnly.Equals(_baseUri.OriginalString.AsSpan(0, _baseUri.OriginalString.Length - 1), _pathBaseComparison))
         {
             // Special case: for the base URI "/something/", if you're at
             // "/something" then treat it as if you were at "/something/" (i.e.,
@@ -290,7 +301,7 @@ public string ToBaseRelativePath(string uri)
 
     internal ReadOnlySpan<char> ToBaseRelativePath(ReadOnlySpan<char> uri)
     {
-        if (MemoryExtensions.StartsWith(uri, _baseUri!.OriginalString.AsSpan(), StringComparison.Ordinal))
+        if (MemoryExtensions.StartsWith(uri, _baseUri!.OriginalString.AsSpan(), _pathBaseComparison))
         {
             // The absolute URI must be of the form "{baseUri}something" (where
             // baseUri ends with a slash), and from that we return "something"
@@ -299,7 +310,7 @@ internal ReadOnlySpan<char> ToBaseRelativePath(ReadOnlySpan<char> uri)
 
         var pathEndIndex = uri.IndexOfAny('#', '?');
         var uriPathOnly = pathEndIndex < 0 ? uri : uri[..pathEndIndex];
-        if (_baseUri.OriginalString.EndsWith('/') && MemoryExtensions.Equals(uriPathOnly, _baseUri.OriginalString.AsSpan(0, _baseUri.OriginalString.Length - 1), StringComparison.Ordinal))
+        if (_baseUri.OriginalString.EndsWith('/') && MemoryExtensions.Equals(uriPathOnly, _baseUri.OriginalString.AsSpan(0, _baseUri.OriginalString.Length - 1), _pathBaseComparison))
         {
             // Special case: for the base URI "/something/", if you're at
             // "/something" then treat it as if you were at "/something/" (i.e.,
@@ -553,9 +564,9 @@ private void AssertInitialized()
         }
     }
 
-    private static bool TryGetLengthOfBaseUriPrefix(Uri baseUri, string uri, out int length)
+    private bool TryGetLengthOfBaseUriPrefix(Uri baseUri, string uri, out int length)
     {
-        if (uri.StartsWith(baseUri.OriginalString, StringComparison.Ordinal))
+        if (uri.StartsWith(baseUri.OriginalString, _pathBaseComparison))
         {
             // The absolute URI must be of the form "{baseUri}something" (where
             // baseUri ends with a slash), and from that we return "something"
@@ -565,7 +576,7 @@ private static bool TryGetLengthOfBaseUriPrefix(Uri baseUri, string uri, out int
 
         var pathEndIndex = uri.AsSpan().IndexOfAny('#', '?');
         var uriPathOnly = pathEndIndex < 0 ? uri : uri.AsSpan(0, pathEndIndex);
-        if (baseUri.OriginalString.EndsWith('/') && uriPathOnly.Equals(baseUri.OriginalString.AsSpan(0, baseUri.OriginalString.Length - 1), StringComparison.Ordinal))
+        if (baseUri.OriginalString.EndsWith('/') && uriPathOnly.Equals(baseUri.OriginalString.AsSpan(0, baseUri.OriginalString.Length - 1), _pathBaseComparison))
         {
             // Special case: for the base URI "/something/", if you're at
             // "/something" then treat it as if you were at "/something/" (i.e.,
@@ -581,7 +592,7 @@ private static bool TryGetLengthOfBaseUriPrefix(Uri baseUri, string uri, out int
         return false;
     }
 
-    private static void Validate(Uri? baseUri, string uri)
+    private void Validate(Uri? baseUri, string uri)
     {
         if (baseUri == null || uri == null)
         {

src/Components/Components/src/NavigationManagerOptions.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components;
+
+/// <summary>
+/// Provides configuration for <see cref="NavigationManager"/> behavior.
+/// </summary>
+public class NavigationManagerOptions
+{
+    /// <summary>
+    /// Gets or sets the string comparison used when comparing URIs against the base URI.
+    /// The default is <see cref="System.StringComparison.Ordinal"/> for backward compatibility.
+    /// Set to <see cref="System.StringComparison.OrdinalIgnoreCase"/> to enable case-insensitive matching.
+    /// </summary>
+    public StringComparison PathBaseComparison { get; set; } = StringComparison.Ordinal;
+}

src/Components/Components/src/PublicAPI.Unshipped.txt

@@ -1 +1,6 @@
 #nullable enable
+Microsoft.AspNetCore.Components.NavigationManagerOptions
+Microsoft.AspNetCore.Components.NavigationManagerOptions.NavigationManagerOptions() -> void
+Microsoft.AspNetCore.Components.NavigationManagerOptions.PathBaseComparison.get -> System.StringComparison
+Microsoft.AspNetCore.Components.NavigationManagerOptions.PathBaseComparison.set -> void
+Microsoft.AspNetCore.Components.NavigationManager.PathBaseComparison.set -> void

src/Components/Components/test/NavigationManagerTest.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Buffers;
 using System.Diagnostics;
 using System.Net.Http;
@@ -84,6 +85,21 @@ public void ToBaseRelativePath_ThrowsForInvalidBaseRelativePaths(string baseUri,
             ex.Message);
     }
 
+    [Fact]
+    public void ToBaseRelativePath_HonorsConfiguredPathBaseComparison()
+    {
+        var navigationManager = new TestNavigationManager("https://example.com/dashboard/", "https://example.com/dashboard/");
+
+        var ex = Assert.Throws<ArgumentException>(() => navigationManager.ToBaseRelativePath("https://example.com/DaShBoArD"));
+        Assert.Equal("The URI 'https://example.com/DaShBoArD' is not contained by the base URI 'https://example.com/dashboard/'.", ex.Message);
+
+        navigationManager.SetPathBaseComparison(StringComparison.OrdinalIgnoreCase);
+
+        var result = navigationManager.ToBaseRelativePath("https://example.com/DaShBoArD");
+
+        Assert.Equal(string.Empty, result);
+    }
+
     [Theory]
     [InlineData("scheme://host/?full%20name=Bob%20Joe&age=42", "scheme://host/?full%20name=John%20Doe&age=42")]
     [InlineData("scheme://host/?fUlL%20nAmE=Bob%20Joe&AgE=42", "scheme://host/?full%20name=John%20Doe&AgE=42")]
@@ -906,6 +922,11 @@ public TestNavigationManager(string baseUri = null, string uri = null)
         public async Task<bool> RunNotifyLocationChangingAsync(string uri, string state, bool isNavigationIntercepted)
             => await NotifyLocationChangingAsync(uri, state, isNavigationIntercepted);
 
+        public void SetPathBaseComparison(StringComparison comparison)
+        {
+            PathBaseComparison = comparison;
+        }
+
         protected override void NavigateToCore(string uri, bool forceLoad)
         {
             throw new System.NotImplementedException();

src/Components/Endpoints/src/DependencyInjection/HttpNavigationManager.cs

@@ -1,13 +1,19 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.AspNetCore.Components.Routing;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.AspNetCore.Components.Routing;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.AspNetCore.Components.Endpoints;
 
 internal sealed class HttpNavigationManager : NavigationManager, IHostEnvironmentNavigationManager
 {
+    public HttpNavigationManager(IOptions<NavigationManagerOptions> options)
+    {
+        PathBaseComparison = options.Value.PathBaseComparison;
+    }
+
     private const string _disableThrowNavigationException = "Microsoft.AspNetCore.Components.Endpoints.NavigationManager.DisableThrowNavigationException";
 
     [FeatureSwitchDefinition(_disableThrowNavigationException)]

src/Components/Endpoints/src/DependencyInjection/RazorComponentsServiceCollectionExtensions.cs

@@ -40,6 +40,7 @@ public static IRazorComponentsBuilder AddRazorComponents(this IServiceCollection
         // Dependencies
         services.AddLogging();
         services.AddAntiforgery();
+        services.AddOptions<NavigationManagerOptions>();
 
         services.TryAddSingleton<RazorComponentsMarkerService>();
 

src/Components/Server/src/Circuits/RemoteNavigationManager.cs

@@ -4,6 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Microsoft.JSInterop;
 using Interop = Microsoft.AspNetCore.Components.Web.BrowserNavigationManagerInterop;
 
@@ -30,9 +31,11 @@ internal sealed partial class RemoteNavigationManager : NavigationManager, IHost
     /// Creates a new <see cref="RemoteNavigationManager"/> instance.
     /// </summary>
     /// <param name="logger">The <see cref="ILogger{TCategoryName}"/>.</param>
-    public RemoteNavigationManager(ILogger<RemoteNavigationManager> logger)
+    /// <param name="options">The configured <see cref="NavigationManagerOptions"/>.</param>
+    public RemoteNavigationManager(ILogger<RemoteNavigationManager> logger, IOptions<NavigationManagerOptions> options)
     {
         _logger = logger;
+        PathBaseComparison = options.Value.PathBaseComparison;
     }
 
     /// <summary>

src/Components/Server/src/DependencyInjection/ComponentServiceCollectionExtensions.cs

@@ -38,6 +38,7 @@ public static IServerSideBlazorBuilder AddServerSideBlazor(this IServiceCollecti
         var builder = new DefaultServerSideBlazorBuilder(services);
 
         services.AddDataProtection();
+        services.AddOptions<NavigationManagerOptions>();
 
         services.TryAddScoped<ProtectedLocalStorage>();
         services.TryAddScoped<ProtectedSessionStorage>();

src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyHost.cs

@@ -11,6 +11,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 
@@ -53,6 +54,12 @@ internal WebAssemblyHost(
         _configuration = builder.Configuration;
         _rootComponents = builder.RootComponents;
         _persistedState = persistedState;
+
+        var navigationManagerOptions = services.GetService<IOptions<NavigationManagerOptions>>();
+        if (navigationManagerOptions is not null)
+        {
+            WebAssemblyNavigationManager.Instance.ApplyOptions(navigationManagerOptions.Value);
+        }
     }
 
     /// <summary>

src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyHostBuilder.cs

@@ -318,6 +318,7 @@ public WebAssemblyHost Build()
     internal void InitializeDefaultServices()
     {
         Services.AddSingleton<IJSRuntime>(DefaultWebAssemblyJSRuntime.Instance);
+        Services.AddOptions<NavigationManagerOptions>();
         Services.AddSingleton<NavigationManager>(WebAssemblyNavigationManager.Instance);
         Services.AddSingleton<INavigationInterception>(WebAssemblyNavigationInterception.Instance);
         Services.AddSingleton<IScrollToLocationHash>(WebAssemblyScrollToLocationHash.Instance);

src/Components/WebAssembly/WebAssembly/src/Services/WebAssemblyNavigationManager.cs

@@ -26,6 +26,11 @@ public WebAssemblyNavigationManager(string baseUri, string uri)
         Initialize(baseUri, uri);
     }
 
+    public void ApplyOptions(NavigationManagerOptions options)
+    {
+        PathBaseComparison = options.PathBaseComparison;
+    }
+
     public void CreateLogger(ILoggerFactory loggerFactory)
     {
         if (_logger is not null)

src/Components/WebAssembly/testassets/HostedInAspNet.Server/Startup.cs

@@ -3,6 +3,9 @@
 
 namespace HostedInAspNet.Server;
 
+using System;
+using Microsoft.AspNetCore.Components;
+
 public class Startup
 {
     public Startup(IConfiguration configuration)
@@ -16,6 +19,14 @@ public Startup(IConfiguration configuration)
     // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
     public void ConfigureServices(IServiceCollection services)
     {
+        var mapAlternativePathApp = Configuration.GetValue<bool>("UseAlternativeBasePath");
+        if (mapAlternativePathApp)
+        {
+            services.Configure<NavigationManagerOptions>(options =>
+            {
+                options.PathBaseComparison = StringComparison.OrdinalIgnoreCase;
+            });
+        }
         services.AddSingleton<BootResourceRequestLog>();
     }
 

src/Components/test/E2ETest/Tests/HostedInAlternativeBasePathTest.cs

@@ -5,6 +5,7 @@
 using Microsoft.AspNetCore.Components.E2ETest.Infrastructure.ServerFixtures;
 using Microsoft.AspNetCore.E2ETesting;
 using OpenQA.Selenium;
+using Xunit;
 using Xunit.Abstractions;
 
 namespace Microsoft.AspNetCore.Components.E2ETest.Tests;
@@ -22,15 +23,14 @@ public HostedInAlternativeBasePathTest(
         serverFixture.Environment = AspNetEnvironment.Development;
     }
 
-    protected override void InitializeAsyncCore()
+    [Theory]
+    [InlineData("/app/")]
+    [InlineData("/APP/")]
+    public void CanLoadBlazorAppFromSubPath(string path)
     {
-        Navigate("/app/");
+        Navigate(path);
         WaitUntilLoaded();
-    }
 
-    [Fact]
-    public void CanLoadBlazorAppFromSubPath()
-    {
         Assert.Equal("App loaded on custom path", Browser.Title);
         Assert.Empty(Browser.GetBrowserLogs(LogLevel.Severe));
     }