Add 'simple' workaround to TokenizingTextBox AutoSuggestBox Layout Issue

This was an issue with the PlaceholderText ContentControl in the AutoSuggestBox which would not update it's layout properly when the ASB had focus when we would add/remove a token.

Author: michael-hawker

Microsoft.Toolkit.Uwp.UI.Controls/TokenizingTextBox/TokenizingTextBox.cs

@@ -8,6 +8,8 @@
 using System.Threading.Tasks;
 using Microsoft.Toolkit.Uwp.Deferred;
 using Microsoft.Toolkit.Uwp.Extensions;
+using Microsoft.Toolkit.Uwp.UI.Extensions;
+using Microsoft.Toolkit.Uwp.UI.Helpers;
 using Windows.System;
 using Windows.UI.Core;
 using Windows.UI.Xaml;
@@ -435,6 +437,8 @@ internal async Task AddTokenAsync(object data, bool? atEnd = null)
             last?._autoSuggestTextBox.Focus(FocusState.Keyboard);
 
             TokenItemAdded?.Invoke(this, data);
+
+            GuardAgainstPlaceholderTextLayoutIssue();
         }
 
         private void UpdateCurrentTextEdit(PretokenStringContainer edit)
@@ -475,7 +479,34 @@ private async Task<bool> RemoveTokenAsync(TokenizingTextBoxItem item, object dat
 
             TokenItemRemoved?.Invoke(this, data);
 
+            GuardAgainstPlaceholderTextLayoutIssue();
+
             return true;
         }
+
+        private void GuardAgainstPlaceholderTextLayoutIssue()
+        {
+            // If the *PlaceholderText is visible* on the last AutoSuggestBox, it can incorrectly layout itself
+            // when the *ASB has focus*. We think this is an optimization in the platform, but haven't been able to
+            // isolate a straight-reproduction of this issue outside of this control (though we have eliminated
+            // most Toolkit influences like ASB/TextBox Style, the InterspersedObservableCollection, etc...).
+            // The only Toolkit component involved here should be WrapPanel (which is a straight-forward Panel).
+            // We also know the ASB itself is adjusting it's size correctly, it's the inner component.
+            //
+            // To combat this issue:
+            //   We toggle the visibility of the Placeholder ContentControl in order to force it's layout to update properly
+            var placeholder = ContainerFromItem(_lastTextEdit).FindDescendantByName("PlaceholderTextContentPresenter");
+
+            if (placeholder.Visibility == Visibility.Visible)
+            {
+                placeholder.Visibility = Visibility.Collapsed;
+
+                // After we ensure we've hid the control, make it visible again (this is inperceptable to the user).
+                _ = CompositionTargetHelper.ExecuteAfterCompositionRenderingAsync(() =>
+                {
+                    placeholder.Visibility = Visibility.Visible;
+                });
+            }
+        }
     }
 }

Microsoft.Toolkit.Uwp.UI/Helpers/CompositionTargetHelper.cs

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.Toolkit.Diagnostics;
+using Windows.UI.Xaml.Media;
+
+namespace Microsoft.Toolkit.Uwp.UI.Helpers
+{
+    /// <summary>
+    /// Provides helpers for the <see cref="CompositionTarget"/> class.
+    /// </summary>
+    public static class CompositionTargetHelper
+    {
+        /// <summary>
+        /// Provides a method to execute code after the rendering pass is completed.
+        /// <seealso href="https://github.com/microsoft/microsoft-ui-xaml/blob/c045cde57c5c754683d674634a0baccda34d58c4/dev/dll/SharedHelpers.cpp#L399"/>
+        /// </summary>
+        /// <param name="action">Action to be executed after render pass</param>
+        /// <returns>Awaitable Task</returns>
+        public static Task<bool> ExecuteAfterCompositionRenderingAsync(Action action)
+        {
+            Guard.IsNotNull(action, nameof(action));
+
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+
+            try
+            {
+                void Callback(object sender, object args)
+                {
+                    CompositionTarget.Rendering -= Callback;
+
+                    action();
+
+                    taskCompletionSource.SetResult(true);
+                }
+
+                CompositionTarget.Rendering += Callback;
+            }
+            catch (Exception e)
+            {
+                taskCompletionSource.SetException(e); // Note this can just sometimes be a wrong thread exception, see WinUI function notes.
+            }
+
+            return taskCompletionSource.Task;
+        }
+    }
+}