feat: Add Set node to support variable assignment during template rendering

Added the `SetNode` class for defining variables in templates, and implemented the corresponding parsing logic in `TemplateReader`. This allows dynamic variable assignment during template rendering, making variables available to subsequent child nodes, thus improving template flexibility and reusability.

Key changes include:
- Created the `SetNode` record type
- Registered the Set node in the node parsing map
- Implemented the `ParseSetNodeAsync` method to parse Set elements
- Modified `ParseChildrenAsync` to handle Set nodes and update the scope
- Added the `EvaluateSetValueAsync` method for evaluating variable values
- Added the `MergeScope` method for merging scope dictionaries

Author: Yushu2606

src/Render/Nodes/SetNode.cs

@@ -0,0 +1,7 @@
+namespace Limekuma.Render.Nodes;
+
+public sealed record SetNode(
+    string Name,
+    object? Value,
+    string? Key
+) : Node(Key);

src/Render/TemplateReader.NodeParsing.cs

@@ -101,6 +101,12 @@ await EvaluateExpressionAttributeOrAsync(element, "strokeWidth", 0f, scope),
             await EvaluateTemplateAttributeOrAsync(element, "truncateSuffix", string.Empty, scope),
             await EvaluateOptionalSmartTemplateAttributeAsync(element, "key", scope));
 
+    private async Task<Node> ParseSetNodeAsync(XElement element, object? scope) =>
+        new SetNode(
+            GetRequiredAttributeValue(element, "var"),
+            await EvaluateSetValueAsync(GetRequiredAttributeValue(element, "value"), scope),
+            await EvaluateOptionalSmartTemplateAttributeAsync(element, "key", scope));
+
     private async Task<Node> ParseIfNodeAsync(XElement element, object? scope)
     {
         bool pass = await EvaluateRequiredExpressionAsAsync<bool>(GetRequiredAttributeValue(element, "rule"), scope);
@@ -153,21 +159,45 @@ private async Task<string> ResolveIncludePathAsync(XElement element, object? sco
     private async Task<List<Node>> ParseChildrenAsync(XElement element, object? scope)
     {
         List<Node> children = [];
+        object? currentScope = scope;
         foreach (XElement child in element.Elements())
         {
-            children.Add(await ParseElementAsync(child, scope));
+            Node node = await ParseElementAsync(child, currentScope);
+            if (node is SetNode setNode)
+            {
+                currentScope = MergeScope(currentScope, setNode.Name, setNode.Value);
+                continue;
+            }
+
+            children.Add(node);
         }
 
         return children;
     }
 
+    private async Task<object?> EvaluateSetValueAsync(string raw, object? scope)
+    {
+        if (raw.StartsWith("@{", StringComparison.Ordinal) && raw.EndsWith('}'))
+        {
+            return await _expressionEngine.EvalAsync(raw[2..^1], scope);
+        }
+
+        try
+        {
+            return await _expressionEngine.EvalAsync(raw, scope);
+        }
+        catch
+        {
+            return await EvaluateTemplateAsync(raw, scope);
+        }
+    }
+
     private async Task<IEnumerable<object>?> EvaluateCollectionAsync(string expression, object? scope)
     {
         object? rawItems = await _expressionEngine.EvalAsync(expression, scope);
         return rawItems switch
         {
             null => null,
-            string => null,
             IEnumerable<object> objectItems => objectItems,
             IEnumerable enumerable => enumerable.Cast<object>(),
             IConvertible convertible => Enumerable.Range(0, Math.Max(0, Convert.ToInt32(convertible, CultureInfo.InvariantCulture)))
@@ -191,4 +221,19 @@ private async Task<List<Node>> ParseChildrenAsync(XElement element, object? scop
         result[indexName] = index;
         return result;
     }
+
+    private static Dictionary<string, object?> MergeScope(object? parent, string variableName, object? value)
+    {
+        Dictionary<string, object?> result = new(StringComparer.OrdinalIgnoreCase);
+        if (parent is IDictionary<string, object?> map)
+        {
+            foreach ((string key, object? mapValue) in map)
+            {
+                result[key] = mapValue;
+            }
+        }
+
+        result[variableName] = value;
+        return result;
+    }
 }

src/Render/TemplateReader.cs

@@ -30,6 +30,7 @@ public TemplateReader(AsyncNCalcEngine expressionEngine)
             ["Grid"] = ParseGridNodeAsync,
             ["Image"] = ParseImageNodeAsync,
             ["Text"] = ParseTextNodeAsync,
+            ["Set"] = ParseSetNodeAsync,
             ["If"] = ParseIfNodeAsync,
             ["For"] = ParseForNodeAsync,
             ["Include"] = ParseIncludeNodeAsync