feat: add global tree actions to FancyTreeTable

updated readme

Author: SolidProgramming

Components/FancyTreeTable.razor

@@ -6,27 +6,34 @@
 }
 
 <div class="fancy-table-topbar d-flex flex-wrap align-items-center justify-content-between gap-2 mb-2">
-    @if (ShouldRenderPageSizeSelector)
-    {
-        <div class="fancy-page-size">
-            @if (PageSizeTemplate is not null)
-            {
-                @PageSizeTemplate(pagedNodes.Context)
-            }
-            else
-            {
-                <label class="d-inline-flex align-items-center gap-2 small text-muted">
-                    <span>Rows per page</span>
-                    <select class="form-select form-select-sm w-auto" value="@PaginationPageSize" @onchange="OnPageSizeChanged">
-                        @foreach (int option in EffectivePageSizeOptions)
-                        {
-                            <option value="@option">@(option == 0 ? "All" : option.ToString())</option>
-                        }
-                    </select>
-                </label>
-            }
-        </div>
-    }
+    <div class="d-flex flex-wrap align-items-center gap-2">
+        @if (TreeActionsTemplate is not null)
+        {
+            @TreeActionsTemplate(TreeContext)
+        }
+
+        @if (ShouldRenderPageSizeSelector)
+        {
+            <div class="fancy-page-size">
+                @if (PageSizeTemplate is not null)
+                {
+                    @PageSizeTemplate(pagedNodes.Context)
+                }
+                else
+                {
+                    <label class="d-inline-flex align-items-center gap-2 small text-muted">
+                        <span>Rows per page</span>
+                        <select class="form-select form-select-sm w-auto" value="@PaginationPageSize" @onchange="OnPageSizeChanged">
+                            @foreach (int option in EffectivePageSizeOptions)
+                            {
+                                <option value="@option">@(option == 0 ? "All" : option.ToString())</option>
+                            }
+                        </select>
+                    </label>
+                }
+            </div>
+        }
+    </div>
 
     @if (ToolbarTemplate is not null)
     {
@@ -244,6 +251,9 @@
     [Parameter]
     public RenderFragment<FancyPaginationContext<TItem>>? PageSizeTemplate { get; set; }
 
+    [Parameter]
+    public RenderFragment<FancyTreeTableContext<TItem>>? TreeActionsTemplate { get; set; }
+
     private readonly HashSet<string> HiddenColumns = new(StringComparer.Ordinal);
     private readonly Dictionary<TItem, bool> ExpandedStates = new();
     private readonly List<TreeNodeState<TItem>> RootNodes = [];
@@ -263,6 +273,7 @@
     private bool IsPaginationActive => PaginationEnabled && PaginationPageSize > 0;
     private bool ShouldRenderPageSizeSelector => PaginationEnabled && ShowPageSizeSelector;
     private int PaginationPageSize => paginationPageSize > 0 ? paginationPageSize : 0;
+    private FancyTreeTableContext<TItem> TreeContext => BuildTreeContext();
 
     private string CurrentFilter =>
         string.IsNullOrWhiteSpace(AppliedSearchText) ? SearchText : AppliedSearchText;
@@ -457,10 +468,32 @@
     private Task ToggleNodeAsync(TreeNodeState<TItem> node)
     {
         node.IsExpanded = !node.IsExpanded;
-        ExpandedStates[node.Item] = node.IsExpanded;
+        if (node.IsExpanded)
+        {
+            ExpandedStates[node.Item] = true;
+        }
+        else
+        {
+            ExpandedStates.Remove(node.Item);
+        }
+
         return Task.CompletedTask;
     }
 
+    public async Task ExpandAllAsync()
+    {
+        ExpandedStates.Clear();
+        SetExpandedStateForAllNodes(expanded: true);
+        await InvokeAsync(StateHasChanged);
+    }
+
+    public async Task CollapseAllAsync()
+    {
+        ExpandedStates.Clear();
+        SetExpandedStateForAllNodes(expanded: false);
+        await InvokeAsync(StateHasChanged);
+    }
+
     private void HandleSearchKeyPress(KeyboardEventArgs e)
     {
         if (e.Key == "Enter")
@@ -534,6 +567,85 @@
             setPageSizeAsync: SetPageSizeAsync);
     }
 
+    private FancyTreeTableContext<TItem> BuildTreeContext()
+    {
+        TreeNodeStatistics stats = GetTreeNodeStatistics();
+
+        return new FancyTreeTableContext<TItem>(
+            rootItemCount: RootNodes.Count,
+            visibleNodeCount: BuildVisibleNodes().Count,
+            expandedNodeCount: stats.ExpandedNodeCount,
+            hasExpandableNodes: stats.ExpandableNodeCount > 0,
+            canExpandAny: stats.CollapsedExpandableNodeCount > 0,
+            canCollapseAny: stats.ExpandedNodeCount > 0,
+            expandAllAsync: ExpandAllAsync,
+            collapseAllAsync: CollapseAllAsync);
+    }
+
+    private void SetExpandedStateForAllNodes(bool expanded)
+    {
+        foreach (TreeNodeState<TItem> rootNode in RootNodes)
+        {
+            SetExpandedStateRecursive(rootNode, expanded);
+        }
+    }
+
+    private void SetExpandedStateRecursive(TreeNodeState<TItem> node, bool expanded)
+    {
+        if (node.HasChildren)
+        {
+            node.IsExpanded = expanded;
+
+            if (expanded)
+            {
+                ExpandedStates[node.Item] = true;
+            }
+        }
+        else
+        {
+            node.IsExpanded = false;
+        }
+
+        foreach (TreeNodeState<TItem> child in node.Children)
+        {
+            SetExpandedStateRecursive(child, expanded);
+        }
+    }
+
+    private TreeNodeStatistics GetTreeNodeStatistics()
+    {
+        TreeNodeStatistics stats = new();
+
+        foreach (TreeNodeState<TItem> rootNode in RootNodes)
+        {
+            CollectTreeNodeStatistics(rootNode, stats);
+        }
+
+        return stats;
+    }
+
+    private static void CollectTreeNodeStatistics(TreeNodeState<TItem> node, TreeNodeStatistics stats)
+    {
+        if (node.HasChildren)
+        {
+            stats.ExpandableNodeCount++;
+
+            if (node.IsExpanded)
+            {
+                stats.ExpandedNodeCount++;
+            }
+            else
+            {
+                stats.CollapsedExpandableNodeCount++;
+            }
+        }
+
+        foreach (TreeNodeState<TItem> child in node.Children)
+        {
+            CollectTreeNodeStatistics(child, stats);
+        }
+    }
+
     private IReadOnlyList<TreeNodeState<TItem>> ApplyPagination(
         IReadOnlyList<TreeNodeState<TItem>> items,
         FancyPaginationContext<TItem> paginationContext)
@@ -638,6 +750,13 @@
         public required FancyPaginationContext<TItem> Context { get; init; }
     }
 
+    private sealed class TreeNodeStatistics
+    {
+        public int ExpandableNodeCount { get; set; }
+        public int ExpandedNodeCount { get; set; }
+        public int CollapsedExpandableNodeCount { get; set; }
+    }
+
     public void Dispose() => debounceTimer?.Dispose();
 }
 

Components/FancyTreeTableContext.cs

@@ -0,0 +1,35 @@
+public sealed class FancyTreeTableContext<TItem>
+{
+    private readonly Func<Task> expandAllAsync;
+    private readonly Func<Task> collapseAllAsync;
+
+    public FancyTreeTableContext(
+        int rootItemCount,
+        int visibleNodeCount,
+        int expandedNodeCount,
+        bool hasExpandableNodes,
+        bool canExpandAny,
+        bool canCollapseAny,
+        Func<Task> expandAllAsync,
+        Func<Task> collapseAllAsync)
+    {
+        RootItemCount = rootItemCount;
+        VisibleNodeCount = visibleNodeCount;
+        ExpandedNodeCount = expandedNodeCount;
+        HasExpandableNodes = hasExpandableNodes;
+        CanExpandAny = canExpandAny;
+        CanCollapseAny = canCollapseAny;
+        this.expandAllAsync = expandAllAsync;
+        this.collapseAllAsync = collapseAllAsync;
+    }
+
+    public int RootItemCount { get; }
+    public int VisibleNodeCount { get; }
+    public int ExpandedNodeCount { get; }
+    public bool HasExpandableNodes { get; }
+    public bool CanExpandAny { get; }
+    public bool CanCollapseAny { get; }
+
+    public Task ExpandAll() => expandAllAsync();
+    public Task CollapseAll() => collapseAllAsync();
+}

README.md

@@ -36,6 +36,7 @@ https://www.nuget.org/packages/SoPro.FancyTable
 
 ### Hierarchical data
 - Expand/collapse in `FancyTreeTable`
+- Expand all / collapse all via `TreeActionsTemplate` or `@ref`
 - Shared column model across flat and tree tables
 - Search keeps matching nodes and their ancestors visible
 - Configurable child lookup via `ChildItemsSelector`
@@ -89,6 +90,7 @@ https://www.nuget.org/packages/SoPro.FancyTable
 | `HasChildrenSelector` | `Func<TItem, bool>?` | Optional optimization to indicate whether a node should render an expand/collapse toggle |
 | `ExpandLabel` | `string` | Accessible label for collapsed nodes (default: `"Expand"`) |
 | `CollapseLabel` | `string` | Accessible label for expanded nodes (default: `"Collapse"`) |
+| `TreeActionsTemplate` | `RenderFragment<FancyTreeTableContext<TItem>>?` | Renders custom tree-level actions such as expand/collapse all |
 
 ## Row Context
 
@@ -110,6 +112,26 @@ https://www.nuget.org/packages/SoPro.FancyTable
 
 For flat tables, tree-specific values are neutral: `IsTreeNode = false`, `Depth = 0`, `HasChildren = false`, and `ToggleNode` is empty.
 
+## Tree Table Context
+
+`FancyTreeTableContext<TItem>` is passed into `TreeActionsTemplate`.
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `RootItemCount` | `int` | Number of root items in the tree |
+| `VisibleNodeCount` | `int` | Number of currently visible nodes after search and expand/collapse state |
+| `ExpandedNodeCount` | `int` | Number of currently expanded nodes that have children |
+| `HasExpandableNodes` | `bool` | Whether the tree contains any expandable nodes |
+| `CanExpandAny` | `bool` | Whether at least one expandable node is currently collapsed |
+| `CanCollapseAny` | `bool` | Whether at least one expandable node is currently expanded |
+| `ExpandAll()` | `Task` | Expands the entire tree across all levels |
+| `CollapseAll()` | `Task` | Collapses the entire tree across all levels |
+
+`FancyTreeTable<TItem>` also exposes imperative methods for `@ref` usage:
+
+- `ExpandAllAsync()`
+- `CollapseAllAsync()`
+
 ## Pagination Context
 
 `FancyPaginationContext<TItem>` is passed into `PaginationSummaryTemplate`, `PaginationTemplate`, and `PageSizeTemplate`.
@@ -338,18 +360,22 @@ When pagination is enabled, `FancyTable` paginates after search and sorting. `Cu
 @page "/fancy-tree-table-demo"
 
 <FancyTreeTable TItem="RuleRow"
+                @ref="RuleTable"
                 Items="Rules"
                 Columns="RuleColumns"
                 ChildItemsSelector="row => row.Children"
                 HasChildrenSelector="row => row.Children.Count > 0"
                 PaginationEnabled="true"
                 PageSize="5"
                 ShowPageSizeSelector="true"
+                TreeActionsTemplate="RuleTreeActions"
                 RowTemplate="SectionHeaderTemplate"
                 RowTemplateSelector="context => context.Item.IsSectionHeader"
                 SearchPlaceholder="Search rules..." />
 
 @code {
+    private FancyTreeTable<RuleRow>? RuleTable;
+
     private static readonly RuleRow Rule_11_1 = new("11.1", "Allow HTTPS", "TCP", "443", "Any", "Server-A", "Allow", [], false);
     private static readonly RuleRow Rule_11_2 = new("11.2", "Allow DNS", "UDP", "53", "Any", "DNS-1", "Allow", [], false);
     private static readonly RuleRow Rule_11_3 = new("11.3", "Block Telnet", "TCP", "23", "Any", "Any", "Deny", [], false);
@@ -385,11 +411,37 @@ When pagination is enabled, `FancyTable` paginates after search and sorting. `Cu
         </td>
     </tr>;
 
+    private RenderFragment<FancyTreeTableContext<RuleRow>> RuleTreeActions => context => @<div class="d-flex flex-wrap gap-2 align-items-center">
+        <button type="button"
+                class="btn btn-sm btn-outline-primary"
+                disabled="@(!context.CanExpandAny)"
+                @onclick="context.ExpandAll">
+            Expand All
+        </button>
+        <button type="button"
+                class="btn btn-sm btn-outline-secondary"
+                disabled="@(!context.CanCollapseAny)"
+                @onclick="context.CollapseAll">
+            Collapse All
+        </button>
+        <button type="button"
+                class="btn btn-sm btn-outline-dark"
+                disabled="@(RuleTable is null)"
+                @onclick="ExpandViaReferenceAsync">
+            Expand via @ref
+        </button>
+        <span class="small text-muted">
+            @context.VisibleNodeCount visible rows, @context.ExpandedNodeCount expanded nodes
+        </span>
+    </div>;
+
     private void InspectSection(RuleRow row)
     {
         Console.WriteLine($"Inspect section {row.Name}");
     }
 
+    private Task ExpandViaReferenceAsync() => RuleTable?.ExpandAllAsync() ?? Task.CompletedTask;
+
     private sealed record RuleRow(
         string Number,
         string Name,
@@ -403,6 +455,8 @@ When pagination is enabled, `FancyTable` paginates after search and sorting. `Cu
 }
 ```
 
+Global expand/collapse actions always operate on the full tree, not just on the current page or currently visible search results.
+
 ## Tree Search and Sorting Semantics
 
 - Search shows matching nodes and their ancestors, so hits remain visible in context