Merge branch 'main' into custom-json-serializer

# Conflicts:
#	InertiaCore/Response.cs
#	InertiaCore/ResponseFactory.cs
#	README.md

Author: kapi2289

.github/workflows/dotnet.yml

@@ -5,9 +5,13 @@ name: .NET
 
 on:
   push:
-    branches: [ "main" ]
+    branches:
+      - "main"
+      - "v1"
   pull_request:
-    branches: [ "main" ]
+    branches:
+      - "main"
+      - "v1"
 
 jobs:
   build:
@@ -19,7 +23,11 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: |
+          6.0.x
+          7.0.x
+          8.0.x
+          9.0.x
     - name: Restore dependencies
       run: dotnet restore
     - name: Build

InertiaCore/Extensions/Configure.cs

@@ -19,13 +19,17 @@ public static IApplicationBuilder UseInertia(this IApplicationBuilder app)
         Inertia.UseFactory(factory);
 
         var viteBuilder = app.ApplicationServices.GetService<IViteBuilder>();
-        if (viteBuilder != null) Vite.UseBuilder(viteBuilder);
+        if (viteBuilder != null)
+        {
+            Vite.UseBuilder(viteBuilder);
+            Inertia.Version(Vite.GetManifestHash);
+        }
 
         app.Use(async (context, next) =>
         {
             if (context.IsInertiaRequest()
                 && context.Request.Method == "GET"
-                && context.Request.Headers["X-Inertia-Version"] != Inertia.GetVersion())
+                && context.Request.Headers[InertiaHeader.Version] != Inertia.GetVersion())
             {
                 await OnVersionChange(context, app);
                 return;
@@ -80,7 +84,7 @@ private static async Task OnVersionChange(HttpContext context, IApplicationBuild
 
         if (tempData.Any()) tempData.Keep();
 
-        context.Response.Headers.Override("X-Inertia-Location", context.RequestedUri());
+        context.Response.Headers.Override(InertiaHeader.Location, context.RequestedUri());
         context.Response.StatusCode = (int)HttpStatusCode.Conflict;
 
         await context.Response.CompleteAsync();

InertiaCore/Extensions/InertiaExtensions.cs

@@ -1,46 +1,66 @@
 using System.Text.Json;
+using InertiaCore.Utils;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.AspNetCore.Mvc;
+using System.Text;
 
 namespace InertiaCore.Extensions;
 
 internal static class InertiaExtensions
 {
-    internal static IEnumerable<string> Only(this object obj, IEnumerable<string> only) =>
-        obj.GetType().GetProperties().Select(c => c.Name)
-            .Intersect(only, StringComparer.OrdinalIgnoreCase).ToList();
-
-    internal static List<string> GetPartialData(this ActionContext context) =>
-        context.HttpContext.Request.Headers["X-Inertia-Partial-Data"]
-            .FirstOrDefault()?.Split(",")
-            .Where(s => !string.IsNullOrEmpty(s))
-            .ToList() ?? new List<string>();
-
     internal static bool IsInertiaPartialComponent(this ActionContext context, string component) =>
-        context.HttpContext.Request.Headers["X-Inertia-Partial-Component"] == component;
+        context.HttpContext.Request.Headers[InertiaHeader.PartialComponent] == component;
 
     internal static string RequestedUri(this HttpContext context) =>
         Uri.UnescapeDataString(context.Request.GetEncodedPathAndQuery());
 
     internal static string RequestedUri(this ActionContext context) => context.HttpContext.RequestedUri();
 
     internal static bool IsInertiaRequest(this HttpContext context) =>
-        bool.TryParse(context.Request.Headers["X-Inertia"], out _);
+        bool.TryParse(context.Request.Headers[InertiaHeader.Inertia], out _);
 
     internal static bool IsInertiaRequest(this ActionContext context) => context.HttpContext.IsInertiaRequest();
 
     internal static string ToCamelCase(this string s) => JsonNamingPolicy.CamelCase.ConvertName(s);
 
     internal static bool Override<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
     {
-        if (dictionary.ContainsKey(key))
-        {
-            dictionary[key] = value;
-            return true;
-        }
-
-        dictionary.Add(key, value);
-        return false;
+        if (dictionary.TryAdd(key, value)) return false;
+        dictionary[key] = value;
+
+        return true;
+    }
+
+    internal static Task<object?> ResolveAsync(this Func<object?> func)
+    {
+        var rt = func.Method.ReturnType;
+
+        if (!rt.IsGenericType || rt.GetGenericTypeDefinition() != typeof(Task<>))
+            return Task.Run(func.Invoke);
+
+        var task = func.DynamicInvoke() as Task;
+        return task!.ResolveResult();
+    }
+
+    internal static async Task<object?> ResolveResult(this Task task)
+    {
+        await task.ConfigureAwait(false);
+        var result = task.GetType().GetProperty("Result");
+
+        return result?.GetValue(task);
+    }
+
+    internal static string MD5(this string s)
+    {
+        using var md5 = System.Security.Cryptography.MD5.Create();
+        var inputBytes = Encoding.UTF8.GetBytes(s);
+        var hashBytes = md5.ComputeHash(inputBytes);
+
+        var sb = new StringBuilder();
+        foreach (var t in hashBytes)
+            sb.Append(t.ToString("x2"));
+
+        return sb.ToString();
     }
 }

InertiaCore/Inertia.cs

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using InertiaCore.Props;
 using InertiaCore.Utils;
 using Microsoft.AspNetCore.Html;
 
@@ -18,7 +19,9 @@ public static class Inertia
 
     public static Task<IHtmlContent> Html(dynamic model) => _factory.Html(model);
 
-    public static void Version(object? version) => _factory.Version(version);
+    public static void Version(string? version) => _factory.Version(version);
+
+    public static void Version(Func<string?> version) => _factory.Version(version);
 
     public static string? GetVersion() => _factory.GetVersion();
 
@@ -28,5 +31,13 @@ public static class Inertia
 
     public static void Share(IDictionary<string, object?> data) => _factory.Share(data);
 
+    public static AlwaysProp Always(string value) => _factory.Always(value);
+
+    public static AlwaysProp Always(Func<string> callback) => _factory.Always(callback);
+
+    public static AlwaysProp Always(Func<Task<object?>> callback) => _factory.Always(callback);
+
     public static LazyProp Lazy(Func<object?> callback) => _factory.Lazy(callback);
+
+    public static LazyProp Lazy(Func<Task<object?>> callback) => _factory.Lazy(callback);
 }

InertiaCore/Models/InertiaOptions.cs

@@ -6,4 +6,5 @@ public class InertiaOptions
 
     public bool SsrEnabled { get; set; } = false;
     public string SsrUrl { get; set; } = "http://127.0.0.1:13714/render";
+    public bool EncryptHistory { get; set; } = false;
 }

InertiaCore/Models/Page.cs

@@ -6,4 +6,6 @@ internal class Page
     public string Component { get; set; } = default!;
     public string? Version { get; set; }
     public string Url { get; set; } = default!;
+    public bool EncryptHistory { get; set; } = false;
+    public bool ClearHistory { get; set; } = false;
 }

InertiaCore/Props/AlwaysProp.cs

@@ -0,0 +1,16 @@
+namespace InertiaCore.Props;
+
+public class AlwaysProp : InvokableProp
+{
+    internal AlwaysProp(object? value) : base(value)
+    {
+    }
+
+    internal AlwaysProp(Func<object?> value) : base(value)
+    {
+    }
+
+    internal AlwaysProp(Func<Task<object?>> value) : base(value)
+    {
+    }
+}

InertiaCore/Props/InvokableProp.cs

@@ -0,0 +1,21 @@
+using InertiaCore.Extensions;
+
+namespace InertiaCore.Props;
+
+public class InvokableProp
+{
+    private readonly object? _value;
+
+    protected InvokableProp(object? value) => _value = value;
+
+    internal Task<object?> Invoke()
+    {
+        return _value switch
+        {
+            Func<object?> f => f.ResolveAsync(),
+            Task t => t.ResolveResult(),
+            InvokableProp p => p.Invoke(),
+            _ => Task.FromResult(_value)
+        };
+    }
+}

InertiaCore/Props/LazyProp.cs

@@ -0,0 +1,12 @@
+namespace InertiaCore.Props;
+
+public class LazyProp : InvokableProp
+{
+    internal LazyProp(Func<object?> value) : base(value)
+    {
+    }
+
+    internal LazyProp(Func<Task<object?>> value) : base(value)
+    {
+    }
+}