Create a Microsoft.CmdPal.Core.ViewModels project (#40560)

_targets #40504_ 

Major refactoring for #40113

This moves a large swath of the codebase to a `.Core` project. "Core"
doesn't have any explicit dependencies on "extensions", settings or the
current `MainListPage`. It's just a filterable list of stuff. This
should let us make this component a bit more reusable.

This is half of a PR. As I did this, I noticed a particular bit of code
for TopLevelVViewModels and CommandPaletteHost that was _very rough_.
Solving it in this PR would make "move everything to a new project" much
harder to review. So I'm submitting two PRs simultaneously, so we can
see the changes separately, then merge together.

src/modules/cmdpal/Microsoft.CmdPal.Core.ViewModels/CommandBarViewModel.cs

@@ -0,0 +1,167 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.CmdPal.Core.ViewModels.Messages;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
+
+namespace Microsoft.CmdPal.Core.ViewModels;
+
+public partial class CommandBarViewModel : ObservableObject,
+    IRecipient<UpdateCommandBarMessage>
+{
+    public ICommandBarContext? SelectedItem
+    {
+        get => field;
+        set
+        {
+            if (field != null)
+            {
+                field.PropertyChanged -= SelectedItemPropertyChanged;
+            }
+
+            field = value;
+            SetSelectedItem(value);
+
+            OnPropertyChanged(nameof(SelectedItem));
+        }
+    }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasPrimaryCommand))]
+    public partial CommandItemViewModel? PrimaryCommand { get; set; }
+
+    public bool HasPrimaryCommand => PrimaryCommand != null && PrimaryCommand.ShouldBeVisible;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasSecondaryCommand))]
+    public partial CommandItemViewModel? SecondaryCommand { get; set; }
+
+    public bool HasSecondaryCommand => SecondaryCommand != null;
+
+    [ObservableProperty]
+    public partial bool ShouldShowContextMenu { get; set; } = false;
+
+    [ObservableProperty]
+    public partial PageViewModel? CurrentPage { get; set; }
+
+    public CommandBarViewModel()
+    {
+        WeakReferenceMessenger.Default.Register<UpdateCommandBarMessage>(this);
+    }
+
+    public void Receive(UpdateCommandBarMessage message) => SelectedItem = message.ViewModel;
+
+    private void SetSelectedItem(ICommandBarContext? value)
+    {
+        if (value != null)
+        {
+            PrimaryCommand = value.PrimaryCommand;
+            value.PropertyChanged += SelectedItemPropertyChanged;
+        }
+        else
+        {
+            if (SelectedItem != null)
+            {
+                SelectedItem.PropertyChanged -= SelectedItemPropertyChanged;
+            }
+
+            PrimaryCommand = null;
+        }
+
+        UpdateContextItems();
+    }
+
+    private void SelectedItemPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        switch (e.PropertyName)
+        {
+            case nameof(SelectedItem.HasMoreCommands):
+                UpdateContextItems();
+                break;
+        }
+    }
+
+    private void UpdateContextItems()
+    {
+        if (SelectedItem == null)
+        {
+            SecondaryCommand = null;
+            ShouldShowContextMenu = false;
+            return;
+        }
+
+        SecondaryCommand = SelectedItem.SecondaryCommand;
+
+        ShouldShowContextMenu = SelectedItem.MoreCommands
+            .OfType<CommandContextItemViewModel>()
+            .Count() > 1;
+
+        OnPropertyChanged(nameof(HasSecondaryCommand));
+        OnPropertyChanged(nameof(SecondaryCommand));
+        OnPropertyChanged(nameof(ShouldShowContextMenu));
+    }
+
+    // InvokeItemCommand is what this will be in Xaml due to source generator
+    // this comes in when an item in the list is tapped
+    // [RelayCommand]
+    public ContextKeybindingResult InvokeItem(CommandContextItemViewModel item) =>
+        PerformCommand(item);
+
+    // this comes in when the primary button is tapped
+    public void InvokePrimaryCommand()
+    {
+        PerformCommand(PrimaryCommand);
+    }
+
+    // this comes in when the secondary button is tapped
+    public void InvokeSecondaryCommand()
+    {
+        PerformCommand(SecondaryCommand);
+    }
+
+    public ContextKeybindingResult CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
+    {
+        var keybindings = SelectedItem?.Keybindings();
+        if (keybindings != null)
+        {
+            // Does the pressed key match any of the keybindings?
+            var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
+            if (keybindings.TryGetValue(pressedKeyChord, out var matchedItem))
+            {
+                return matchedItem != null ? PerformCommand(matchedItem) : ContextKeybindingResult.Unhandled;
+            }
+        }
+
+        return ContextKeybindingResult.Unhandled;
+    }
+
+    private ContextKeybindingResult PerformCommand(CommandItemViewModel? command)
+    {
+        if (command == null)
+        {
+            return ContextKeybindingResult.Unhandled;
+        }
+
+        if (command.HasMoreCommands)
+        {
+            return ContextKeybindingResult.KeepOpen;
+        }
+        else
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(command.Command.Model, command.Model));
+            return ContextKeybindingResult.Hide;
+        }
+    }
+}
+
+public enum ContextKeybindingResult
+{
+    Unhandled,
+    Hide,
+    KeepOpen,
+}