[2.x] Merge prop

InertiaCore/Inertia.cs

@@ -40,4 +40,20 @@ public static class Inertia
     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);
+
+    public static DeepMergeProp DeepMerge(object? value) => _factory.DeepMerge(value);
+
+    public static DeepMergeProp DeepMerge(Func<object?> callback) => _factory.DeepMerge(callback);
+
+    public static DeepMergeProp DeepMerge(Func<Task<object?>> callback) => _factory.DeepMerge(callback);
 }

InertiaCore/Models/Page.cs

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

InertiaCore/Props/DeepMergeProp.cs

@@ -0,0 +1,30 @@
+using InertiaCore.Utils;
+
+namespace InertiaCore.Props;
+
+public class DeepMergeProp : InvokableProp, Mergeable
+{
+    public bool merge { get; set; } = true;
+    public string[]? matchOn { get; set; }
+    public bool deepMerge { get; set; } = true;
+
+    public DeepMergeProp(object? value) : base(value)
+    {
+        merge = true;
+        deepMerge = true;
+    }
+
+    internal DeepMergeProp(Func<object?> value) : base(value)
+    {
+        merge = true;
+        deepMerge = true;
+    }
+
+    internal DeepMergeProp(Func<Task<object?>> value) : base(value)
+    {
+        merge = true;
+        deepMerge = true;
+    }
+
+    public bool ShouldDeepMerge() => deepMerge;
+}

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,27 @@
+using InertiaCore.Props;
+
+namespace InertiaCore.Utils;
+
+public class MergeProp : InvokableProp, Mergeable
+{
+    public bool merge { get; set; } = true;
+    public bool deepMerge { get; set; } = false;
+    public string[]? matchOn { get; set; }
+
+    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

@@ -47,6 +47,9 @@ protected internal async Task ProcessResponse()
             ClearHistory = _clearHistory,
         };
 
+        page.MergeProps = ResolveMergeProps(props);
+        page.MatchPropsOn = ResolveMatchPropsOn(props);
+        page.DeepMergeProps = ResolveDeepMergeProps(props);
         page.Props["errors"] = GetErrors();
 
         SetPage(page);
@@ -88,7 +91,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);
@@ -144,6 +147,167 @@ 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
+       );
+
+        // Parse the "PARTIAL_ONLY" header into a collection of keys to include
+        var onlyProps = _context!.HttpContext.Request.Headers[InertiaHeader.PartialOnly]
+            .ToString()
+            .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+            .Select(s => s.Trim())
+            .Where(s => !string.IsNullOrEmpty(s))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        // Parse the "PARTIAL_EXCEPT" header into a collection of keys to exclude
+        var exceptProps = new HashSet<string>(
+            _context!.HttpContext.Request.Headers[InertiaHeader.PartialExcept]
+                .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
+            .Where(kv => onlyProps.Count == 0 || onlyProps.Contains(kv.Key)) // Include only specified keys if any
+            .Where(kv => !exceptProps.Contains(kv.Key)) // Exclude specified 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 match props on for properties that should be matched on specific keys.
+    /// </summary>
+    private Dictionary<string, string[]>? ResolveMatchPropsOn(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
+       );
+
+        // Parse the "PARTIAL_ONLY" header into a collection of keys to include
+        var onlyProps = _context!.HttpContext.Request.Headers[InertiaHeader.PartialOnly]
+            .ToString()
+            .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+            .Select(s => s.Trim())
+            .Where(s => !string.IsNullOrEmpty(s))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        // Parse the "PARTIAL_EXCEPT" header into a collection of keys to exclude
+        var exceptProps = new HashSet<string>(
+            _context!.HttpContext.Request.Headers[InertiaHeader.PartialExcept]
+                .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 have match on keys
+        var matchPropsOn = _props.Where(o => o.Value is Mergeable mergeable && mergeable.ShouldMerge() && mergeable.GetMatchOn() != null)
+            .Where(kv => !resetProps.Contains(kv.Key)) // Exclude reset keys
+            .Where(kv => onlyProps.Count == 0 || onlyProps.Contains(kv.Key)) // Include only specified keys if any
+            .Where(kv => !exceptProps.Contains(kv.Key)) // Exclude specified keys
+            .Where(kv => resolvedProps.Contains(kv.Key.ToCamelCase())) // Filter only the props that are in the resolved props
+            .ToDictionary(
+                kv => kv.Key.ToCamelCase(), // Convert property name to camelCase
+                kv => ((Mergeable)kv.Value!).GetMatchOn()!
+            );
+
+        if (matchPropsOn.Count == 0)
+        {
+            return null;
+        }
+
+        // Return the result
+        return matchPropsOn;
+    }
+
+    /// <summary>
+    /// Resolve deep merge properties that should be deeply merged with existing values by the front-end.
+    /// </summary>
+    private List<string>? ResolveDeepMergeProps(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
+       );
+
+        // Parse the "PARTIAL_ONLY" header into a collection of keys to include
+        var onlyProps = _context!.HttpContext.Request.Headers[InertiaHeader.PartialOnly]
+            .ToString()
+            .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+            .Select(s => s.Trim())
+            .Where(s => !string.IsNullOrEmpty(s))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        // Parse the "PARTIAL_EXCEPT" header into a collection of keys to exclude
+        var exceptProps = new HashSet<string>(
+            _context!.HttpContext.Request.Headers[InertiaHeader.PartialExcept]
+                .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 DeepMergeable and should be deeply merged
+        var deepMergeProps = _props.Where(o => o.Value is DeepMergeProp deepMergeable && deepMergeable.ShouldDeepMerge()) // Check if value is DeepMergeProp and should deep merge
+            .Where(kv => !resetProps.Contains(kv.Key)) // Exclude reset keys
+            .Where(kv => onlyProps.Count == 0 || onlyProps.Contains(kv.Key)) // Include only specified keys if any
+            .Where(kv => !exceptProps.Contains(kv.Key)) // Exclude specified 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 (deepMergeProps.Count == 0)
+        {
+            return null;
+        }
+
+        // Return the result
+        return deepMergeProps;
+    }
+
     /// <summary>
     /// Resolve all necessary class instances in the given props.
     /// </summary>

InertiaCore/ResponseFactory.cs

@@ -29,6 +29,14 @@ internal interface IResponseFactory
     public AlwaysProp Always(Func<Task<object?>> callback);
     public LazyProp Lazy(Func<object?> callback);
     public LazyProp Lazy(Func<Task<object?>> callback);
+    public MergeProp Merge(object? value);
+    public MergeProp Merge(Func<object?> callback);
+    public MergeProp Merge(Func<Task<object?>> callback);
+    public DeepMergeProp DeepMerge(object? value);
+    public DeepMergeProp DeepMerge(Func<object?> callback);
+    public DeepMergeProp DeepMerge(Func<Task<object?>> callback);
+    public OptionalProp Optional(Func<object?> callback);
+    public OptionalProp Optional(Func<Task<object?>> callback);
 }
 
 internal class ResponseFactory : IResponseFactory
@@ -144,4 +152,12 @@ public void Share(IDictionary<string, object?> data)
     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 MergeProp Merge(object? value) => new(value);
+    public MergeProp Merge(Func<object?> callback) => new(callback);
+    public MergeProp Merge(Func<Task<object?>> callback) => new(callback);
+    public DeepMergeProp DeepMerge(object? value) => new(value);
+    public DeepMergeProp DeepMerge(Func<object?> callback) => new(callback);
+    public DeepMergeProp DeepMerge(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,34 @@
+namespace InertiaCore.Utils;
+
+public interface Mergeable
+{
+    public bool merge { get; set; }
+    public bool deepMerge { get; set; }
+    public string[]? matchOn { get; set; }
+
+    public Mergeable Merge()
+    {
+        merge = true;
+
+        return this;
+    }
+
+    public Mergeable DeepMerge()
+    {
+        deepMerge = true;
+
+        merge = true;
+
+        return this;
+    }
+
+    public Mergeable MatchesOn(params string[] keys)
+    {
+        matchOn = keys;
+        return this;
+    }
+
+    public bool ShouldMerge() => merge;
+    public bool ShouldDeepMerge() => deepMerge;
+    public string[]? GetMatchOn() => matchOn;
+}