Wrap FluentAvalonia controls within same named classes allowing us to declare the xmlns namespace in our assembly

Framework/Foundation/Configurations/ConfigurationChanged.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Foundation;
+
+public record ConfigurationChanged<TConfiguration>(TConfiguration Configuration) where TConfiguration : class;

Framework/Foundation/Configurations/ConfigurationInitializer.cs

@@ -0,0 +1,22 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public class ConfigurationInitializer<TConfiguration> : IInitializable where TConfiguration : class, new()
+{
+    private readonly TConfiguration configuration;
+    private readonly IMediator mediator;
+
+    public ConfigurationInitializer(TConfiguration configuration,
+        IMediator mediator)
+    {
+        this.configuration = configuration;
+        this.mediator = mediator;
+    }
+
+    public async Task InitializeAsync()
+    {
+        await mediator.Send(configuration);
+        await Task.CompletedTask;
+    }
+}

Framework/Foundation/Configurations/ConfigurationWriter.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation;
+
+public class ConfigurationWriter<TConfiguration> : IConfigurationWriter<TConfiguration> where TConfiguration : class, new()
+{
+    private readonly IConfiguration rootConfiguration;
+
+    public ConfigurationWriter(IConfiguration rootConfiguration)
+    {
+        this.rootConfiguration = rootConfiguration;
+    }
+
+    public void Write(string section, TConfiguration configuration)
+    {
+        if (rootConfiguration is IConfigurationRoot root)
+        {
+            foreach (IConfigurationProvider? provider in root.Providers)
+            {
+                if (provider is IWritableConfigurationProvider writableConfigurationProvider)
+                {
+                    writableConfigurationProvider.Write(section, configuration);
+                }
+            }
+        }
+    }
+}

Framework/Foundation/Configurations/IConfigurationWriter.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IConfigurationWriter<TConfiguration> where TConfiguration : class
+{
+    void Write(string section, TConfiguration args);
+}

Framework/Foundation/Configurations/IWritableConfigurationProvider.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IWritableConfigurationProvider
+{
+    void Write<TValue>(string section, TValue value) where TValue : class, new();
+}

Framework/Foundation/Configurations/IWritableJsonConfigurationBuilder.cs

@@ -0,0 +1,12 @@
+namespace Toolkit.Foundation;
+
+public interface IWritableJsonConfigurationBuilder
+{
+    Stream? DefaultFileStream { get; }
+
+    IWritableJsonConfigurationBuilder AddDefaultConfiguration<TConfiguration>(string Key) where TConfiguration : class;
+
+    IWritableJsonConfigurationBuilder AddDefaultFileStream(Stream stream);
+
+    void Build(string path);
+}

Framework/Foundation/Configurations/IWritableJsonConfigurationDescriptor.cs

@@ -0,0 +1,8 @@
+namespace Toolkit.Foundation;
+
+public interface IWritableJsonConfigurationDescriptor
+{
+    Type ConfigurationType { get; }
+
+    string Key { get; }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationBuilder.cs

@@ -0,0 +1,108 @@
+using Json.Patch;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+namespace Toolkit.Foundation;
+
+public class WritableJsonConfigurationBuilder : IWritableJsonConfigurationBuilder
+{
+    private readonly List<IWritableJsonConfigurationDescriptor> descriptors = new();
+
+    public Stream? DefaultFileStream { get; private set; }
+
+    public IReadOnlyCollection<IWritableJsonConfigurationDescriptor> Descriptors => new ReadOnlyCollection<IWritableJsonConfigurationDescriptor>(descriptors);
+
+    public IWritableJsonConfigurationBuilder AddDefaultConfiguration<TConfiguration>(string Key) where TConfiguration : class
+    {
+        descriptors.Add(new WritableJsonConfigurationDescriptor(typeof(TConfiguration), Key));
+        return this;
+    }
+
+    public IWritableJsonConfigurationBuilder AddDefaultFileStream(Stream stream)
+    {
+        DefaultFileStream = stream;
+        return this;
+    }
+
+    public void Build(string path)
+    {
+        JObject? sourceDocument = new();
+        if (TryLoadSource(out string? defaultContent))
+        {
+            sourceDocument = JObject.Parse(defaultContent!);
+        }
+
+        JObject? targetDocument = new();
+        if (TryLoadTarget(path, out string? targetContent))
+        {
+            targetDocument = JObject.Parse(targetContent!);
+        }
+
+        foreach (IWritableJsonConfigurationDescriptor? descriptor in descriptors)
+        {
+            if (sourceDocument.SelectToken($"$.{descriptor.Key}") is JToken sourceSection)
+            {
+                if (targetDocument.SelectToken($"$.{descriptor.Key}") is JToken targetSection)
+                {
+                    object? source = JsonSerializer.Deserialize(JsonConvert.SerializeObject(sourceSection), descriptor.ConfigurationType);
+                    object? target = JsonSerializer.Deserialize(JsonConvert.SerializeObject(targetSection), descriptor.ConfigurationType);
+
+                    JsonPatch? patch = source.CreatePatch(target);
+
+                    object? sourcePatched = patch.Apply(source);
+                    targetSection.Replace(JToken.Parse(JsonSerializer.Serialize(sourcePatched, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull })));
+                }
+                else
+                {
+                    object? source = JsonSerializer.Deserialize(JsonConvert.SerializeObject(sourceSection), descriptor.ConfigurationType);
+                    targetDocument.Add(descriptor.Key, JToken.Parse(JsonSerializer.Serialize(source, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull })));
+                }
+            }
+            else
+            {
+                object? configuration = Activator.CreateInstance(descriptor.ConfigurationType);
+                targetDocument.Add(descriptor.Key, JToken.Parse(JsonSerializer.Serialize(configuration, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull })));
+            }
+        }
+
+        using FileStream? fileStream = new(path, FileMode.Create, FileAccess.Write);
+        using StreamWriter streamWriter = new(fileStream);
+        using JsonTextWriter writer = new(streamWriter) { Formatting = Formatting.Indented };
+        targetDocument.WriteTo(writer);
+    }
+
+    private bool TryLoadTarget(string path, [MaybeNull] out string? content)
+    {
+        if (File.Exists(path))
+        {
+            using FileStream? fileStream = new(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using StreamReader? streamReader = new(fileStream);
+            content = streamReader.ReadToEnd();
+            return true;
+        }
+
+        content = null;
+        return false;
+    }
+
+    private bool TryLoadSource([MaybeNull] out string? content)
+    {
+        if (DefaultFileStream is Stream fileStream)
+        {
+            using StreamReader? streamReader = new(fileStream);
+            content = streamReader.ReadToEnd();
+            return true;
+        }
+
+        content = null;
+        return false;
+    }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationDescriptor.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Foundation;
+
+public record WritableJsonConfigurationDescriptor(Type ConfigurationType, string Key) : IWritableJsonConfigurationDescriptor;

Framework/Foundation/Configurations/WritableJsonConfigurationExtensions.cs

@@ -0,0 +1,74 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.FileProviders;
+
+namespace Toolkit.Foundation;
+
+public static class WritableJsonConfigurationExtensions
+{
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path)
+    {
+        return builder.AddWritableJsonFile(null, path, false, false, null);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        Action<IWritableJsonConfigurationBuilder>? factoryDelegate)
+    {
+        return builder.AddWritableJsonFile(null, path, false, false, factoryDelegate);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, false, null);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional,
+        Action<IWritableJsonConfigurationBuilder>? factoryDelegate)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, false, factoryDelegate);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional,
+        bool reloadOnChange)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, reloadOnChange, null);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        string path,
+        bool optional,
+        bool reloadOnChange,
+        Action<IWritableJsonConfigurationBuilder>? factoryDelegate)
+    {
+        return builder.AddWritableJsonFile(null, path, optional, reloadOnChange, factoryDelegate);
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder,
+        IFileProvider? provider,
+        string path,
+        bool optional,
+        bool reloadOnChange, Action<IWritableJsonConfigurationBuilder>? writableJsonConfigurationDelegate)
+    {
+        IWritableJsonConfigurationBuilder writableJsonConfigurationBuilder = new WritableJsonConfigurationBuilder();
+        writableJsonConfigurationDelegate?.Invoke(writableJsonConfigurationBuilder);
+
+        return builder.AddWritableJsonFile(configuration =>
+        {
+            configuration.FileProvider = provider;
+            configuration.Path = path;
+            configuration.Optional = optional;
+            configuration.ReloadOnChange = reloadOnChange;
+            configuration.Factory = writableJsonConfigurationBuilder;
+            configuration.ResolveFileProvider();
+        });
+    }
+
+    public static IConfigurationBuilder AddWritableJsonFile(this IConfigurationBuilder builder, Action<WritableJsonConfigurationSource> configureSource) => builder.Add(configureSource);
+}

Framework/Foundation/Configurations/WritableJsonConfigurationFile.cs

@@ -0,0 +1,148 @@
+using Microsoft.Extensions.Configuration;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Text.Json;
+
+namespace Toolkit.Foundation;
+
+internal class WritableJsonConfigurationFile
+{
+    private readonly Dictionary<string, (JsonValueKind?, string?)> data = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Stack<string> paths = new();
+    private JObject tokenCache = new();
+    private bool isParsing;
+
+    public IDictionary<string, string?> Parse(Stream input)
+    {
+        return ParseStream(input);
+    }
+
+    public void Write(string key, string value, Stream output)
+    {
+        if (isParsing)
+        {
+            return;
+        }
+
+        if (key[^1] == ':')
+        {
+            key = key[0..^1];
+        }
+
+        string? tokenPath = $"$.{key.Replace(":", ".")}";
+        key = key.Replace("[", "").Replace("]", "");
+
+        if (tokenCache.SelectToken(tokenPath) is JToken token && data.ContainsKey(key))
+        {
+            (JsonValueKind? kind, string _) = data[key];
+            object? newValue = ConvertValue(kind, value);
+
+            data[key] = new(kind, value);
+            token.Replace(JToken.FromObject(newValue));
+        }
+
+        using StreamWriter streamWriter = new(output);
+        using JsonTextWriter writer = new(streamWriter) { Formatting = Formatting.Indented };
+        tokenCache.WriteTo(writer);
+
+        output.SetLength(output.Position);
+    }
+
+    private static object ConvertValue(JsonValueKind? kind, string value)
+    {
+        return kind is JsonValueKind.True or JsonValueKind.False ? bool.Parse(value) : value;
+    }
+
+    private void EnterContext(string context)
+    {
+        paths.Push(paths.Count > 0 ? paths.Peek() + ConfigurationPath.KeyDelimiter + context : context);
+    }
+
+    private void ExitContext()
+    {
+        paths.Pop();
+    }
+
+    private IDictionary<string, string?> ParseStream(Stream input)
+    {
+        data.Clear();
+
+        JsonDocumentOptions jsonDocumentOptions = new()
+        {
+            CommentHandling = JsonCommentHandling.Skip,
+            AllowTrailingCommas = true,
+        };
+
+        isParsing = true;
+        using (StreamReader? reader = new(input))
+        {
+            string? content = reader.ReadToEnd();
+            tokenCache = JObject.Parse(content);
+
+            using JsonDocument? doc = JsonDocument.Parse(content, jsonDocumentOptions);
+            VisitElement(doc.RootElement);
+        }
+        isParsing = false;
+
+        return data.ToDictionary(k => k.Key, v => v.Value.Item2?.ToString() ?? null);
+    }
+
+    private void VisitElement(JsonElement element)
+    {
+        bool isEmpty = true;
+
+        foreach (JsonProperty property in element.EnumerateObject())
+        {
+            isEmpty = false;
+
+            EnterContext(property.Name);
+            VisitValue(property.Value);
+            ExitContext();
+        }
+
+        if (isEmpty && paths.Count > 0)
+        {
+            data[paths.Peek()] = (JsonValueKind.Null, null);
+        }
+    }
+
+    private void VisitValue(JsonElement value)
+    {
+        switch (value.ValueKind)
+        {
+            case JsonValueKind.Object:
+                VisitElement(value);
+                break;
+
+            case JsonValueKind.Array:
+                int index = 0;
+                foreach (JsonElement arrayElement in value.EnumerateArray())
+                {
+                    EnterContext(index.ToString());
+                    VisitValue(arrayElement);
+                    ExitContext();
+                    index++;
+                }
+                break;
+
+            case JsonValueKind.Number:
+            case JsonValueKind.String:
+            case JsonValueKind.True:
+            case JsonValueKind.False:
+            case JsonValueKind.Null:
+                string key = paths.Peek();
+                if (data.ContainsKey(key))
+                {
+                    throw new FormatException();
+                }
+                data[key] = new(value.ValueKind, value.ToString());
+                break;
+
+            case JsonValueKind.Undefined:
+                break;
+
+            default:
+                throw new FormatException();
+        }
+    }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationProvider.cs

@@ -0,0 +1,46 @@
+using Microsoft.Extensions.Configuration.Json;
+using Microsoft.Extensions.FileProviders;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Toolkit.Foundation;
+
+public class WritableJsonConfigurationProvider : JsonConfigurationProvider, IWritableConfigurationProvider
+{
+    public WritableJsonConfigurationProvider(JsonConfigurationSource source) : base(source)
+    {
+
+    }
+
+    public void Write<TValue>(string section, TValue value) where TValue : class, new()
+    {
+        IFileInfo? file = Source.FileProvider?.GetFileInfo(Source.Path ?? string.Empty);
+        static Stream OpenRead(IFileInfo fileInfo)
+        {
+            return fileInfo.PhysicalPath is not null
+                ? new FileStream(fileInfo.PhysicalPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)
+                : fileInfo.CreateReadStream();
+        }
+
+        if (file is null)
+        {
+            throw new FileNotFoundException();
+        }
+
+        using Stream stream = OpenRead(file);
+        using StreamReader? reader = new(stream);
+
+        string? content = reader.ReadToEnd();
+        JObject? document = JObject.Parse(content);
+
+        if (document.SelectToken($"$.{section}") is JToken sectionToken)
+        {
+            sectionToken.Replace(JToken.Parse(JsonConvert.SerializeObject(value)));
+            stream.SetLength(0);
+
+            using StreamWriter streamWriter = new(stream);
+            using JsonTextWriter writer = new(streamWriter) { Formatting = Formatting.Indented };
+            document.WriteTo(writer);
+        }
+    }
+}

Framework/Foundation/Configurations/WritableJsonConfigurationSource.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.Configuration.Json;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.FileProviders;
+
+namespace Toolkit.Foundation;
+
+public class WritableJsonConfigurationSource : JsonConfigurationSource
+{
+    public IWritableJsonConfigurationBuilder? Factory { get; set; }
+
+    public override IConfigurationProvider Build(IConfigurationBuilder builder)
+    {
+        EnsureDefaultsWithSteam(builder);
+        return new WritableJsonConfigurationProvider(this);
+    }
+
+    private void EnsureDefaultsWithSteam(IConfigurationBuilder builder)
+    {
+        EnsureDefaults(builder);
+
+        if (FileProvider is PhysicalFileProvider physicalFileProvider)
+        {
+            string? outputFile = System.IO.Path.Combine(physicalFileProvider.Root, Path);
+            Factory?.Build(outputFile);
+        }
+    }
+}

Framework/Foundation/Configurations/Write.cs

@@ -0,0 +1,5 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public abstract record Write<TConfiguration>(string Section, Action<TConfiguration> UpdateDelegate) : IRequest  where TConfiguration : class;

Framework/Foundation/Configurations/WriteHandler.cs

@@ -0,0 +1,29 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public class WriteHandler<TConfiguration> : IRequestHandler<Write<TConfiguration>> where TConfiguration : class
+{
+    private readonly IMediator mediator;
+    private readonly TConfiguration configuration;
+    private readonly IConfigurationWriter<TConfiguration> writer;
+
+    public WriteHandler(TConfiguration configuration,
+        IConfigurationWriter<TConfiguration> writer,
+        IMediator mediator)
+    {
+        this.mediator = mediator;
+        this.configuration = configuration;
+        this.writer = writer;
+    }
+
+    public async ValueTask<Unit> Handle(Write<TConfiguration> request, CancellationToken cancellationToken)
+    {
+        request.UpdateDelegate.Invoke(configuration);
+        writer.Write(request.Section, configuration);
+
+        await mediator.Send(new ConfigurationChanged<TConfiguration>(configuration), cancellationToken);
+
+        return default;
+    }
+}

Framework/Foundation/Extensions/IHostBuilderExtensions.cs

@@ -0,0 +1,16 @@
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation;
+
+public static class IHostBuilderExtensions
+{
+    public static IHostBuilder UseContentRoot(this IHostBuilder hostBuilder, string contentRoot, bool createDirectory)
+    {
+        if (!Directory.Exists(contentRoot) && createDirectory)
+        {
+            Directory.CreateDirectory(contentRoot);
+        }
+
+        return hostBuilder.UseContentRoot(contentRoot);
+    }
+}

Framework/Foundation/Extensions/IServiceCollectionExtensions.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Toolkit.Foundation;
+
+public static class IServiceCollectionExtensions
+{
+    public static IServiceCollection AddHandler<TRequestHandler>(this IServiceCollection serviceCollection)
+    {
+        serviceCollection.TryAdd(new ServiceDescriptor(typeof(TRequestHandler), typeof(TRequestHandler), ServiceLifetime.Transient));
+        return serviceCollection;
+    }
+
+
+    public static IServiceCollection AddFoundation(this IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddSingleton<IServiceFactory>(provider => new ServiceFactory(provider.GetService, (instanceType, parameters) => ActivatorUtilities.CreateInstance(provider, instanceType, parameters!)))
+            .AddSingleton<IInitialization, Initialization>(provider => new Initialization(() =>
+            {
+                return serviceCollection.Where(x => x.ServiceType.GetInterfaces()
+                    .Contains(typeof(IInitializable)) || x.ServiceType == typeof(IInitializable))
+                    .GroupBy(x => x.ServiceType)
+                    .Select(x => x.First())
+                    .SelectMany(x => provider.GetServices(x.ServiceType)
+                    .Select(x => (IInitializable?)x)).ToList();
+            }));
+
+        return serviceCollection;
+    }
+}

Framework/Foundation/Extensions/IServiceFactoryExtensions.cs

@@ -0,0 +1,15 @@
+namespace Toolkit.Foundation;
+
+public static class IServiceFactoryExtensions
+{
+    public static T? Create<T>(this IServiceFactory serviceFactory, params object?[] parameters)
+    {
+        return serviceFactory.Create<T>(typeof(T), parameters);
+    }
+
+    public static object? Create(this IServiceFactory serviceFactory, Type type)
+    {
+        ServiceFactoryDescriptor? descriptor = new(serviceFactory);
+        return descriptor.Create(type);
+    }
+}

Framework/Foundation/Foundation.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>Toolkit.Foundation</AssemblyName>
+    <RootNamespace>Toolkit.Foundation</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JsonPatch.Net" Version="2.0.4" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
+    <PackageReference Include="Mediator.Abstractions" Version="2.1.0-preview.5" />
+  </ItemGroup>
+
+</Project>

Framework/Foundation/Lifecycles/AppService.cs

@@ -0,0 +1,25 @@
+using Mediator;
+using Microsoft.Extensions.Hosting;
+
+namespace Toolkit.Foundation;
+
+public class AppService : IHostedService
+{
+    private readonly IMediator mediator;
+
+    public AppService(IMediator mediator)
+    {
+        this.mediator = mediator;
+    }
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        await mediator.Send(new Initialize());
+        await mediator.Send(new Initialized());
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}

Framework/Foundation/Lifecycles/ICache.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface ICache
+{
+
+}

Framework/Foundation/Lifecycles/IInitializable.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IInitializable
+{
+    Task InitializeAsync();
+}

Framework/Foundation/Lifecycles/IInitialization.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IInitialization
+{
+    Task InitializeAsync();
+}

Framework/Foundation/Lifecycles/Initialization.cs

@@ -0,0 +1,26 @@
+using System.Diagnostics;
+
+namespace Toolkit.Foundation;
+
+public class Initialization : IInitialization
+{
+    private readonly Func<IEnumerable<IInitializable?>> factory;
+
+    public Initialization(Func<IEnumerable<IInitializable?>> factory)
+    {
+        this.factory = factory;
+    }
+
+    public async Task InitializeAsync()
+    {
+        foreach (IInitializable? initializer in factory())
+        {
+            if (initializer is not null)
+            {
+                Trace.WriteLine(initializer.GetType());
+                await initializer.InitializeAsync();
+                Trace.WriteLine("Done");
+            }
+        }
+    }
+}

Framework/Foundation/Lifecycles/Initialize.cs

@@ -0,0 +1,5 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public record Initialize : IRequest;

Framework/Foundation/Lifecycles/InitializeHandler.cs

@@ -0,0 +1,19 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public class InitializeHandler : IRequestHandler<Initialize>
+{
+    private readonly IInitialization initialization;
+
+    public InitializeHandler(IInitialization initialization)
+    {
+        this.initialization = initialization;
+    }
+
+    public async ValueTask<Unit> Handle(Initialize request, CancellationToken cancellationToken)
+    {
+        await initialization.InitializeAsync();
+        return default;
+    }
+}

Framework/Foundation/Lifecycles/Initialized.cs

@@ -0,0 +1,5 @@
+using Mediator;
+
+namespace Toolkit.Foundation;
+
+public record class Initialized : IRequest;

Framework/Foundation/Navigation/IEventParameter.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Toolkit.Foundation
+{
+    public interface IEventParameter
+    {
+        List<object> GetValues(EventArgs args);
+    }
+}

Framework/Foundation/Navigation/INavigationConfirmation.cs

@@ -0,0 +1,13 @@
+
+namespace Toolkit.Foundation
+{
+    public interface INavigationConfirmation
+    {
+        ValueTask<bool> CanConfirm();
+    }
+
+    public interface INavigated
+    {
+        ValueTask Navigated();
+    }
+}

Framework/Foundation/Navigation/INavigationRouteDescriptor.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public interface INavigationRouteDescriptor
+    {
+        object Route { get; }
+
+        string? Name { get; }
+    }
+}

Framework/Foundation/Navigation/INavigationRouteDescriptorCollection.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Toolkit.Foundation
+{
+    public interface INavigationRouteDescriptorCollection : IList<INavigationRouteDescriptor>
+    {
+    }
+}

Framework/Foundation/Navigation/IParameter.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public interface IParameter
+    {
+        string? Key { get; }
+
+        KeyValuePair<string, object>? GetValue(object target);
+    }
+}

Framework/Foundation/Navigation/Navigate.cs

@@ -0,0 +1,29 @@
+using Mediator;
+
+namespace Toolkit.Foundation
+{
+    public record Navigate : IRequest
+    {
+        public Navigate(string name, params object?[] parameters)
+        {
+            Name = name;
+            Parameters = parameters;
+        }
+
+        public Navigate(Type type, params object?[] parameters)
+        {
+            Type = type;
+            Parameters = parameters;
+        }
+
+        public Type? Type { get; }
+
+        public object? Route { get; init; }
+
+        public string? Name { get; }
+
+        public string? FriendlyName { get; init; }
+
+        public object?[] Parameters { get; }
+    }
+}

Framework/Foundation/Navigation/NavigateBack.cs

@@ -0,0 +1,7 @@
+using Mediator;
+
+namespace Toolkit.Foundation
+{
+    public record NavigateBack(object Route) : IRequest;
+
+}

Framework/Foundation/Navigation/NavigationRoute.cs

@@ -0,0 +1,6 @@
+using Mediator;
+
+namespace Toolkit.Foundation
+{
+    public record NavigationRoute(string Name, object Route) : IRequest;
+}

Framework/Foundation/Navigation/NavigationRouteDescriptor.cs

@@ -0,0 +1,15 @@
+namespace Toolkit.Foundation
+{
+    public record NavigationRouteDescriptor : INavigationRouteDescriptor
+    {
+        public NavigationRouteDescriptor(string name, object route)
+        {
+            Name = name;
+            Route = route;
+        }
+
+        public string Name { get; }
+
+        public object Route { get; }
+    }
+}

Framework/Foundation/Navigation/NavigationRouteDescriptorCollection.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public class NavigationRouteDescriptorCollection : List<INavigationRouteDescriptor>, INavigationRouteDescriptorCollection
+    {
+        public NavigationRouteDescriptorCollection(IEnumerable<INavigationRouteDescriptor> collection) : base(collection)
+        {
+        }
+    }
+}

Framework/Foundation/Services/IServiceCreator.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface IServiceCreator<T>
+    {
+        object Create(Func<Type, object[], object> creator, params object[] parameters);
+    }
+}

Framework/Foundation/Services/IServiceFactory.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation
+{
+    public interface IServiceFactory
+    {
+        object? Create(Type type, params object?[] parameters);
+
+        T? Create<T>(Type type, params object?[] parameters);
+    }
+}

Framework/Foundation/Services/ServiceCreator.cs

@@ -0,0 +1,10 @@
+namespace Toolkit.Foundation
+{
+    public class ServiceCreator<I, T> : IServiceCreator<I>
+    {
+        public virtual object Create(Func<Type, object[], object> creator, params object[] parameters)
+        {
+            return creator(typeof(T), parameters);
+        }
+    }
+}

Framework/Foundation/Services/ServiceFactory.cs

@@ -0,0 +1,26 @@
+namespace Toolkit.Foundation
+{
+    public class ServiceFactory : IServiceFactory
+    {
+        private readonly Func<Type, object?> factory;
+        private readonly Func<Type, object?[], object> creator;
+
+        public ServiceFactory(Func<Type, object?> factory, Func<Type, object?[], object> creator)
+        {
+            this.factory = factory;
+            this.creator = creator;
+        }
+
+        public object? Create(Type type, params object?[] parameters)
+        {
+            dynamic? lookup = factory(typeof(IServiceCreator<>).MakeGenericType(type));
+            return lookup is not null ? lookup.Create(creator, parameters) : creator(type, parameters);
+        }
+
+        public T? Create<T>(Type type, params object?[] parameters)
+        {
+            dynamic? lookup = factory(typeof(IServiceCreator<>).MakeGenericType(type));
+            return lookup is not null ? (T)lookup.Create(creator, parameters) : (T)creator(type, parameters);
+        }
+    }
+}

Framework/Foundation/Services/ServiceFactoryDescriptor.cs

@@ -0,0 +1,25 @@
+using System.Reflection;
+
+namespace Toolkit.Foundation
+{
+    internal class ServiceFactoryDescriptor
+    {
+        private readonly IServiceFactory serviceFactory;
+
+        public ServiceFactoryDescriptor(IServiceFactory serviceFactory)
+        {
+            this.serviceFactory = serviceFactory;
+        }
+
+        public object? Create(Type type)
+        {
+            MethodInfo? methodInfo = typeof(ServiceFactoryDescriptor).GetMethod(nameof(Create), BindingFlags.NonPublic | BindingFlags.Instance);
+            return methodInfo?.MakeGenericMethod(type).Invoke(this, new object[] { type });
+        }
+
+        private T Create<T>(Type type)
+        {
+            return serviceFactory.Create<T>(type);
+        }
+    }
+}

Framework/Foundation/Templates/INamedDataTemplateFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface INamedDataTemplateFactory
+    {
+        object? Create(string name, params object[] parameters);
+    }
+}

Framework/Foundation/Templates/INamedTemplateFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface INamedTemplateFactory
+    {
+        object? Create(string name);
+    }
+}

Framework/Foundation/Templates/ITemplateBuilder.cs

@@ -0,0 +1,13 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Toolkit.Foundation
+{
+    public interface ITemplateBuilder
+    {
+        IReadOnlyCollection<ITemplateDescriptor> Descriptors { get; }
+
+        ITemplateBuilder Add<TViewModel, TView>(string name, ServiceLifetime lifetime = ServiceLifetime.Transient);
+
+        ITemplateBuilder Add<TViewModel, TView>(ServiceLifetime lifetime = ServiceLifetime.Transient);
+    }
+}

Framework/Foundation/Templates/ITemplateDescriptor.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Toolkit.Foundation
+{
+    public interface ITemplateDescriptor
+    {
+        Type ContentType { get; }
+
+        ServiceLifetime Lifetime { get; }
+
+        string? Name { get; }
+
+        Type TemplateType { get; }
+    }
+}

Framework/Foundation/Templates/ITemplateDescriptorProvider.cs

@@ -0,0 +1,12 @@
+namespace Toolkit.Foundation
+{
+
+    public interface ITemplateDescriptorProvider
+    {
+        ITemplateDescriptor? Get(string name);
+
+        ITemplateDescriptor? Get(Type type);
+
+        ITemplateDescriptor? Get<T>();
+    }
+}

Framework/Foundation/Templates/ITemplateFactory.cs

@@ -0,0 +1,9 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.Foundation
+{
+    public interface ITemplateFactory
+    {
+        object? Create([MaybeNull] object? data);
+    }
+}

Framework/Foundation/Templates/ITemplateSelector.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation
+{
+    public interface ITemplateSelector
+    {
+    }
+}

Framework/Foundation/Templates/ITypedDataTemplateFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation
+{
+    public interface ITypedDataTemplateFactory
+    {
+        object? Create(Type type, params object[] parameters);
+    }
+}

Framework/Foundation/Templates/NamedDataTemplateFactory.cs

@@ -0,0 +1,36 @@
+namespace Toolkit.Foundation
+{
+    public class NamedDataTemplateFactory : INamedDataTemplateFactory
+    {
+        private readonly Dictionary<string, object> cache = new();
+
+        private readonly IReadOnlyCollection<ITemplateDescriptor> descriptors;
+        private readonly IServiceFactory serviceFactory;
+
+        public NamedDataTemplateFactory(IReadOnlyCollection<ITemplateDescriptor> descriptors,
+            IServiceFactory serviceFactory)
+        {
+            this.descriptors = descriptors;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create(string name, params object[] parameters)
+        {
+            if (cache.TryGetValue(name, out object? data))
+            {
+                return data;
+            }
+
+            if (descriptors.FirstOrDefault(x => x.Name == name) is ITemplateDescriptor descriptor)
+            {
+                data = parameters is { Length: > 0 } ? serviceFactory.Create<object>(descriptor.ContentType, parameters) : serviceFactory.Create(descriptor.ContentType);
+                if (data is ICache cache)
+                {
+                    this.cache[name] = cache;
+                }
+            }
+
+            return data;
+        }
+    }
+}

Framework/Foundation/Templates/NamedTemplateFactory.cs

@@ -0,0 +1,41 @@
+namespace Toolkit.Foundation
+{
+    public class NamedTemplateFactory : INamedTemplateFactory
+    {
+        private readonly Dictionary<string, object> cache = new();
+
+        private readonly ITemplateDescriptorProvider provider;
+        private readonly IServiceFactory serviceFactory;
+
+        public NamedTemplateFactory(ITemplateDescriptorProvider provider,
+            IServiceFactory serviceFactory)
+        {
+            this.provider = provider;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create(string name)
+        {
+            if (cache.TryGetValue(name, out object? view))
+            {
+                return view;
+            }
+
+            if (provider.Get(name) is ITemplateDescriptor descriptor)
+            {
+                view = serviceFactory.Create(descriptor.TemplateType);
+                if (view is ICache cache)
+                {
+                    this.cache[name] = cache;
+                }
+
+                if (descriptor.GetType().GenericTypeArguments is { Length: 2 })
+                {
+                    (descriptor as dynamic).ViewInvoker?.Invoke(view);
+                }
+            }
+
+            return view;
+        }
+    }
+}

Framework/Foundation/Templates/TemplateBuilder.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.ObjectModel;
+
+namespace Toolkit.Foundation
+{
+    public class TemplateBuilder : ITemplateBuilder
+    {
+        private readonly List<ITemplateDescriptor> descriptors = new();
+
+        public IReadOnlyCollection<ITemplateDescriptor> Descriptors => new ReadOnlyCollection<ITemplateDescriptor>(descriptors);
+
+        public ITemplateBuilder Add<TViewModel, TView>(string name, ServiceLifetime lifetime = ServiceLifetime.Transient)
+        {
+            descriptors.Add(new TemplateDescriptor(typeof(TViewModel), typeof(TView), name, lifetime));
+            return this;
+        }
+
+        public ITemplateBuilder Add<TViewModel, TView>(ServiceLifetime lifetime = ServiceLifetime.Transient)
+        {
+            descriptors.Add(new TemplateDescriptor(typeof(TViewModel), typeof(TView), null, lifetime));
+            return this;
+        }
+    }
+}

Framework/Foundation/Templates/TemplateDescriptor.cs

@@ -0,0 +1,26 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Toolkit.Foundation
+{
+    public class TemplateDescriptor : ITemplateDescriptor
+    {
+        public TemplateDescriptor(Type dataType,
+            Type templateType,
+            string? name = null,
+            ServiceLifetime lifetime = ServiceLifetime.Transient)
+        {
+            TemplateType = templateType;
+            ContentType = dataType;
+            Name = name;
+            Lifetime = lifetime;
+        }
+
+        public ServiceLifetime Lifetime { get; }
+
+        public Type TemplateType { get; }
+
+        public Type ContentType { get; }
+
+        public string? Name { get; }
+    }
+}

Framework/Foundation/Templates/TemplateDescriptorProvider.cs

@@ -0,0 +1,42 @@
+namespace Toolkit.Foundation
+{
+    public class TemplateDescriptorProvider : ITemplateDescriptorProvider
+    {
+        private readonly IReadOnlyCollection<ITemplateDescriptor> descriptors;
+
+        public TemplateDescriptorProvider(IReadOnlyCollection<ITemplateDescriptor> descriptors)
+        {
+            this.descriptors = descriptors;
+        }
+
+        public ITemplateDescriptor? Get(string name)
+        {
+            if (descriptors.FirstOrDefault(x => x.Name == name) is ITemplateDescriptor descriptor)
+            {
+                return descriptor;
+            }
+
+            return null;
+        }
+
+        public ITemplateDescriptor? Get(Type type)
+        {
+            if (descriptors.FirstOrDefault(x => x.ContentType == type) is ITemplateDescriptor descriptor)
+            {
+                return descriptor;
+            }
+
+            return null;
+        }
+
+        public ITemplateDescriptor? Get<T>()
+        {
+            if (descriptors.FirstOrDefault(x => x.ContentType == typeof(T)) is ITemplateDescriptor descriptor)
+            {
+                return descriptor;
+            }
+
+            return null;
+        }
+    }
+}

Framework/Foundation/Templates/TemplateFactory.cs

@@ -0,0 +1,43 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.Foundation
+{
+    public class TemplateFactory : ITemplateFactory
+    {
+        private readonly Dictionary<object, object> cache = new();
+
+        private readonly ITemplateDescriptorProvider provider;
+        private readonly IServiceFactory serviceFactory;
+
+        public TemplateFactory(ITemplateDescriptorProvider provider,
+            IServiceFactory serviceFactory)
+        {
+            this.provider = provider;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create([MaybeNull] object? data)
+        {
+            if (data is null)
+            {
+                return null;
+            }
+
+            if (cache.TryGetValue(data, out object? template))
+            {
+                return template;
+            }
+
+            if (provider.Get(data.GetType()) is ITemplateDescriptor descriptor)
+            {
+                template = serviceFactory.Create(descriptor.TemplateType);
+                if (template is ICache cache)
+                {
+                    this.cache[data] = cache;
+                }
+            }
+
+            return template;
+        }
+    }
+}

Framework/Foundation/Templates/TypedDataTemplateFactory.cs

@@ -0,0 +1,36 @@
+namespace Toolkit.Foundation
+{
+    public class TypedDataTemplateFactory : ITypedDataTemplateFactory
+    {
+        private readonly Dictionary<Type, object> cache = new();
+
+        private readonly IReadOnlyCollection<ITemplateDescriptor> descriptors;
+        private readonly IServiceFactory serviceFactory;
+
+        public TypedDataTemplateFactory(IReadOnlyCollection<ITemplateDescriptor> descriptors,
+            IServiceFactory serviceFactory)
+        {
+            this.descriptors = descriptors;
+            this.serviceFactory = serviceFactory;
+        }
+
+        public virtual object? Create(Type type, params object[] parameters)
+        {
+            if (cache.TryGetValue(type, out object? data))
+            {
+                return data;
+            }
+
+            if (descriptors.FirstOrDefault(x => x.ContentType == type) is ITemplateDescriptor descriptor)
+            {
+                data = parameters is { Length: > 0 } ? serviceFactory.Create<object>(descriptor.ContentType, parameters) : serviceFactory.Create(descriptor.ContentType);
+                if (data is ICache cache)
+                {
+                    this.cache[type] = cache;
+                }
+            }
+
+            return data;
+        }
+    }
+}