Refactor: Streamline Utlity Classes

src/InfiniFrame.BlazorWebView/InfiniFrameBlazorApp.cs

@@ -1,6 +1,7 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
+using InfiniFrame.Utilities;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
@@ -62,9 +63,6 @@ public void Run() {
         }
     }
 
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
-
     public async ValueTask DisposeAsync() {
         if (_disposed) return;
 
@@ -87,7 +85,7 @@ public async ValueTask DisposeAsync() {
                     break;
             }
         }
-        catch (Exception e) when (IsNonFatalException(e)) {
+        catch (Exception e) when (ExceptionsUtility.IsNonFatalException(e)) {
             logger?.LogError(e, "Error disposing of InfiniFrameBlazorApp");
         }
 

src/InfiniFrame.BlazorWebView/InfiniFrameSynchronizationContext.cs

@@ -5,6 +5,7 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 using InfiniFrame.BlazorWebView.Utils;
+using InfiniFrame.Utilities;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace InfiniFrame.BlazorWebView;
@@ -45,7 +46,7 @@ public Task InvokeAsync(Action action) {
             catch (OperationCanceledException) {
                 completion.SetCanceled();
             }
-            catch (Exception exception) when (IsNonFatalException(exception)) {
+            catch (Exception exception) when (ExceptionsUtility.IsNonFatalException(exception)) {
                 completion.SetException(exception);
             }
         }, completion);
@@ -66,7 +67,7 @@ public Task InvokeAsync(Func<Task> asyncAction) {
             catch (OperationCanceledException) {
                 completion.SetCanceled();
             }
-            catch (Exception exception) when (IsNonFatalException(exception)) {
+            catch (Exception exception) when (ExceptionsUtility.IsNonFatalException(exception)) {
                 completion.SetException(exception);
             }
         }, completion);
@@ -86,7 +87,7 @@ public Task<TResult> InvokeAsync<TResult>(Func<TResult> function) {
             catch (OperationCanceledException) {
                 completion.SetCanceled();
             }
-            catch (Exception exception) when (IsNonFatalException(exception)) {
+            catch (Exception exception) when (ExceptionsUtility.IsNonFatalException(exception)) {
                 completion.SetException(exception);
             }
         }, completion);
@@ -107,7 +108,7 @@ public Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> asyncFunction) {
             catch (OperationCanceledException) {
                 completion.SetCanceled();
             }
-            catch (Exception exception) when (IsNonFatalException(exception)) {
+            catch (Exception exception) when (ExceptionsUtility.IsNonFatalException(exception)) {
                 completion.SetException(exception);
             }
         }, completion);
@@ -232,7 +233,7 @@ private void ExecuteBackground(InfiniFrameSynchronizationWorkItem item) {
             try {
                 ExecuteSynchronously(null, item.Callback, item.StateObject);
             }
-            catch (Exception ex) when (IsNonFatalException(ex)) {
+            catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
                 DispatchException(ex);
             }
 
@@ -243,7 +244,7 @@ private void ExecuteBackground(InfiniFrameSynchronizationWorkItem item) {
         try {
             ExecutionContext.Run(item.ExecutionContext, ExecutionContextThunk, item);
         }
-        catch (Exception ex) when (IsNonFatalException(ex)) {
+        catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
             DispatchException(ex);
         }
     }
@@ -252,7 +253,4 @@ private void DispatchException(Exception ex) {
         UnhandledExceptionEventHandler? handler = UnhandledException;
         handler?.Invoke(this, new UnhandledExceptionEventArgs(ex, false));
     }
-
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
 }

src/InfiniFrame.BlazorWebView/InfiniFrameWebViewManager.cs

@@ -2,6 +2,7 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 using InfiniFrame.BlazorWebView.Utils;
+using InfiniFrame.Utilities;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.WebView;
@@ -224,7 +225,7 @@ private async Task MessagePump() {
         catch (OperationCanceledException) {
             LazyLogger.Value?.LogDebug("WebView message pump cancellation requested.");
         }
-        catch (Exception ex) when (IsNonFatalException(ex)) {
+        catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
             LazyLogger.Value?.LogError(ex, "Unhandled exception in WebView message pump.");
             throw;
         }
@@ -250,9 +251,6 @@ protected override async ValueTask DisposeAsyncCore() {
         }
     }
 
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
-
     private static string GetFallbackContentType(string localPath) {
         string extension = Path.GetExtension(localPath);
 

src/InfiniFrame.Js/Interop/RegisterWindowCreatedUtility.cs

@@ -1,6 +1,7 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
+using InfiniFrame.Utilities;
 using Microsoft.Extensions.Logging;
 using System.Runtime.CompilerServices;
 
@@ -76,7 +77,7 @@ IReadOnlyList<string> registrationMessages
         try {
             allMessagesSent = await SendRegistrationsAndAckAsync(window, registrationMessages);
         }
-        catch (Exception ex) when (IsNonFatalException(ex)) {
+        catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
             window.Logger.LogError(ex, "Unhandled error while sending window-created registration messages.");
         }
         finally {
@@ -96,7 +97,4 @@ private static async Task<bool> SendRegistrationsAndAckAsync(IInfiniFrameWindow
         window.Logger.LogDebug("Sent '{ReadyAckMessageId}' handshake acknowledgement.", HandlerNames.WindowReadyAck);
         return true;
     }
-
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
 }

src/InfiniFrame.Shared/FluentApi/InfiniWindowBuilderExtensions.cs

@@ -124,7 +124,7 @@ public static T GrantBrowserPermissions<T>(this T builder, bool enable = true) w
     ///     The file path to the icon.
     /// </value>
     public static T SetIconFile<T>(this T builder, string? iconFilePath) where T : IInfiniFrameWindowBuilder {
-        if (!IconFileUtilities.TryResolveIconFilePath(iconFilePath, out string? resolvedIconFilePath)) return builder;
+        if (!IconFileUtility.TryResolveIconFilePath(iconFilePath, out string? resolvedIconFilePath)) return builder;
 
         builder.Configuration.IconFilePath = resolvedIconFilePath;
         return builder;

src/InfiniFrame.Shared/FluentApi/InfiniWindowExtensions.cs

@@ -427,7 +427,7 @@ public static T SetHeight<T>(this T window, int height) where T : class, IInfini
     public static T SetIconFile<T>(this T window, string iconFilePath) where T : class, IInfiniFrameWindow {
         window.Logger.LogDebug(".SetIconFile({IconFile})", iconFilePath);
 
-        if (!IconFileUtilities.TryResolveIconFilePath(iconFilePath, out string? resolvedIconFilePath)) {
+        if (!IconFileUtility.TryResolveIconFilePath(iconFilePath, out string? resolvedIconFilePath)) {
             window.Logger.LogWarning("Icon file {IconFile} does not exist or is an invalid file path.", iconFilePath);
             return window;
         }

src/InfiniFrame.Shared/InfiniFrame.Shared.csproj

@@ -42,6 +42,7 @@
         <InternalsVisibleTo Include="InfiniFrame"/>
         <InternalsVisibleTo Include="InfiniFrame.WebServer"/>
         <InternalsVisibleTo Include="InfiniFrame.Blazor"/>
+        <InternalsVisibleTo Include="InfiniFrame.BlazorWebView"/>
         <InternalsVisibleTo Include="InfiniFrameTests"/>
         <InternalsVisibleTo Include="InfiniFrameTests.Playwright"/>
         <InternalsVisibleTo Include="InfiniFrameTests.Shared"/>

src/InfiniFrame.Shared/Utilities/InfiniFrameNativeParametersValidator.cs → src/InfiniFrame.Shared/Native/InfiniFrameNativeParametersValidator.cs

@@ -1,11 +1,11 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
-using InfiniFrame.Native;
+using InfiniFrame.Utilities;
 using Microsoft.Extensions.Logging;
 using System.Runtime.InteropServices;
 
-namespace InfiniFrame.Utilities;
+namespace InfiniFrame.Native;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
@@ -34,7 +34,7 @@ public static bool Validate(InfiniFrameNativeParameters parameters, ILogger logg
         }
 
         if (!string.IsNullOrWhiteSpace(windowIconFile) &&
-            !IconFileUtilities.TryResolveIconFilePath(windowIconFile, out _)) {
+            !IconFileUtility.TryResolveIconFilePath(windowIconFile, out _)) {
             logger.LogError("WindowIconFile: {WindowIconFile} cannot be found", windowIconFile);
             result = false;
         }

src/InfiniFrame.Shared/Utilities/ExceptionsUtility.cs

@@ -0,0 +1,12 @@
+// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+namespace InfiniFrame.Utilities;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+internal static class ExceptionsUtility {
+    public static bool IsNonFatalException(Exception exception)
+        => exception is not (OutOfMemoryException or AccessViolationException);
+}

src/InfiniFrame.Shared/Utilities/IconFileUtilities.cs → src/InfiniFrame.Shared/Utilities/IconFileUtility.cs

@@ -7,7 +7,7 @@ namespace InfiniFrame.Utilities;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public static class IconFileUtilities {
+internal static class IconFileUtility {
     public static bool TryResolveIconFilePath(
         string? filePath,
         [NotNullWhen(true)] out string? resolvedFilePath,

src/InfiniFrame.Shared/Utilities/InvokeUtilities.cs → src/InfiniFrame.Shared/Utilities/InvokeUtility.cs

@@ -16,7 +16,7 @@ namespace InfiniFrame.Utilities;
 ///         a synchronization primitive (e.g. <see cref="System.Threading.ManualResetEventSlim" />).
 ///     </para>
 /// </summary>
-internal static class InvokeUtilities {
+internal static class InvokeUtility {
     public static T? InvokeAndReturn<T>(IInfiniFrameWindow window, Func<IInfiniFrameWindow, T> callback) {
         T? value = default;
         // ReSharper disable once RedundantAssignment

src/InfiniFrame.Tools.Pack/Exceptions/ExceptionsUtility.cs

@@ -0,0 +1,12 @@
+// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+namespace InfiniFrame.Tools.Pack.Exceptions;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+internal static class ExceptionsUtility {
+    public static bool IsNonFatalException(Exception exception)
+        => exception is not (OutOfMemoryException or AccessViolationException);
+}

src/InfiniFrame.Tools.Pack/Program.cs

@@ -42,15 +42,12 @@ public static async Task<int> Main(string[] args) {
             Log.Error(ex, "ERROR: {Message}", ex.Message);
             return ExitCodes.NativeDependencyMissing;
         }
-        catch (Exception ex) when (IsNonFatalException(ex)) {
+        catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
             Log.Error(ex, "ERROR: {Message}", ex.Message);
             return ExitCodes.GenericFailure;
         }
         finally {
             await Log.CloseAndFlushAsync();
         }
     }
-
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
 }

src/InfiniFrame.WebServer/InfiniFrameWebApplication.cs

@@ -1,6 +1,8 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
+using InfiniFrame.Utilities;
+
 namespace InfiniFrame.WebServer;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
@@ -89,7 +91,7 @@ private async Task StopWebAppAsync(CancellationToken ct = default) {
         try {
             await WebApp.StopAsync(ct);
         }
-        catch (Exception e) when (IsNonFatalException(e)) {
+        catch (Exception e) when (ExceptionsUtility.IsNonFatalException(e)) {
             Window.Logger.LogError(e, "Error stopping web app");
         }
     }
@@ -102,7 +104,4 @@ private static async Task ObserveHostRunCompletionAsync(Task runTask) {
             // Host shutdown cancellation is expected.
         }
     }
-
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
 }

src/InfiniFrame/Configuration/InfiniFrameOptionsBuilder.cs

@@ -67,7 +67,7 @@ public string? Title {
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
     public InfiniFrameNativeParameters ToNativeParameters() {
-        IconFileUtilities.TryResolveIconFilePath(IconFilePath, out string? resolvedIconFilePath);
+        IconFileUtility.TryResolveIconFilePath(IconFilePath, out string? resolvedIconFilePath);
 
         if (CustomSchemeNames.Count > CustomSchemeNameMemory.MaxCustomSchemeNames)
             throw new InvalidOperationException("Maximum number of custom schemes is 16.");

src/InfiniFrame/Events/InfiniFrameEvents.Messaging.cs

@@ -4,6 +4,7 @@
 using InfiniFrame.Interop;
 using InfiniFrame.Js;
 using InfiniFrame.Js.Interop;
+using InfiniFrame.Utilities;
 using Microsoft.Extensions.Logging;
 using System.Text.Json;
 
@@ -75,7 +76,7 @@ public void OnWebMessageReceived(string message, string? origin = null) {
                         );
                     }
                 }
-                catch (Exception ex) when (IsNonFatalException(ex)) {
+                catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
                     Sender.Logger.LogError(
                         ex,
                         "Unhandled exception while processing postMessage '{MessageId}'",
@@ -95,7 +96,7 @@ public void OnWebMessageReceived(string message, string? origin = null) {
 
                     SendSuccess(Sender, parseResult.RequestId, response);
                 }
-                catch (Exception ex) when (IsNonFatalException(ex)) {
+                catch (Exception ex) when (ExceptionsUtility.IsNonFatalException(ex)) {
                     Sender.Logger.LogError(
                         ex,
                         "Unhandled exception while processing getMessage '{MessageId}'",
@@ -122,9 +123,6 @@ public void OnWebMessageReceived(string message, string? origin = null) {
     // Helpers
     // ---------------------------------------------------------------------------------------------------------------------
 
-    private static bool IsNonFatalException(Exception exception)
-        => exception is not (OutOfMemoryException or AccessViolationException);
-
     private static void SendSuccess(IInfiniFrameWindow window, string? requestId, string? data) {
         string responsePayloadJson = JsonSerializer.Serialize(
             new InteropGetMessageSuccessResponse {