[2.x] Defer Prop

InertiaCore/Inertia.cs

@@ -35,7 +35,21 @@ public static class Inertia
 
     public static AlwaysProp Always(Func<Task<object?>> callback) => _factory.Always(callback);
 
+    public static DeferProp Defer(Func<object?> callback, string group = "default") => _factory.Defer(callback, group);
+
+    public static DeferProp Defer(Func<Task<object?>> callback, string group = "default") => _factory.Defer(callback, group);
+
     public static LazyProp Lazy(Func<object?> callback) => _factory.Lazy(callback);
 
     public static LazyProp Lazy(Func<Task<object?>> callback) => _factory.Lazy(callback);
+
+    public static OptionalProp Optional(Func<object?> callback) => _factory.Optional(callback);
+
+    public static OptionalProp Optional(Func<Task<object?>> callback) => _factory.Optional(callback);
+
+    public static MergeProp Merge(object? value) => _factory.Merge(value);
+
+    public static MergeProp Merge(Func<object?> callback) => _factory.Merge(callback);
+
+    public static MergeProp Merge(Func<Task<object?>> callback) => _factory.Merge(callback);
 }

InertiaCore/Models/Page.cs

@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 namespace InertiaCore.Models;
 
 internal class Page
@@ -6,4 +8,10 @@ internal class Page
     public string Component { get; set; } = default!;
     public string? Version { get; set; }
     public string Url { get; set; } = default!;
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public List<string>? MergeProps { get; set; }
+
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public Dictionary<string, List<string>>? DeferredProps { get; set; }
 }

InertiaCore/Props/DeferProp.cs

@@ -0,0 +1,36 @@
+using InertiaCore.Utils;
+
+namespace InertiaCore.Props;
+
+public class DeferProp : InvokableProp, IIgnoresFirstLoad, Mergeable
+{
+    public bool merge { get; set; }
+    protected readonly string _group = "default";
+
+    public DeferProp(object? value, string group) : base(value)
+    {
+        _group = group;
+    }
+
+    internal DeferProp(Func<object?> value, string group) : base(value)
+    {
+        _group = group;
+    }
+
+    internal DeferProp(Func<Task<object?>> value, string group) : base(value)
+    {
+        _group = group;
+    }
+
+    public Mergeable Merge()
+    {
+        merge = true;
+
+        return this;
+    }
+
+    public string? Group()
+    {
+        return _group;
+    }
+}

InertiaCore/Props/LazyProp.cs

@@ -1,6 +1,8 @@
+using InertiaCore.Utils;
+
 namespace InertiaCore.Props;
 
-public class LazyProp : InvokableProp
+public class LazyProp : InvokableProp, IIgnoresFirstLoad
 {
     internal LazyProp(Func<object?> value) : base(value)
     {

InertiaCore/Props/MergeProp.cs

@@ -0,0 +1,25 @@
+using InertiaCore.Props;
+
+namespace InertiaCore.Utils;
+
+public class MergeProp : InvokableProp, Mergeable
+{
+    public bool merge { get; set; } = true;
+
+    public MergeProp(object? value) : base(value)
+    {
+        merge = true;
+    }
+
+    internal MergeProp(Func<object?> value) : base(value)
+    {
+        merge = true;
+    }
+
+    internal MergeProp(Func<Task<object?>> value) : base(value)
+    {
+        merge = true;
+    }
+}
+
+

InertiaCore/Props/OptionalProp.cs

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

InertiaCore/Response.cs

@@ -43,6 +43,8 @@ protected internal async Task ProcessResponse()
             Props = props
         };
 
+        page.MergeProps = ResolveMergeProps(props);
+        page.DeferredProps = ResolveDeferredProps(props);
         page.Props["errors"] = GetErrors();
 
         SetPage(page);
@@ -84,7 +86,7 @@ protected internal async Task ProcessResponse()
 
         if (!isPartial)
             return props
-                .Where(kv => kv.Value is not LazyProp)
+                .Where(kv => kv.Value is not IIgnoresFirstLoad)
                 .ToDictionary(kv => kv.Key, kv => kv.Value);
 
         props = props.ToDictionary(kv => kv.Key, kv => kv.Value);
@@ -140,6 +142,74 @@ protected internal async Task ProcessResponse()
             .Concat(alwaysProps).ToDictionary(kv => kv.Key, kv => kv.Value);
     }
 
+    /// <summary>
+    /// Resolve `merge` properties that should be appended to the existing values by the front-end.
+    /// </summary>
+    private List<string>? ResolveMergeProps(Dictionary<string, object?> props)
+    {
+        // Parse the "RESET" header into a collection of keys to reset
+        var resetProps = new HashSet<string>(
+           _context!.HttpContext.Request.Headers[InertiaHeader.Reset]
+               .ToString()
+               .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+               .Select(s => s.Trim()),
+           StringComparer.OrdinalIgnoreCase
+       );
+
+        var resolvedProps = props
+            .Select(kv => kv.Key.ToCamelCase()) // Convert property name to camelCase
+            .ToList();
+
+        // Filter the props that are Mergeable and should be merged
+        var mergeProps = _props.Where(o => o.Value is Mergeable mergeable && mergeable.ShouldMerge()) // Check if value is Mergeable and should merge
+            .Where(kv => !resetProps.Contains(kv.Key)) // Exclude reset keys
+            .Select(kv => kv.Key.ToCamelCase()) // Convert property name to camelCase
+            .Where(resolvedProps.Contains) // Filter only the props that are in the resolved props
+            .ToList();
+
+        if (mergeProps.Count == 0)
+        {
+            return null;
+        }
+
+        // Return the result
+        return mergeProps;
+    }
+
+    /// <summary>
+    /// Resolve `deferred` properties that should be fetched after the initial page load.
+    /// </summary>
+    private Dictionary<string, List<string>>? ResolveDeferredProps(Dictionary<string, object?> props)
+    {
+
+        bool isPartial = _context!.IsInertiaPartialComponent(_component);
+        if (isPartial)
+        {
+            return null;
+        }
+
+        var deferredProps = _props.Where(o => o.Value is DeferProp) // Filter props that are instances of DeferProp
+            .Select(kv => new
+            {
+                Key = kv.Key,
+                Group = ((DeferProp)kv.Value!).Group()
+            }) // Map each prop to a new object with Key and Group
+
+            .GroupBy(x => x.Group) // Group by 'Group'
+            .ToDictionary(
+                g => g.Key!,
+                g => g.Select(x => x.Key.ToCamelCase()).ToList() // Extract 'Key' for each group
+            );
+
+        if (deferredProps.Count == 0)
+        {
+            return null;
+        }
+
+        // Return the result
+        return deferredProps;
+    }
+
     /// <summary>
     /// Resolve all necessary class instances in the given props.
     /// </summary>

InertiaCore/ResponseFactory.cs

@@ -26,6 +26,13 @@ internal interface IResponseFactory
     public AlwaysProp Always(Func<Task<object?>> callback);
     public LazyProp Lazy(Func<object?> callback);
     public LazyProp Lazy(Func<Task<object?>> callback);
+    public DeferProp Defer(Func<object?> callback, string group = "default");
+    public DeferProp Defer(Func<Task<object?>> callback, string group = "default");
+    public MergeProp Merge(object? value);
+    public MergeProp Merge(Func<object?> callback);
+    public MergeProp Merge(Func<Task<object?>> callback);
+    public OptionalProp Optional(Func<object?> callback);
+    public OptionalProp Optional(Func<Task<object?>> callback);
 }
 
 internal class ResponseFactory : IResponseFactory
@@ -127,10 +134,16 @@ public void Share(IDictionary<string, object?> data)
 
         context.Features.Set(sharedData);
     }
-
     public LazyProp Lazy(Func<object?> callback) => new(callback);
     public LazyProp Lazy(Func<Task<object?>> callback) => new(callback);
     public AlwaysProp Always(object? value) => new(value);
     public AlwaysProp Always(Func<object?> callback) => new(callback);
     public AlwaysProp Always(Func<Task<object?>> callback) => new(callback);
+    public DeferProp Defer(Func<object?> callback, string group = "default") => new(callback, group);
+    public DeferProp Defer(Func<Task<object?>> callback, string group = "default") => new(callback, group);
+    public MergeProp Merge(object? value) => new(value);
+    public MergeProp Merge(Func<object?> callback) => new(callback);
+    public MergeProp Merge(Func<Task<object?>> callback) => new(callback);
+    public OptionalProp Optional(Func<object?> callback) => new(callback);
+    public OptionalProp Optional(Func<Task<object?>> callback) => new(callback);
 }

InertiaCore/Utils/IIgnoresFirstLoad.cs

@@ -0,0 +1,5 @@
+namespace InertiaCore.Utils;
+
+public interface IIgnoresFirstLoad
+{
+}

InertiaCore/Utils/InertiaHeader.cs

@@ -15,4 +15,6 @@ public static class InertiaHeader
     public const string PartialOnly = "X-Inertia-Partial-Data";
 
     public const string PartialExcept = "X-Inertia-Partial-Except";
+
+    public const string Reset = "X-Inertia-Reset";
 }

InertiaCore/Utils/Mergeable.cs

@@ -0,0 +1,15 @@
+namespace InertiaCore.Utils;
+
+public interface Mergeable
+{
+    public bool merge { get; set; }
+
+    public Mergeable Merge()
+    {
+        merge = true;
+
+        return this;
+    }
+
+    public bool ShouldMerge() => merge;
+}