Refactor application structure and add unit tests

Added:
- New `ProgressService` class for managing progress indicators.
- New `AssetDatabase`, `AssetOpenHandlerAttribute`, and `AsyncAssetOpenHandlerAttribute` classes for asset handling.
- `Ghost.UnitTest` project for unit testing with associated files and configurations.

Changed:
- `ActivationHandler` class to ensure correct handling of `LaunchActivatedEventArgs`.
- `App.xaml.cs` to register `INotificationService` and `IProgressService`, replacing `StackedNotificationService`.
- `OnLaunched` method in `App.xaml.cs` to correctly call `ActivationHandler.Handle(args)` and start the host.
- `INavigationAware` interface from internal to public for broader access.
- `EditorState.cs` to activate `EditorApplication` with the current service provider.
- Property names in `AssetItem` and `ExplorerItem` structs to `Name` and `FullName`.
- `NotificationService` class to implement `INotificationService` and refactor notification handling.
- `AssetPathToGlyphConverter` to handle file extensions consistently.
- Bindings in `ProjectPage.xaml` and `ProjectPage.xaml.cs` to use `FullName` instead of `Path`.
- `EngineEditorWindow` and `LandingWindow` classes to utilize new notification and progress services.
- `Logger` class to include a new method for logging errors with exceptions.

Updated:
- Manifest files and project files to reflect new structure and dependencies.
- Solution file `GhostEngine.sln` to include the new unit test project.
- Added several new test classes and methods in `UnitTests.cs`.

Ghost.App/ViewModels/Pages/Landing/CreateProjectViewModel.cs

@@ -0,0 +1,95 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Ghost.App.Contracts;
+using Ghost.App.Infrastructures.AppState;
+using Ghost.App.Services;
+using Ghost.App.Utilities;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.Models;
+using Ghost.Engine.Resources;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Ghost.Editor.ViewModels.Pages.Landing;
+
+internal partial class CreateProjectViewModel(NotificationService notificationService, ProjectService projectService, AppStateMachine stateService) : ObservableObject, INavigationAware
+{
+    public ObservableCollection<TemplateData> templates = new();
+
+    [ObservableProperty]
+    public partial TemplateData? SelectedTemplate
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial string? ProjectName
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial string? ProjectLocation
+    {
+        get;
+        set;
+    }
+
+    public async void OnNavigatedTo(object? parameter)
+    {
+        templates.Clear();
+        await foreach (var (path, info) in ProjectService.GetProjectTemplatesAsync())
+        {
+            templates.Add(new(path, info));
+        }
+
+        SelectedTemplate = templates.FirstOrDefault();
+    }
+
+    public void OnNavigatedFrom()
+    {
+    }
+
+    [RelayCommand]
+    private async Task SelectionProjectLocation()
+    {
+        var folder = await SystemUtilities.OpenFolderPickerAsync();
+        if (folder != null)
+        {
+            ProjectLocation = folder.Path;
+        }
+    }
+
+    [RelayCommand]
+    private async Task CreateProject()
+    {
+        if (string.IsNullOrWhiteSpace(ProjectName)
+            || !Directory.Exists(ProjectLocation)
+            || !SelectedTemplate.HasValue)
+        {
+            notificationService.ShowNotification("Incorrect project info", MessageType.Error);
+            return;
+        }
+
+        var result = await projectService.CreateProjectAsync(ProjectName, ProjectLocation, EngineData.s_engineVersion, SelectedTemplate.Value.directory);
+        if (!result.success)
+        {
+            notificationService.ShowNotification(result.message, MessageType.Error);
+            return;
+        }
+
+        try
+        {
+            await stateService.TransitionToAsync(StateKey.EngineEditor, result.data);
+        }
+        catch (System.Exception e)
+        {
+            notificationService.ShowNotification($"Failed to load project: {e.Message}", MessageType.Error);
+        }
+    }
+}

Ghost.App/ViewModels/Pages/Landing/OpenProjectViewModel.cs

@@ -0,0 +1,110 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.App.Contracts;
+using Ghost.App.Infrastructures.AppState;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.Models;
+using Ghost.Editor.Services.Contracts;
+using Microsoft.UI.Xaml;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Storage;
+
+namespace Ghost.Editor.ViewModels.Pages.Landing;
+
+internal partial class OpenProjectViewModel(ProjectService projectService, INotificationService _notificationService, AppStateMachine _stateService) : ObservableObject, INavigationAware
+{
+    public readonly ObservableCollection<ProjectMetadataInfo> projects = new();
+
+    [ObservableProperty]
+    public partial Visibility EmptyVisibility
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial Visibility DragVisibility
+    {
+        get;
+        set;
+    }
+
+    public void UpdateEmptyPlaceHolderVisibility()
+    {
+        EmptyVisibility = projects.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public async void OnNavigatedTo(object? parameter)
+    {
+        projects.Clear();
+        await foreach (var projectInfo in projectService.GetAllProjectAsync())
+        {
+            var metadata = await ProjectService.LoadMetadataAsync(projectInfo.MetadataPath);
+            if (metadata == null)
+            {
+                continue;
+            }
+
+            projects.Add(new(projectInfo.MetadataPath, metadata));
+        }
+
+        UpdateEmptyPlaceHolderVisibility();
+        DragVisibility = Visibility.Collapsed;
+    }
+
+    public void OnNavigatedFrom()
+    {
+    }
+
+    public async Task ContentDrop(DataPackageView dataView)
+    {
+        var errorMessage = string.Empty;
+        if (dataView.Contains(StandardDataFormats.StorageItems))
+        {
+            var items = await dataView.GetStorageItemsAsync();
+            var rootFolder = items.OfType<StorageFolder>().FirstOrDefault();
+            if (rootFolder != null)
+            {
+                var result = await projectService.AddProjectFromDirectoryAsync(rootFolder.Path);
+                if (result.success)
+                {
+                    projects.Add(result.data);
+                    goto CloseDropPanel;
+                }
+                else
+                {
+                    errorMessage = result.message;
+                }
+            }
+        }
+        else
+        {
+            errorMessage = "Unsupported data format. Please drop a folder containing a project.";
+        }
+
+        _notificationService.ShowNotification(errorMessage, MessageType.Error);
+
+    CloseDropPanel:
+        DragVisibility = Visibility.Collapsed;
+        UpdateEmptyPlaceHolderVisibility();
+    }
+
+    public async Task LoadProject(ProjectMetadataInfo project)
+    {
+        try
+        {
+            project.Metadata.LastOpened = DateTime.Now;
+            await ProjectService.CreateMetadataFileAsync(project.Path, project.Metadata);
+
+            await _stateService.TransitionToAsync(StateKey.EngineEditor, project);
+        }
+        catch (Exception e)
+        {
+            _notificationService.ShowNotification($"Failed to load project: {e.Message}", MessageType.Error);
+        }
+    }
+}