Show waiting dependency details in dashboard

src/Aspire.Dashboard/Components/Controls/PropertyValues/ResourceStateDescriptionValue.razor

@@ -0,0 +1,32 @@
+@using Aspire.Dashboard.Utils
+
+@if (_waitingResources.Count == 0)
+{
+    <FluentHighlighter HighlightedText="@HighlightText" Text="@Value" />
+}
+
+else
+{
+    <FluentHighlighter HighlightedText="@HighlightText" Text="@_prefix" />
+    @for (var index = 0; index < _waitingResources.Count; index++)
+    {
+        var waitingResource = _waitingResources[index];
+
+        if (index > 0)
+        {
+            <span>, </span>
+        }
+
+        if (waitingResource.Resource is { } resource)
+        {
+            <FluentAnchor Href="@DashboardUrls.ResourcesUrl(resource: resource.Name)" Appearance="Appearance.Hypertext">
+                <FluentHighlighter HighlightedText="@HighlightText" Text="@waitingResource.DisplayName" />
+            </FluentAnchor>
+        }
+        else
+        {
+            <FluentHighlighter HighlightedText="@HighlightText" Text="@waitingResource.DisplayName" />
+        }
+    }
+    <FluentHighlighter HighlightedText="@HighlightText" Text="@_suffix" />
+}

src/Aspire.Dashboard/Components/Controls/PropertyValues/ResourceStateDescriptionValue.razor.cs

@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Dashboard.Model;
+using Aspire.Dashboard.Resources;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.Localization;
+
+namespace Aspire.Dashboard.Components.Controls.PropertyValues;
+
+public partial class ResourceStateDescriptionValue
+{
+    private const string WaitingResourcePlaceholder = "{0}";
+    private string _prefix = string.Empty;
+    private string _suffix = string.Empty;
+    private List<WaitingResource> _waitingResources = [];
+
+    [Parameter, EditorRequired]
+    public required string Value { get; set; }
+
+    [Parameter, EditorRequired]
+    public required string HighlightText { get; set; }
+
+    [Parameter, EditorRequired]
+    public required ResourceViewModel Resource { get; set; }
+
+    [Parameter, EditorRequired]
+    public required IDictionary<string, ResourceViewModel> ResourceByName { get; set; }
+
+    [Parameter]
+    public bool ShowHiddenResources { get; set; }
+
+    [Inject]
+    public required IStringLocalizer<Columns> Loc { get; init; }
+
+    protected override void OnParametersSet()
+    {
+        _waitingResources = [];
+        _prefix = string.Empty;
+        _suffix = string.Empty;
+
+        if (!Resource.TryGetWaitingForDependencies(out var dependencies))
+        {
+            return;
+        }
+
+        var waitingResourceNames = string.Join(", ", dependencies);
+        if (!TrySplitWaitingForFormat(waitingResourceNames, out _prefix, out _suffix))
+        {
+            return;
+        }
+
+        foreach (var dependency in dependencies)
+        {
+            if (TryGetVisibleResource(dependency, out var resource))
+            {
+                _waitingResources.Add(new WaitingResource(resource, ResourceViewModel.GetResourceName(resource, ResourceByName)));
+            }
+            else
+            {
+                _waitingResources.Add(new WaitingResource(null, dependency));
+            }
+        }
+    }
+
+    private bool TrySplitWaitingForFormat(string waitingResourceNames, out string prefix, out string suffix)
+    {
+        var format = Loc[nameof(Columns.StateColumnResourceWaitingFor)].Value;
+        var placeholderIndex = format.IndexOf(WaitingResourcePlaceholder, StringComparison.Ordinal);
+
+        if (placeholderIndex >= 0)
+        {
+            prefix = format[..placeholderIndex];
+            suffix = format[(placeholderIndex + WaitingResourcePlaceholder.Length)..];
+            return true;
+        }
+
+        var resourceNamesIndex = Value.IndexOf(waitingResourceNames, StringComparison.Ordinal);
+        if (resourceNamesIndex >= 0)
+        {
+            prefix = Value[..resourceNamesIndex];
+            suffix = Value[(resourceNamesIndex + waitingResourceNames.Length)..];
+            return true;
+        }
+
+        prefix = string.Empty;
+        suffix = string.Empty;
+        return false;
+    }
+
+    private bool TryGetVisibleResource(string resourceName, [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out ResourceViewModel? resource)
+    {
+        if (ResourceViewModel.TryGetResourceByName(resourceName, ResourceByName, out resource) && !resource.IsResourceHidden(ShowHiddenResources))
+        {
+            return true;
+        }
+
+        resource = null;
+        return false;
+    }
+
+    private sealed record WaitingResource(ResourceViewModel? Resource, string DisplayName);
+}

src/Aspire.Dashboard/Components/Controls/ResourceDetails.razor.cs

@@ -213,6 +213,16 @@ protected override void OnParametersSet()
                     Type = typeof(ResourceHealthStateValue),
                     Parameters = { ["Resource"] = _resource }
                 },
+                [StateDescriptionPropertyKey] = new ComponentMetadata
+                {
+                    Type = typeof(ResourceStateDescriptionValue),
+                    Parameters =
+                    {
+                        ["Resource"] = _resource,
+                        ["ResourceByName"] = ResourceByName,
+                        ["ShowHiddenResources"] = ShowHiddenResources
+                    }
+                }
             };
 
             // For parameter resources whose value is unset, render the same "Value not set" affordance

src/Aspire.Dashboard/Model/ResourceStateViewModel.cs

@@ -132,6 +132,11 @@ internal static string GetResourceStateTooltip(ResourceViewModel resource, IStri
         }
         else if (resource.IsWaiting())
         {
+            if (resource.TryGetWaitingForDependencies(out var dependencies))
+            {
+                return loc.GetString(nameof(Columns.StateColumnResourceWaitingFor), string.Join(", ", dependencies));
+            }
+
             return loc[nameof(Columns.StateColumnResourceWaiting)];
         }
         else if (resource.IsNotStarted())

src/Aspire.Dashboard/Model/ResourceViewModelExtensions.cs

@@ -99,6 +99,11 @@ public static bool TryGetAppArgsSensitivity(this ResourceViewModel resource, out
         return resource.TryGetCustomDataBoolArray(KnownProperties.Resource.AppArgsSensitivity, out argParams);
     }
 
+    public static bool TryGetWaitingForDependencies(this ResourceViewModel resource, out ImmutableArray<string> dependencies)
+    {
+        return resource.TryGetCustomDataStringArray(KnownProperties.Resource.WaitingFor, out dependencies) && dependencies.Length > 0;
+    }
+
     private static bool TryGetCustomDataString(this ResourceViewModel resource, string key, [NotNullWhen(returnValue: true)] out string? s)
     {
         if (resource.Properties.TryGetValue(key, out var property) && property.Value.TryConvertToString(out var valueString))

src/Aspire.Dashboard/Resources/Columns.resx

@@ -164,4 +164,8 @@ For more information, see https://aka.ms/aspire/container-runtime-unhealthy</val
   <data name="StateColumnResourceWaiting" xml:space="preserve">
     <value>Resource is waiting for other resources to be in a running and healthy state.</value>
   </data>
+  <data name="StateColumnResourceWaitingFor" xml:space="preserve">
+    <value>Waiting for dependencies: {0}.</value>
+    <comment>{0} is a comma-separated list of dependency resource names.</comment>
+  </data>
 </root>