From 8e1c00312c48ce57c11345f9381b5030ce6c2dbe Mon Sep 17 00:00:00 2001
From: Ionite <dev@ionite.io>
Date: Wed, 10 Apr 2024 21:53:59 -0400
Subject: [PATCH 1/6] Add Inference prompt help tooltip

---
 .../Controls/Inference/PromptCard.axaml       | 30 ++++++++++++-------
 .../Controls/Inference/PromptCard.axaml.cs    |  2 +-
 .../Languages/Resources.Designer.cs           |  9 ++++++
 .../Languages/Resources.resx                  |  3 ++
 .../Inference/PromptCardViewModel.cs          | 30 +++++++++++++++++++
 .../Models/Settings/TeachingTip.cs            |  1 +
 6 files changed, 64 insertions(+), 11 deletions(-)

diff --git a/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml b/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml
index 7c53337d..12423e48 100644
--- a/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml
+++ b/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml
@@ -8,6 +8,8 @@
     xmlns:icons="clr-namespace:Projektanker.Icons.Avalonia;assembly=Projektanker.Icons.Avalonia"
     xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
     xmlns:vmInference="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Inference"
+    xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+    xmlns:lang="clr-namespace:StabilityMatrix.Avalonia.Languages"
     x:DataType="vmInference:PromptCardViewModel">
     <Design.PreviewWith>
         <Grid Width="460" Height="600">
@@ -56,21 +58,29 @@
                                 HorizontalAlignment="Right"
                                 Orientation="Horizontal">
 
-                                <Button
-                                    Margin="0,-2,0,0"
-                                    Padding="10,4"
-                                    VerticalAlignment="Top"
-                                    VerticalContentAlignment="Top"
-                                    icons:Attached.Icon="fa-solid fa-question"
-                                    Classes="transparent-full"
-                                    Command="{Binding ShowHelpDialogCommand}" />
-
+                                <Panel>
+                                    <Button
+                                        x:Name="PART_HelpButton"
+                                        Margin="0,-2,0,0"
+                                        Padding="10,4"
+                                        VerticalAlignment="Top"
+                                        VerticalContentAlignment="Top"
+                                        icons:Attached.Icon="fa-solid fa-question"
+                                        Classes="transparent-full"
+                                        Command="{Binding ShowHelpDialogCommand}" />
+                                    
+                                    <ui:TeachingTip 
+                                        Target="{Binding #PART_HelpButton}"
+                                        Title="{x:Static lang:Resources.TeachingTip_InferencePromptHelpButton}"
+                                        IsOpen="{Binding IsHelpButtonTeachingTipOpen}"/>
+                                </Panel>
+                                
                                 <Button
                                     Padding="8,4"
                                     Command="{Binding DebugShowTokensCommand}"
                                     Content="Show Tokens"
                                     IsVisible="{Binding SharedState.IsDebugMode}" />
-
+                                
                             </StackPanel>
 
                             <Border
diff --git a/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml.cs b/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml.cs
index f5a79dcb..4b874d17 100644
--- a/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml.cs
+++ b/StabilityMatrix.Avalonia/Controls/Inference/PromptCard.axaml.cs
@@ -12,7 +12,7 @@ using StabilityMatrix.Core.Attributes;
 namespace StabilityMatrix.Avalonia.Controls;
 
 [Transient]
-public class PromptCard : TemplatedControl
+public class PromptCard : TemplatedControlBase
 {
     /// <inheritdoc />
     protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
diff --git a/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs b/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs
index 388037ce..e38cda20 100644
--- a/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs
+++ b/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs
@@ -2795,6 +2795,15 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Click here to review prompt syntax and how to include Lora / Embeddings..
+        /// </summary>
+        public static string TeachingTip_InferencePromptHelpButton {
+            get {
+                return ResourceManager.GetString("TeachingTip_InferencePromptHelpButton", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Additional folders such as IPAdapters and TextualInversions (embeddings) can be enabled here.
         /// </summary>
diff --git a/StabilityMatrix.Avalonia/Languages/Resources.resx b/StabilityMatrix.Avalonia/Languages/Resources.resx
index 4c70a20c..ee360cb1 100644
--- a/StabilityMatrix.Avalonia/Languages/Resources.resx
+++ b/StabilityMatrix.Avalonia/Languages/Resources.resx
@@ -1068,4 +1068,7 @@
   <data name="Label_WorkflowImportComplete" xml:space="preserve">
     <value>The workflow and custom nodes have been imported.</value>
   </data>
+  <data name="TeachingTip_InferencePromptHelpButton" xml:space="preserve">
+    <value>Click here to review prompt syntax and how to include Lora / Embeddings.</value>
+  </data>
 </root>
diff --git a/StabilityMatrix.Avalonia/ViewModels/Inference/PromptCardViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/Inference/PromptCardViewModel.cs
index d4a2b895..919e4e30 100644
--- a/StabilityMatrix.Avalonia/ViewModels/Inference/PromptCardViewModel.cs
+++ b/StabilityMatrix.Avalonia/ViewModels/Inference/PromptCardViewModel.cs
@@ -20,6 +20,7 @@ using StabilityMatrix.Core.Exceptions;
 using StabilityMatrix.Core.Helper.Cache;
 using StabilityMatrix.Core.Models;
 using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
+using StabilityMatrix.Core.Models.Settings;
 using StabilityMatrix.Core.Services;
 
 namespace StabilityMatrix.Avalonia.ViewModels.Inference;
@@ -30,6 +31,7 @@ namespace StabilityMatrix.Avalonia.ViewModels.Inference;
 public partial class PromptCardViewModel : LoadableViewModelBase, IParametersLoadableState, IComfyStep
 {
     private readonly IModelIndexService modelIndexService;
+    private readonly ISettingsManager settingsManager;
 
     /// <summary>
     /// Cache of prompt text to tokenized Prompt
@@ -48,6 +50,9 @@ public partial class PromptCardViewModel : LoadableViewModelBase, IParametersLoa
     [ObservableProperty]
     private bool isAutoCompletionEnabled;
 
+    [ObservableProperty]
+    private bool isHelpButtonTeachingTipOpen;
+
     /// <inheritdoc />
     public PromptCardViewModel(
         ICompletionProvider completionProvider,
@@ -59,6 +64,7 @@ public partial class PromptCardViewModel : LoadableViewModelBase, IParametersLoa
     )
     {
         this.modelIndexService = modelIndexService;
+        this.settingsManager = settingsManager;
         CompletionProvider = completionProvider;
         TokenizerProvider = tokenizerProvider;
         SharedState = sharedState;
@@ -77,6 +83,30 @@ public partial class PromptCardViewModel : LoadableViewModelBase, IParametersLoa
         );
     }
 
+    partial void OnIsHelpButtonTeachingTipOpenChanging(bool oldValue, bool newValue)
+    {
+        // If the teaching tip is being closed, save the setting
+        if (oldValue && !newValue)
+        {
+            settingsManager.Transaction(settings =>
+            {
+                settings.SeenTeachingTips.Add(TeachingTip.InferencePromptHelpButtonTip);
+            });
+        }
+    }
+
+    /// <inheritdoc />
+    public override void OnLoaded()
+    {
+        base.OnLoaded();
+
+        // Show teaching tip for help button if not seen
+        if (!settingsManager.Settings.SeenTeachingTips.Contains(TeachingTip.InferencePromptHelpButtonTip))
+        {
+            IsHelpButtonTeachingTipOpen = true;
+        }
+    }
+
     /// <summary>
     /// Applies the prompt step.
     /// Requires:
diff --git a/StabilityMatrix.Core/Models/Settings/TeachingTip.cs b/StabilityMatrix.Core/Models/Settings/TeachingTip.cs
index 92a6ea3d..d69595c7 100644
--- a/StabilityMatrix.Core/Models/Settings/TeachingTip.cs
+++ b/StabilityMatrix.Core/Models/Settings/TeachingTip.cs
@@ -14,6 +14,7 @@ public record TeachingTip(string Value) : StringValue(Value)
     public static TeachingTip PackageExtensionsInstallNotice => new("PackageExtensionsInstallNotice");
     public static TeachingTip DownloadsTip => new("DownloadsTip");
     public static TeachingTip WebUiButtonMovedTip => new("WebUiButtonMovedTip");
+    public static TeachingTip InferencePromptHelpButtonTip => new("InferencePromptHelpButtonTip");
 
     /// <inheritdoc />
     public override string ToString()

From 04e5459f756ed4e021cc0cf2da67e832fec346cc Mon Sep 17 00:00:00 2001
From: Ionite <dev@ionite.io>
Date: Wed, 10 Apr 2024 21:56:10 -0400
Subject: [PATCH 2/6] Add layer diffuse changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 14157ffd..546b1b81 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning 2.0](https://semver.org/spec/v2
 - Added Reference-Only mode for Inference ControlNet, used for guiding the sampler with an image without a pretrained model. Part of the latent and attention layers will be connected to the reference image, similar to Image to Image or Inpainting.
 - Inference ControlNet module now supports over 42 preprocessors, a new button next to the preprocessors dropdown allows previewing the output of the selected preprocessor on the image.
 - Added resolution selection for Inference ControlNet module, this controls preprocessor resolution too.
+- Added Layer Diffuse sampler addon to Inference, allows generating foreground with transparency with SD1.5 and SDXL.
 - Added support for deep links from the new Stability Matrix Chrome extension
 - Added OpenArt.AI workflow browser for ComfyUI workflows
 - Added more metadata to the image dialog info flyout

From 38a104146f193a50df1aebd9c6808e8fec0d0cd0 Mon Sep 17 00:00:00 2001
From: Ionite <dev@ionite.io>
Date: Wed, 10 Apr 2024 23:19:44 -0400
Subject: [PATCH 3/6] Add vendored labs controls to fix asyncimage

---
 .../AsyncImage/AsyncImageFailedEventArgs.cs   |  20 +
 .../AsyncImage/BetterAsyncImage.Events.cs     |  42 ++
 .../AsyncImage/BetterAsyncImage.Properties.cs | 135 +++++
 .../VendorLabs/AsyncImage/BetterAsyncImage.cs | 248 ++++++++
 .../Controls/VendorLabs/Cache/CacheBase.cs    | 565 ++++++++++++++++++
 .../Controls/VendorLabs/Cache/CacheOptions.cs |  18 +
 .../Controls/VendorLabs/Cache/FileCache.cs    |  36 ++
 .../Controls/VendorLabs/Cache/ImageCache.cs   |  76 +++
 .../VendorLabs/Cache/InMemoryStorage.cs       | 156 +++++
 .../VendorLabs/Cache/InMemoryStorageItem.cs   |  49 ++
 .../Controls/VendorLabs/LICENSE               |  21 +
 ...tabilityMatrix.Avalonia.csproj.DotSettings |   3 +-
 12 files changed, 1368 insertions(+), 1 deletion(-)
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/AsyncImageFailedEventArgs.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Events.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Properties.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheBase.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheOptions.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/FileCache.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/ImageCache.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorage.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorageItem.cs
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/LICENSE

diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/AsyncImageFailedEventArgs.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/AsyncImageFailedEventArgs.cs
new file mode 100644
index 00000000..b236c348
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/AsyncImageFailedEventArgs.cs
@@ -0,0 +1,20 @@
+using System;
+using Avalonia.Interactivity;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs;
+
+public partial class BetterAsyncImage
+{
+    public class AsyncImageFailedEventArgs : RoutedEventArgs
+    {
+        internal AsyncImageFailedEventArgs(Exception? errorException = null, string errorMessage = "")
+            : base(FailedEvent)
+        {
+            ErrorException = errorException;
+            ErrorMessage = errorMessage;
+        }
+
+        public Exception? ErrorException { get; private set; }
+        public string ErrorMessage { get; private set; }
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Events.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Events.cs
new file mode 100644
index 00000000..3219a46d
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Events.cs
@@ -0,0 +1,42 @@
+using System;
+using Avalonia.Interactivity;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs;
+
+public partial class BetterAsyncImage
+{
+    /// <summary>
+    /// Deines the <see cref="Opened"/> event
+    /// </summary>
+    public static readonly RoutedEvent<RoutedEventArgs> OpenedEvent = RoutedEvent.Register<
+        BetterAsyncImage,
+        RoutedEventArgs
+    >(nameof(Opened), RoutingStrategies.Bubble);
+
+    /// <summary>
+    /// Deines the <see cref="Failed"/> event
+    /// </summary>
+    public static readonly RoutedEvent<global::Avalonia.Labs.Controls.AsyncImage.AsyncImageFailedEventArgs> FailedEvent =
+        RoutedEvent.Register<
+            BetterAsyncImage,
+            global::Avalonia.Labs.Controls.AsyncImage.AsyncImageFailedEventArgs
+        >(nameof(Failed), RoutingStrategies.Bubble);
+
+    /// <summary>
+    /// Occurs when the image is successfully loaded.
+    /// </summary>
+    public event EventHandler<RoutedEventArgs>? Opened
+    {
+        add => AddHandler(OpenedEvent, value);
+        remove => RemoveHandler(OpenedEvent, value);
+    }
+
+    /// <summary>
+    /// Occurs when the image fails to load the uri provided.
+    /// </summary>
+    public event EventHandler<global::Avalonia.Labs.Controls.AsyncImage.AsyncImageFailedEventArgs>? Failed
+    {
+        add => AddHandler(FailedEvent, value);
+        remove => RemoveHandler(FailedEvent, value);
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Properties.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Properties.cs
new file mode 100644
index 00000000..c31f00aa
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.Properties.cs
@@ -0,0 +1,135 @@
+using System;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Labs.Controls;
+using Avalonia.Media;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs;
+
+public partial class BetterAsyncImage
+{
+    /// <summary>
+    /// Defines the <see cref="PlaceholderSource"/> property.
+    /// </summary>
+    public static readonly StyledProperty<IImage?> PlaceholderSourceProperty = AvaloniaProperty.Register<
+        BetterAsyncImage,
+        IImage?
+    >(nameof(PlaceholderSource));
+
+    /// <summary>
+    /// Defines the <see cref="Source"/> property.
+    /// </summary>
+    public static readonly StyledProperty<Uri?> SourceProperty = AvaloniaProperty.Register<
+        BetterAsyncImage,
+        Uri?
+    >(nameof(Source));
+
+    /// <summary>
+    /// Defines the <see cref="Stretch"/> property.
+    /// </summary>
+    public static readonly StyledProperty<Stretch> StretchProperty = AvaloniaProperty.Register<
+        BetterAsyncImage,
+        Stretch
+    >(nameof(Stretch), Stretch.Uniform);
+
+    /// <summary>
+    /// Defines the <see cref="PlaceholderStretch"/> property.
+    /// </summary>
+    public static readonly StyledProperty<Stretch> PlaceholderStretchProperty = AvaloniaProperty.Register<
+        BetterAsyncImage,
+        Stretch
+    >(nameof(PlaceholderStretch), Stretch.Uniform);
+
+    /// <summary>
+    /// Defines the <see cref="State"/> property.
+    /// </summary>
+    public static readonly DirectProperty<BetterAsyncImage, AsyncImageState> StateProperty =
+        AvaloniaProperty.RegisterDirect<BetterAsyncImage, AsyncImageState>(
+            nameof(State),
+            o => o.State,
+            (o, v) => o.State = v
+        );
+
+    /// <summary>
+    /// Defines the <see cref="ImageTransition"/> property.
+    /// </summary>
+    public static readonly StyledProperty<IPageTransition?> ImageTransitionProperty =
+        AvaloniaProperty.Register<BetterAsyncImage, IPageTransition?>(
+            nameof(ImageTransition),
+            new CrossFade(TimeSpan.FromSeconds(0.25))
+        );
+
+    /// <summary>
+    /// Defines the <see cref="IsCacheEnabled"/> property.
+    /// </summary>
+    public static readonly DirectProperty<BetterAsyncImage, bool> IsCacheEnabledProperty =
+        AvaloniaProperty.RegisterDirect<BetterAsyncImage, bool>(
+            nameof(IsCacheEnabled),
+            o => o.IsCacheEnabled,
+            (o, v) => o.IsCacheEnabled = v
+        );
+    private bool _isCacheEnabled;
+
+    /// <summary>
+    /// Gets or sets the placeholder image.
+    /// </summary>
+    public IImage? PlaceholderSource
+    {
+        get => GetValue(PlaceholderSourceProperty);
+        set => SetValue(PlaceholderSourceProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the uri pointing to the image resource
+    /// </summary>
+    public Uri? Source
+    {
+        get => GetValue(SourceProperty);
+        set => SetValue(SourceProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets a value controlling how the image will be stretched.
+    /// </summary>
+    public Stretch Stretch
+    {
+        get { return GetValue(StretchProperty); }
+        set { SetValue(StretchProperty, value); }
+    }
+
+    /// <summary>
+    /// Gets or sets a value controlling how the placeholder will be stretched.
+    /// </summary>
+    public Stretch PlaceholderStretch
+    {
+        get { return GetValue(StretchProperty); }
+        set { SetValue(StretchProperty, value); }
+    }
+
+    /// <summary>
+    /// Gets the current loading state of the image.
+    /// </summary>
+    public AsyncImageState State
+    {
+        get => _state;
+        private set => SetAndRaise(StateProperty, ref _state, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the transition to run when the image is loaded.
+    /// </summary>
+    public IPageTransition? ImageTransition
+    {
+        get => GetValue(ImageTransitionProperty);
+        set => SetValue(ImageTransitionProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets whether to use cache for retrieved images
+    /// </summary>
+    public bool IsCacheEnabled
+    {
+        get => _isCacheEnabled;
+        set => SetAndRaise(IsCacheEnabledProperty, ref _isCacheEnabled, value);
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.cs
new file mode 100644
index 00000000..ec0cfa54
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/AsyncImage/BetterAsyncImage.cs
@@ -0,0 +1,248 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Metadata;
+using Avalonia.Controls.Primitives;
+using Avalonia.Interactivity;
+using Avalonia.Labs.Controls;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Threading;
+using StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs;
+
+/// <summary>
+/// An image control that asynchronously retrieves an image using a <see cref="Uri"/>.
+/// </summary>
+[TemplatePart("PART_Image", typeof(Image))]
+[TemplatePart("PART_PlaceholderImage", typeof(Image))]
+public partial class BetterAsyncImage : TemplatedControl
+{
+    protected Image? ImagePart { get; private set; }
+    protected Image? PlaceholderPart { get; private set; }
+
+    private bool _isInitialized;
+    private CancellationTokenSource? _tokenSource;
+    private AsyncImageState _state;
+
+    protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+    {
+        base.OnApplyTemplate(e);
+
+        ImagePart = e.NameScope.Get<Image>("PART_Image");
+        PlaceholderPart = e.NameScope.Get<Image>("PART_PlaceholderImage");
+
+        _tokenSource = new CancellationTokenSource();
+
+        _isInitialized = true;
+
+        if (Source != null)
+        {
+            SetSource(Source);
+        }
+    }
+
+    private async void SetSource(object? source)
+    {
+        if (!_isInitialized)
+        {
+            return;
+        }
+
+        _tokenSource?.Cancel();
+
+        _tokenSource = new CancellationTokenSource();
+
+        AttachSource(null);
+
+        if (source == null)
+        {
+            return;
+        }
+
+        State = AsyncImageState.Loading;
+
+        if (Source is IImage image)
+        {
+            AttachSource(image);
+
+            return;
+        }
+
+        if (Source == null)
+        {
+            return;
+        }
+
+        var uri = Source;
+
+        if (uri != null && uri.IsAbsoluteUri)
+        {
+            if (uri.Scheme == "http" || uri.Scheme == "https")
+            {
+                Bitmap? bitmap = null;
+                // Android doesn't allow network requests on the main thread, even though we are using async apis.
+#if NET6_0_OR_GREATER
+                if (OperatingSystem.IsAndroid())
+                {
+                    await Task.Run(async () =>
+                    {
+                        try
+                        {
+                            bitmap = await LoadImageAsync(uri, _tokenSource.Token);
+                        }
+                        catch (Exception ex)
+                        {
+                            await Dispatcher.UIThread.InvokeAsync(() =>
+                            {
+                                State = AsyncImageState.Failed;
+
+                                RaiseEvent(new AsyncImageFailedEventArgs(ex));
+                            });
+                        }
+                    });
+                }
+                else
+#endif
+                {
+                    try
+                    {
+                        bitmap = await LoadImageAsync(uri, _tokenSource.Token);
+                    }
+                    catch (Exception ex)
+                    {
+                        await Dispatcher.UIThread.InvokeAsync(() =>
+                        {
+                            State = AsyncImageState.Failed;
+
+                            RaiseEvent(new AsyncImageFailedEventArgs(ex));
+                        });
+                    }
+                }
+
+                AttachSource(bitmap);
+            }
+            else if (uri.Scheme == "avares")
+            {
+                try
+                {
+                    AttachSource(new Bitmap(AssetLoader.Open(uri)));
+                }
+                catch (Exception ex)
+                {
+                    State = AsyncImageState.Failed;
+
+                    RaiseEvent(new AsyncImageFailedEventArgs(ex));
+                }
+            }
+            else if (uri.Scheme == "file" && File.Exists(uri.LocalPath))
+            {
+                // Added error handling here for local files
+                try
+                {
+                    AttachSource(new Bitmap(uri.LocalPath));
+                }
+                catch (Exception ex)
+                {
+                    State = AsyncImageState.Failed;
+
+                    RaiseEvent(new AsyncImageFailedEventArgs(ex));
+                }
+            }
+            else
+            {
+                RaiseEvent(
+                    new AsyncImageFailedEventArgs(
+                        new UriFormatException($"Uri has unsupported scheme. Uri:{source}")
+                    )
+                );
+            }
+        }
+        else
+        {
+            RaiseEvent(
+                new AsyncImageFailedEventArgs(
+                    new UriFormatException($"Relative paths aren't supported. Uri:{source}")
+                )
+            );
+        }
+    }
+
+    private void AttachSource(IImage? image)
+    {
+        if (ImagePart != null)
+        {
+            ImagePart.Source = image;
+        }
+
+        _tokenSource?.Cancel();
+        _tokenSource = new CancellationTokenSource();
+
+        if (image == null)
+        {
+            State = AsyncImageState.Unloaded;
+
+            ImageTransition?.Start(ImagePart, PlaceholderPart, true, _tokenSource.Token);
+        }
+        else if (image.Size != default)
+        {
+            State = AsyncImageState.Loaded;
+
+            ImageTransition?.Start(PlaceholderPart, ImagePart, true, _tokenSource.Token);
+
+            RaiseEvent(new RoutedEventArgs(OpenedEvent));
+        }
+    }
+
+    private async Task<Bitmap> LoadImageAsync(Uri? url, CancellationToken token)
+    {
+        if (await ProvideCachedResourceAsync(url, token) is { } bitmap)
+        {
+            return bitmap;
+        }
+#if NET6_0_OR_GREATER
+        using var client = new HttpClient();
+        var stream = await client.GetStreamAsync(url, token).ConfigureAwait(false);
+
+        await using var memoryStream = new MemoryStream();
+        await stream.CopyToAsync(memoryStream, token).ConfigureAwait(false);
+#elif NETSTANDARD2_0
+        using var client = new HttpClient();
+        var response = await client.GetAsync(url, token).ConfigureAwait(false);
+        var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
+
+        using var memoryStream = new MemoryStream();
+        await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
+#endif
+
+        memoryStream.Position = 0;
+        return new Bitmap(memoryStream);
+    }
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == SourceProperty)
+        {
+            SetSource(Source);
+        }
+    }
+
+    protected virtual async Task<Bitmap?> ProvideCachedResourceAsync(Uri? imageUri, CancellationToken token)
+    {
+        if (IsCacheEnabled && imageUri != null)
+        {
+            return await ImageCache
+                .Instance.GetFromCacheAsync(imageUri, cancellationToken: token)
+                .ConfigureAwait(false);
+        }
+        return null;
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheBase.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheBase.cs
new file mode 100644
index 00000000..a4604082
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheBase.cs
@@ -0,0 +1,565 @@
+// Parts of this file was taken from Windows Community Toolkit CacheBase implementation
+// https://github.com/CommunityToolkit/WindowsCommunityToolkit/blob/main/Microsoft.Toolkit.Uwp.UI/Cache/ImageCache.cs
+
+// 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.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+internal abstract class CacheBase<T>
+{
+    private class ConcurrentRequest
+    {
+        public Task<T?>? Task { get; set; }
+
+        public bool EnsureCachedCopy { get; set; }
+    }
+
+    private readonly SemaphoreSlim _cacheFolderSemaphore = new SemaphoreSlim(1);
+    private string? _baseFolder = null;
+    private string? _cacheFolderName = null;
+
+    private string? _cacheFolder = null;
+    private InMemoryStorage<T>? _inMemoryFileStorage = null;
+
+    private ConcurrentDictionary<string, ConcurrentRequest> _concurrentTasks =
+        new ConcurrentDictionary<string, ConcurrentRequest>();
+
+    private HttpClient? _httpClient = null;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CacheBase{T}"/> class.
+    /// </summary>
+    protected CacheBase()
+    {
+        var options = CacheOptions.Default;
+        CacheDuration = options?.CacheDuration ?? TimeSpan.FromDays(1);
+        _baseFolder = options?.BaseCachePath ?? null;
+        _inMemoryFileStorage = new InMemoryStorage<T>();
+        RetryCount = 1;
+    }
+
+    /// <summary>
+    /// Gets or sets the life duration of every cache entry.
+    /// </summary>
+    public TimeSpan CacheDuration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of retries trying to ensure the file is cached.
+    /// </summary>
+    public uint RetryCount { get; set; }
+
+    /// <summary>
+    /// Gets or sets max in-memory item storage count
+    /// </summary>
+    public int MaxMemoryCacheCount
+    {
+        get { return _inMemoryFileStorage?.MaxItemCount ?? 0; }
+        set
+        {
+            if (_inMemoryFileStorage != null)
+                _inMemoryFileStorage.MaxItemCount = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets instance of <see cref="HttpClient"/>
+    /// </summary>
+    protected HttpClient HttpClient
+    {
+        get
+        {
+            if (_httpClient == null)
+            {
+                var messageHandler = new HttpClientHandler();
+
+                _httpClient = new HttpClient(messageHandler);
+            }
+
+            return _httpClient;
+        }
+    }
+
+    /// <summary>
+    /// Initializes FileCache and provides root folder and cache folder name
+    /// </summary>
+    /// <param name="folder">Folder that is used as root for cache</param>
+    /// <param name="folderName">Cache folder name</param>
+    /// <param name="httpMessageHandler">instance of <see cref="HttpMessageHandler"/></param>
+    /// <returns>awaitable task</returns>
+    public virtual async Task InitializeAsync(
+        string? folder = null,
+        string? folderName = null,
+        HttpMessageHandler? httpMessageHandler = null
+    )
+    {
+        _baseFolder = folder;
+        _cacheFolderName = folderName;
+
+        _cacheFolder = await GetCacheFolderAsync().ConfigureAwait(false);
+
+        if (httpMessageHandler != null)
+        {
+            _httpClient = new HttpClient(httpMessageHandler);
+        }
+    }
+
+    /// <summary>
+    /// Clears all files in the cache
+    /// </summary>
+    /// <returns>awaitable task</returns>
+    public async Task ClearAsync()
+    {
+        var folder = await GetCacheFolderAsync().ConfigureAwait(false);
+        var files = Directory.EnumerateFiles(folder!);
+
+        await InternalClearAsync(files.Select(x => x as string)).ConfigureAwait(false);
+
+        _inMemoryFileStorage?.Clear();
+    }
+
+    /// <summary>
+    /// Clears file if it has expired
+    /// </summary>
+    /// <param name="duration">timespan to compute whether file has expired or not</param>
+    /// <returns>awaitable task</returns>
+    public Task ClearAsync(TimeSpan duration)
+    {
+        return RemoveExpiredAsync(duration);
+    }
+
+    /// <summary>
+    /// Removes cached files that have expired
+    /// </summary>
+    /// <param name="duration">Optional timespan to compute whether file has expired or not. If no value is supplied, <see cref="CacheDuration"/> is used.</param>
+    /// <returns>awaitable task</returns>
+    public async Task RemoveExpiredAsync(TimeSpan? duration = null)
+    {
+        TimeSpan expiryDuration = duration ?? CacheDuration;
+
+        var folder = await GetCacheFolderAsync().ConfigureAwait(false);
+        var files = Directory.EnumerateFiles(folder!);
+
+        var filesToDelete = new List<string>();
+
+        foreach (var file in files)
+        {
+            if (file == null)
+            {
+                continue;
+            }
+
+            if (await IsFileOutOfDateAsync(file, expiryDuration, false).ConfigureAwait(false))
+            {
+                filesToDelete.Add(file);
+            }
+        }
+
+        await InternalClearAsync(filesToDelete).ConfigureAwait(false);
+
+        _inMemoryFileStorage?.Clear(expiryDuration);
+    }
+
+    /// <summary>
+    /// Removed items based on uri list passed
+    /// </summary>
+    /// <param name="uriForCachedItems">Enumerable uri list</param>
+    /// <returns>awaitable Task</returns>
+    public async Task RemoveAsync(IEnumerable<Uri> uriForCachedItems)
+    {
+        if (uriForCachedItems == null || !uriForCachedItems.Any())
+        {
+            return;
+        }
+
+        var folder = await GetCacheFolderAsync().ConfigureAwait(false);
+        var files = Directory.EnumerateFiles(folder!);
+        var filesToDelete = new List<string>();
+        var keys = new List<string>();
+
+        Dictionary<string, string> hashDictionary = new Dictionary<string, string>();
+
+        foreach (var file in files)
+        {
+            hashDictionary.Add(Path.GetFileName(file), file);
+        }
+
+        foreach (var uri in uriForCachedItems)
+        {
+            string fileName = GetCacheFileName(uri);
+            if (hashDictionary.TryGetValue(fileName, out var file))
+            {
+                filesToDelete.Add(file);
+                keys.Add(fileName);
+            }
+        }
+
+        await InternalClearAsync(filesToDelete).ConfigureAwait(false);
+
+        _inMemoryFileStorage?.Remove(keys);
+    }
+
+    /// <summary>
+    /// Assures that item represented by Uri is cached.
+    /// </summary>
+    /// <param name="uri">Uri of the item</param>
+    /// <param name="throwOnError">Indicates whether or not exception should be thrown if item cannot be cached</param>
+    /// <param name="storeToMemoryCache">Indicates if item should be loaded into the in-memory storage</param>
+    /// <param name="cancellationToken">instance of <see cref="CancellationToken"/></param>
+    /// <returns>Awaitable Task</returns>
+    public Task PreCacheAsync(
+        Uri uri,
+        bool throwOnError = false,
+        bool storeToMemoryCache = false,
+        CancellationToken cancellationToken = default(CancellationToken)
+    )
+    {
+        return GetItemAsync(uri, throwOnError, !storeToMemoryCache, cancellationToken);
+    }
+
+    /// <summary>
+    /// Retrieves item represented by Uri from the cache. If the item is not found in the cache, it will try to downloaded and saved before returning it to the caller.
+    /// </summary>
+    /// <param name="uri">Uri of the item.</param>
+    /// <param name="throwOnError">Indicates whether or not exception should be thrown if item cannot be found / downloaded.</param>
+    /// <param name="cancellationToken">instance of <see cref="CancellationToken"/></param>
+    /// <returns>an instance of Generic type</returns>
+    public Task<T?> GetFromCacheAsync(
+        Uri uri,
+        bool throwOnError = false,
+        CancellationToken cancellationToken = default(CancellationToken)
+    )
+    {
+        return GetItemAsync(uri, throwOnError, false, cancellationToken);
+    }
+
+    /// <summary>
+    /// Gets the string containing cached item for given Uri
+    /// </summary>
+    /// <param name="uri">Uri of the item.</param>
+    /// <returns>a string</returns>
+    public async Task<string> GetFileFromCacheAsync(Uri uri)
+    {
+        var folder = await GetCacheFolderAsync().ConfigureAwait(false);
+
+        return Path.Combine(folder!, GetCacheFileName(uri));
+    }
+
+    /// <summary>
+    /// Retrieves item represented by Uri from the in-memory cache if it exists and is not out of date. If item is not found or is out of date, default instance of the generic type is returned.
+    /// </summary>
+    /// <param name="uri">Uri of the item.</param>
+    /// <returns>an instance of Generic type</returns>
+    public T? GetFromMemoryCache(Uri uri)
+    {
+        T? instance = default(T);
+
+        string fileName = GetCacheFileName(uri);
+
+        if (_inMemoryFileStorage?.MaxItemCount > 0)
+        {
+            var msi = _inMemoryFileStorage?.GetItem(fileName, CacheDuration);
+            if (msi != null)
+            {
+                instance = msi.Item;
+            }
+        }
+
+        return instance;
+    }
+
+    /// <summary>
+    /// Cache specific hooks to process items from HTTP response
+    /// </summary>
+    /// <param name="stream">input stream</param>
+    /// <returns>awaitable task</returns>
+    protected abstract Task<T> ConvertFromAsync(Stream stream);
+
+    /// <summary>
+    /// Cache specific hooks to process items from HTTP response
+    /// </summary>
+    /// <param name="baseFile">storage file</param>
+    /// <returns>awaitable task</returns>
+    protected abstract Task<T> ConvertFromAsync(string baseFile);
+
+    /// <summary>
+    /// Override-able method that checks whether file is valid or not.
+    /// </summary>
+    /// <param name="file">storage file</param>
+    /// <param name="duration">cache duration</param>
+    /// <param name="treatNullFileAsOutOfDate">option to mark uninitialized file as expired</param>
+    /// <returns>bool indicate whether file has expired or not</returns>
+    protected virtual async Task<bool> IsFileOutOfDateAsync(
+        string file,
+        TimeSpan duration,
+        bool treatNullFileAsOutOfDate = true
+    )
+    {
+        if (file == null)
+        {
+            return treatNullFileAsOutOfDate;
+        }
+
+        var info = new FileInfo(file);
+
+        return info.Length == 0 || DateTime.Now.Subtract(info.LastWriteTime) > duration;
+    }
+
+    private static string GetCacheFileName(Uri uri)
+    {
+        return CreateHash64(uri.ToString()).ToString();
+    }
+
+    private static ulong CreateHash64(string str)
+    {
+        byte[] utf8 = System.Text.Encoding.UTF8.GetBytes(str);
+
+        ulong value = (ulong)utf8.Length;
+        for (int n = 0; n < utf8.Length; n++)
+        {
+            value += (ulong)utf8[n] << ((n * 5) % 56);
+        }
+
+        return value;
+    }
+
+    private async Task<T?> GetItemAsync(
+        Uri uri,
+        bool throwOnError,
+        bool preCacheOnly,
+        CancellationToken cancellationToken
+    )
+    {
+        T? instance = default(T);
+
+        string fileName = GetCacheFileName(uri);
+        _concurrentTasks.TryGetValue(fileName, out var request);
+
+        // if similar request exists check if it was preCacheOnly and validate that current request isn't preCacheOnly
+        if (request != null && request.EnsureCachedCopy && !preCacheOnly)
+        {
+            if (request.Task != null)
+                await request.Task.ConfigureAwait(false);
+            request = null;
+        }
+
+        if (request == null)
+        {
+            request = new ConcurrentRequest()
+            {
+                Task = GetFromCacheOrDownloadAsync(uri, fileName, preCacheOnly, cancellationToken),
+                EnsureCachedCopy = preCacheOnly
+            };
+
+            _concurrentTasks[fileName] = request;
+        }
+
+        try
+        {
+            if (request.Task != null)
+                instance = await request.Task.ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine(ex.Message);
+            if (throwOnError)
+            {
+                throw;
+            }
+        }
+        finally
+        {
+            _concurrentTasks.TryRemove(fileName, out _);
+        }
+
+        return instance;
+    }
+
+    private async Task<T?> GetFromCacheOrDownloadAsync(
+        Uri uri,
+        string fileName,
+        bool preCacheOnly,
+        CancellationToken cancellationToken
+    )
+    {
+        T? instance = default(T);
+
+        if (_inMemoryFileStorage?.MaxItemCount > 0)
+        {
+            var msi = _inMemoryFileStorage?.GetItem(fileName, CacheDuration);
+            if (msi != null)
+            {
+                instance = msi.Item;
+            }
+        }
+
+        if (instance != null)
+        {
+            return instance;
+        }
+
+        var folder = await GetCacheFolderAsync().ConfigureAwait(false);
+        var baseFile = Path.Combine(folder!, fileName);
+
+        bool downloadDataFile =
+            !File.Exists(baseFile)
+            || await IsFileOutOfDateAsync(baseFile, CacheDuration).ConfigureAwait(false);
+
+        if (!File.Exists(baseFile))
+        {
+            File.Create(baseFile).Dispose();
+        }
+
+        if (downloadDataFile)
+        {
+            uint retries = 0;
+            try
+            {
+                while (retries < RetryCount)
+                {
+                    try
+                    {
+                        instance = await DownloadFileAsync(uri, baseFile, preCacheOnly, cancellationToken)
+                            .ConfigureAwait(false);
+
+                        if (instance != null)
+                        {
+                            break;
+                        }
+                    }
+                    catch (FileNotFoundException) { }
+
+                    retries++;
+                }
+            }
+            catch (Exception ex)
+            {
+                File.Delete(baseFile);
+                throw; // re-throwing the exception changes the stack trace. just throw
+            }
+        }
+
+        if (EqualityComparer<T>.Default.Equals(instance, default(T)) && !preCacheOnly)
+        {
+            instance = await ConvertFromAsync(baseFile).ConfigureAwait(false);
+
+            if (_inMemoryFileStorage?.MaxItemCount > 0)
+            {
+                var properties = new FileInfo(baseFile);
+
+                var msi = new InMemoryStorageItem<T>(fileName, properties.LastWriteTime, instance);
+                _inMemoryFileStorage?.SetItem(msi);
+            }
+        }
+        return instance;
+    }
+
+    private async Task<T?> DownloadFileAsync(
+        Uri uri,
+        string baseFile,
+        bool preCacheOnly,
+        CancellationToken cancellationToken
+    )
+    {
+        T? instance = default(T);
+
+        using (MemoryStream ms = new MemoryStream())
+        {
+            using (var stream = await HttpClient.GetStreamAsync(uri))
+            {
+                stream.CopyTo(ms);
+                ms.Flush();
+
+                ms.Position = 0;
+
+                using (var fs = File.Open(baseFile, FileMode.OpenOrCreate, FileAccess.Write))
+                {
+                    ms.CopyTo(fs);
+
+                    fs.Flush();
+
+                    ms.Position = 0;
+                }
+            }
+
+            // if its pre-cache we aren't looking to load items in memory
+            if (!preCacheOnly)
+            {
+                instance = await ConvertFromAsync(ms).ConfigureAwait(false);
+            }
+        }
+
+        return instance;
+    }
+
+    private async Task InternalClearAsync(IEnumerable<string?> files)
+    {
+        foreach (var file in files)
+        {
+            try
+            {
+                File.Delete(file!);
+            }
+            catch
+            {
+                // Just ignore errors for now}
+            }
+        }
+    }
+
+    /// <summary>
+    /// Initializes with default values if user has not initialized explicitly
+    /// </summary>
+    /// <returns>awaitable task</returns>
+    private async Task ForceInitialiseAsync()
+    {
+        if (_cacheFolder != null)
+        {
+            return;
+        }
+
+        await _cacheFolderSemaphore.WaitAsync().ConfigureAwait(false);
+
+        _inMemoryFileStorage = new InMemoryStorage<T>();
+
+        if (_baseFolder == null)
+        {
+            _baseFolder = Path.GetTempPath();
+        }
+
+        if (string.IsNullOrWhiteSpace(_cacheFolderName))
+        {
+            _cacheFolderName = GetType().Name;
+        }
+
+        try
+        {
+            _cacheFolder = Path.Combine(_baseFolder, _cacheFolderName);
+            Directory.CreateDirectory(_cacheFolder);
+        }
+        finally
+        {
+            _cacheFolderSemaphore.Release();
+        }
+    }
+
+    private async Task<string?> GetCacheFolderAsync()
+    {
+        if (_cacheFolder == null)
+        {
+            await ForceInitialiseAsync().ConfigureAwait(false);
+        }
+
+        return _cacheFolder;
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheOptions.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheOptions.cs
new file mode 100644
index 00000000..a07ca33c
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/CacheOptions.cs
@@ -0,0 +1,18 @@
+using System;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+public class CacheOptions
+{
+    private static CacheOptions? _cacheOptions;
+
+    public static CacheOptions Default => _cacheOptions ??= new CacheOptions();
+
+    public static void SetDefault(CacheOptions defaultCacheOptions)
+    {
+        _cacheOptions = defaultCacheOptions;
+    }
+
+    public string? BaseCachePath { get; set; }
+    public TimeSpan? CacheDuration { get; set; }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/FileCache.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/FileCache.cs
new file mode 100644
index 00000000..a273ca0b
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/FileCache.cs
@@ -0,0 +1,36 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+/// <summary>
+/// Provides methods and tools to cache files in a folder
+/// </summary>
+internal class FileCache : CacheBase<string>
+{
+    /// <summary>
+    /// Private singleton field.
+    /// </summary>
+    private static FileCache? _instance;
+
+    /// <summary>
+    /// Gets public singleton property.
+    /// </summary>
+    public static FileCache Instance => _instance ?? (_instance = new FileCache());
+
+    protected override Task<string> ConvertFromAsync(Stream stream)
+    {
+        // nothing to do in this instance;
+        return Task.FromResult<string>("");
+    }
+
+    /// <summary>
+    /// Returns a cached path
+    /// </summary>
+    /// <param name="baseFile">storage file</param>
+    /// <returns>awaitable task</returns>
+    protected override Task<string> ConvertFromAsync(string baseFile)
+    {
+        return Task.FromResult(baseFile);
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/ImageCache.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/ImageCache.cs
new file mode 100644
index 00000000..5582b071
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/ImageCache.cs
@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Avalonia.Media.Imaging;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+/// <summary>
+/// Provides methods and tools to cache images in a folder
+/// </summary>
+internal class ImageCache : CacheBase<Bitmap>
+{
+    /// <summary>
+    /// Private singleton field.
+    /// </summary>
+    [ThreadStatic]
+    private static ImageCache? _instance;
+
+    /// <summary>
+    /// Gets public singleton property.
+    /// </summary>
+    public static ImageCache Instance => _instance ?? (_instance = new ImageCache());
+
+    /// <summary>
+    /// Creates a bitmap from a stream
+    /// </summary>
+    /// <param name="stream">input stream</param>
+    /// <returns>awaitable task</returns>
+    protected override async Task<Bitmap> ConvertFromAsync(Stream stream)
+    {
+        if (stream.Length == 0)
+        {
+            throw new FileNotFoundException();
+        }
+
+        return new Bitmap(stream);
+    }
+
+    /// <summary>
+    /// Creates a bitmap from a cached file
+    /// </summary>
+    /// <param name="baseFile">file</param>
+    /// <returns>awaitable task</returns>
+    protected override async Task<Bitmap> ConvertFromAsync(string baseFile)
+    {
+        using (var stream = File.OpenRead(baseFile))
+        {
+            return await ConvertFromAsync(stream).ConfigureAwait(false);
+        }
+    }
+
+    /// <summary>
+    /// Checks whether file is valid or not.
+    /// </summary>
+    /// <param name="file">file</param>
+    /// <param name="duration">cache duration</param>
+    /// <param name="treatNullFileAsOutOfDate">option to mark uninitialized file as expired</param>
+    /// <returns>bool indicate whether file has expired or not</returns>
+    protected override async Task<bool> IsFileOutOfDateAsync(
+        string file,
+        TimeSpan duration,
+        bool treatNullFileAsOutOfDate = true
+    )
+    {
+        if (file == null)
+        {
+            return treatNullFileAsOutOfDate;
+        }
+
+        var fileInfo = new FileInfo(file);
+
+        return fileInfo.Length == 0
+            || DateTime.Now.Subtract(File.GetLastAccessTime(file)) > duration
+            || DateTime.Now.Subtract(File.GetLastWriteTime(file)) > duration;
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorage.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorage.cs
new file mode 100644
index 00000000..5643e679
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorage.cs
@@ -0,0 +1,156 @@
+// 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.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Labs.Controls.Cache;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+/// <summary>
+/// Generic in-memory storage of items
+/// </summary>
+/// <typeparam name="T">T defines the type of item stored</typeparam>
+public class InMemoryStorage<T>
+{
+    private int _maxItemCount;
+    private ConcurrentDictionary<string, InMemoryStorageItem<T>> _inMemoryStorage =
+        new ConcurrentDictionary<string, InMemoryStorageItem<T>>();
+    private object _settingMaxItemCountLocker = new object();
+
+    /// <summary>
+    /// Gets or sets the maximum count of Items that can be stored in this InMemoryStorage instance.
+    /// </summary>
+    public int MaxItemCount
+    {
+        get { return _maxItemCount; }
+        set
+        {
+            if (_maxItemCount == value)
+            {
+                return;
+            }
+
+            _maxItemCount = value;
+
+            lock (_settingMaxItemCountLocker)
+            {
+                EnsureStorageBounds(value);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Clears all items stored in memory
+    /// </summary>
+    public void Clear()
+    {
+        _inMemoryStorage.Clear();
+    }
+
+    /// <summary>
+    /// Clears items stored in memory based on duration passed
+    /// </summary>
+    /// <param name="duration">TimeSpan to identify expired items</param>
+    public void Clear(TimeSpan duration)
+    {
+        var expirationDate = DateTime.Now.Subtract(duration);
+
+        var itemsToRemove = _inMemoryStorage
+            .Where(kvp => kvp.Value.LastUpdated <= expirationDate)
+            .Select(kvp => kvp.Key);
+
+        if (itemsToRemove.Any())
+        {
+            Remove(itemsToRemove);
+        }
+    }
+
+    /// <summary>
+    /// Remove items based on provided keys
+    /// </summary>
+    /// <param name="keys">identified of the in-memory storage item</param>
+    public void Remove(IEnumerable<string> keys)
+    {
+        foreach (var key in keys)
+        {
+            if (string.IsNullOrWhiteSpace(key))
+            {
+                continue;
+            }
+
+            _inMemoryStorage.TryRemove(key, out _);
+        }
+    }
+
+    /// <summary>
+    /// Add new item to in-memory storage
+    /// </summary>
+    /// <param name="item">item to be stored</param>
+    public void SetItem(InMemoryStorageItem<T> item)
+    {
+        if (MaxItemCount == 0)
+        {
+            return;
+        }
+
+        _inMemoryStorage[item.Id] = item;
+
+        // ensure max limit is maintained. trim older entries first
+        if (_inMemoryStorage.Count > MaxItemCount)
+        {
+            var itemsToRemove = _inMemoryStorage
+                .OrderBy(kvp => kvp.Value.Created)
+                .Take(_inMemoryStorage.Count - MaxItemCount)
+                .Select(kvp => kvp.Key);
+            Remove(itemsToRemove);
+        }
+    }
+
+    /// <summary>
+    /// Get item from in-memory storage as long as it has not ex
+    /// </summary>
+    /// <param name="id">id of the in-memory storage item</param>
+    /// <param name="duration">timespan denoting expiration</param>
+    /// <returns>Valid item if not out of date or return null if out of date or item does not exist</returns>
+    public InMemoryStorageItem<T>? GetItem(string id, TimeSpan duration)
+    {
+        if (!_inMemoryStorage.TryGetValue(id, out var tempItem))
+        {
+            return null;
+        }
+
+        var expirationDate = DateTime.Now.Subtract(duration);
+
+        if (tempItem.LastUpdated > expirationDate)
+        {
+            return tempItem;
+        }
+
+        _inMemoryStorage.TryRemove(id, out _);
+
+        return null;
+    }
+
+    private void EnsureStorageBounds(int maxCount)
+    {
+        if (_inMemoryStorage.Count == 0)
+        {
+            return;
+        }
+
+        if (maxCount == 0)
+        {
+            _inMemoryStorage.Clear();
+            return;
+        }
+
+        if (_inMemoryStorage.Count > maxCount)
+        {
+            Remove(_inMemoryStorage.Keys.Take(_inMemoryStorage.Count - maxCount));
+        }
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorageItem.cs b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorageItem.cs
new file mode 100644
index 00000000..4bad770d
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Cache/InMemoryStorageItem.cs
@@ -0,0 +1,49 @@
+// 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;
+
+namespace StabilityMatrix.Avalonia.Controls.VendorLabs.Cache;
+
+/// <summary>
+/// Generic InMemoryStorageItem holds items for InMemoryStorage.
+/// </summary>
+/// <typeparam name="T">Type is set by consuming cache</typeparam>
+public class InMemoryStorageItem<T>
+{
+    /// <summary>
+    /// Gets the item identifier
+    /// </summary>
+    public string Id { get; private set; }
+
+    /// <summary>
+    /// Gets the item created timestamp.
+    /// </summary>
+    public DateTime Created { get; private set; }
+
+    /// <summary>
+    /// Gets the item last updated timestamp.
+    /// </summary>
+    public DateTime LastUpdated { get; private set; }
+
+    /// <summary>
+    /// Gets the item being stored.
+    /// </summary>
+    public T Item { get; private set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="InMemoryStorageItem{T}"/> class.
+    /// Constructor for InMemoryStorageItem
+    /// </summary>
+    /// <param name="id">uniquely identifies the item</param>
+    /// <param name="lastUpdated">last updated timestamp</param>
+    /// <param name="item">the item being stored</param>
+    public InMemoryStorageItem(string id, DateTime lastUpdated, T item)
+    {
+        Id = id;
+        LastUpdated = lastUpdated;
+        Item = item;
+        Created = DateTime.Now;
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/LICENSE b/StabilityMatrix.Avalonia/Controls/VendorLabs/LICENSE
new file mode 100644
index 00000000..8a6071d2
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 AvaloniaUI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/StabilityMatrix.Avalonia/StabilityMatrix.Avalonia.csproj.DotSettings b/StabilityMatrix.Avalonia/StabilityMatrix.Avalonia.csproj.DotSettings
index ef254925..524abe98 100644
--- a/StabilityMatrix.Avalonia/StabilityMatrix.Avalonia.csproj.DotSettings
+++ b/StabilityMatrix.Avalonia/StabilityMatrix.Avalonia.csproj.DotSettings
@@ -2,4 +2,5 @@
 	<s:String x:Key="/Default/CodeEditing/Localization/Localizable/@EntryValue">Yes</s:String>
 	<s:String x:Key="/Default/CodeEditing/Localization/LocalizableInspector/@EntryValue">Pessimistic</s:String>
 	<s:String x:Key="/Default/CodeInspection/Daemon/ConfigureAwaitAnalysisMode/@EntryValue">UI</s:String>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=controls_005Cpropertygrid/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=controls_005Cpropertygrid/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=controls_005Cvendorlabs_005Casyncimage/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

From 224b008cd9ba2d6238dd29c223cc860d9daf6a4d Mon Sep 17 00:00:00 2001
From: Ionite <dev@ionite.io>
Date: Wed, 10 Apr 2024 23:24:05 -0400
Subject: [PATCH 4/6] Switch usages to BetterAsyncImage

---
 .../Controls/Inference/ImageFolderCard.axaml         |  3 ++-
 .../Controls/Inference/ImageGalleryCard.axaml        |  3 ++-
 .../SelectableImageCard/SelectableImageButton.axaml  |  5 +++--
 .../Styles/ControlThemes/BetterComboBoxStyles.axaml  | 11 ++++++-----
 StabilityMatrix.Avalonia/Views/CheckpointsPage.axaml |  5 +++--
 .../Views/CivitAiBrowserPage.axaml                   | 12 ++++++------
 .../Views/Dialogs/OpenArtWorkflowDialog.axaml        |  3 ++-
 .../Views/InstalledWorkflowsPage.axaml               |  5 +++--
 .../Views/OpenArtBrowserPage.axaml                   |  7 ++++---
 .../Views/PackageManagerPage.axaml                   |  3 ++-
 10 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/StabilityMatrix.Avalonia/Controls/Inference/ImageFolderCard.axaml b/StabilityMatrix.Avalonia/Controls/Inference/ImageFolderCard.axaml
index 67b75973..b34b8b42 100644
--- a/StabilityMatrix.Avalonia/Controls/Inference/ImageFolderCard.axaml
+++ b/StabilityMatrix.Avalonia/Controls/Inference/ImageFolderCard.axaml
@@ -10,6 +10,7 @@
     xmlns:vmInference="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Inference"
     xmlns:scroll="clr-namespace:StabilityMatrix.Avalonia.Controls.Scroll"
     xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+    xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
     x:DataType="vmInference:ImageFolderCardViewModel">
 
     <Design.PreviewWith>
@@ -196,7 +197,7 @@
 
                                             <Border ClipToBounds="True" CornerRadius="8">
                                                 <Grid RowDefinitions="*,Auto">
-                                                    <labs:AsyncImage
+                                                    <vendorLabs:BetterAsyncImage
                                                         Width="{Binding $parent[ItemsRepeater].((vmInference:ImageFolderCardViewModel)DataContext).ImageSize.Width}"
                                                         Height="{Binding $parent[ItemsRepeater].((vmInference:ImageFolderCardViewModel)DataContext).ImageSize.Height}"
                                                         Source="{Binding AbsolutePath}"
diff --git a/StabilityMatrix.Avalonia/Controls/Inference/ImageGalleryCard.axaml b/StabilityMatrix.Avalonia/Controls/Inference/ImageGalleryCard.axaml
index f80c99b2..d3be63b5 100644
--- a/StabilityMatrix.Avalonia/Controls/Inference/ImageGalleryCard.axaml
+++ b/StabilityMatrix.Avalonia/Controls/Inference/ImageGalleryCard.axaml
@@ -6,6 +6,7 @@
     xmlns:models="clr-namespace:StabilityMatrix.Avalonia.Models"
     xmlns:vmInference="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Inference"
     xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+    xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
     x:DataType="vmInference:ImageGalleryCardViewModel">
 
     <Design.PreviewWith>
@@ -116,7 +117,7 @@
                             </ListBox.Styles>
                             <ListBox.ItemTemplate>
                                 <DataTemplate DataType="{x:Type models:ImageSource}">
-                                    <labs:AsyncImage
+                                    <vendorLabs:BetterAsyncImage
                                         MaxHeight="65"
                                         CornerRadius="4"
                                         Source="{Binding Uri}"
diff --git a/StabilityMatrix.Avalonia/Controls/SelectableImageCard/SelectableImageButton.axaml b/StabilityMatrix.Avalonia/Controls/SelectableImageCard/SelectableImageButton.axaml
index 3211921a..40289621 100644
--- a/StabilityMatrix.Avalonia/Controls/SelectableImageCard/SelectableImageButton.axaml
+++ b/StabilityMatrix.Avalonia/Controls/SelectableImageCard/SelectableImageButton.axaml
@@ -2,7 +2,8 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:selectableImageCard="clr-namespace:StabilityMatrix.Avalonia.Controls.SelectableImageCard"
         xmlns:controls="clr-namespace:StabilityMatrix.Avalonia.Controls"
-        xmlns:controls1="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls">
+        xmlns:controls1="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+        xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs">
     <Design.PreviewWith>
         <Border Padding="20">
             <!-- Add Controls for Previewer Here -->
@@ -39,7 +40,7 @@
                         CornerRadius="12"
                         Command="{TemplateBinding Command}"
                         CommandParameter="{TemplateBinding CommandParameter}">
-                        <controls1:AsyncImage
+                        <vendorLabs:BetterAsyncImage
                             Stretch="UniformToFill"
                             CornerRadius="8"
                             ContextFlyout="{TemplateBinding ContextFlyout}"
diff --git a/StabilityMatrix.Avalonia/Styles/ControlThemes/BetterComboBoxStyles.axaml b/StabilityMatrix.Avalonia/Styles/ControlThemes/BetterComboBoxStyles.axaml
index 652a4ade..c1274ef4 100644
--- a/StabilityMatrix.Avalonia/Styles/ControlThemes/BetterComboBoxStyles.axaml
+++ b/StabilityMatrix.Avalonia/Styles/ControlThemes/BetterComboBoxStyles.axaml
@@ -7,7 +7,8 @@
     xmlns:models="clr-namespace:StabilityMatrix.Core.Models;assembly=StabilityMatrix.Core"
     xmlns:sg="clr-namespace:SpacedGridControl.Avalonia;assembly=SpacedGridControl.Avalonia"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
-    xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls">
+    xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+    xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs">
 
     <Design.PreviewWith>
         <Panel Width="450" Height="600">
@@ -43,7 +44,7 @@
                     ColumnSpacing="6"
                     RowSpacing="0">
                     <!--  Image  -->
-                    <labs:AsyncImage
+                    <vendorLabs:BetterAsyncImage
                         Width="64"
                         Height="96"
                         CornerRadius="6"
@@ -125,7 +126,7 @@
                         ColumnSpacing="8"
                         TextBlock.TextTrimming="CharacterEllipsis"
                         TextBlock.TextWrapping="NoWrap">
-                        <labs:AsyncImage
+                        <vendorLabs:BetterAsyncImage
                             Grid.RowSpan="2"
                             Width="42"
                             Height="42"
@@ -213,7 +214,7 @@
                         ColumnSpacing="8"
                         TextBlock.TextTrimming="CharacterEllipsis"
                         TextBlock.TextWrapping="NoWrap">
-                        <labs:AsyncImage
+                        <vendorLabs:BetterAsyncImage
                             Grid.RowSpan="2"
                             Width="36"
                             Height="36"
@@ -221,7 +222,7 @@
                             RenderOptions.BitmapInterpolationMode="HighQuality"
                             Source="{Binding Local.PreviewImageFullPathGlobal}"
                             Stretch="UniformToFill">
-                        </labs:AsyncImage>
+                        </vendorLabs:BetterAsyncImage>
 
                         <!--  Text  -->
                         <sg:SpacedGrid
diff --git a/StabilityMatrix.Avalonia/Views/CheckpointsPage.axaml b/StabilityMatrix.Avalonia/Views/CheckpointsPage.axaml
index bbb08dae..facb1298 100644
--- a/StabilityMatrix.Avalonia/Views/CheckpointsPage.axaml
+++ b/StabilityMatrix.Avalonia/Views/CheckpointsPage.axaml
@@ -14,6 +14,7 @@
                           xmlns:generic="clr-namespace:System.Collections.Generic;assembly=System.Collections"
                           xmlns:converters="clr-namespace:StabilityMatrix.Avalonia.Converters"
                           xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+                          xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
                           d:DataContext="{x:Static mocks:DesignData.CheckpointsPageViewModel}"
                           x:CompileBindings="True"
                           x:DataType="vm:CheckpointsPageViewModel"
@@ -139,7 +140,7 @@
                                         TextWrapping="WrapWithOverflow"
                                         IsVisible="{Binding IsConnectedModel}" />
                                     <!--  Image  -->
-                                    <labs:AsyncImage
+                                    <vendorLabs:BetterAsyncImage
                                         Margin="0,0,0,4"
                                         CornerRadius="4"
                                         Source="{Binding PreviewImagePath}"
@@ -176,7 +177,7 @@
                                 IsVisible="{Binding IsConnectedModel}" />
                         </StackPanel>
 
-                        <labs:AsyncImage Grid.Row="1"
+                        <vendorLabs:BetterAsyncImage Grid.Row="1"
                                          Grid.Column="0"
                                          Grid.ColumnSpan="2"
                                          Margin="0, 4,0,4"
diff --git a/StabilityMatrix.Avalonia/Views/CivitAiBrowserPage.axaml b/StabilityMatrix.Avalonia/Views/CivitAiBrowserPage.axaml
index 2ccda13b..288c0328 100644
--- a/StabilityMatrix.Avalonia/Views/CivitAiBrowserPage.axaml
+++ b/StabilityMatrix.Avalonia/Views/CivitAiBrowserPage.axaml
@@ -17,6 +17,7 @@
     xmlns:helpers="clr-namespace:StabilityMatrix.Avalonia.Helpers"
     xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
     xmlns:system="clr-namespace:System;assembly=System.Runtime"
+    xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
     d:DataContext="{x:Static designData:DesignData.CivitAiBrowserViewModel}"
     d:DesignHeight="700"
     d:DesignWidth="800"
@@ -103,7 +104,7 @@
                     CommandParameter="{Binding CivitModel}"
                     IsEnabled="{Binding !IsImporting}">
                     <Grid RowDefinitions="*, Auto">
-                        <labs:AsyncImage Grid.Row="0"
+                        <vendorLabs:BetterAsyncImage Grid.Row="0"
                                                       CornerRadius="8"
                                                       VerticalAlignment="Top"
                                                       HorizontalAlignment="Center"
@@ -115,8 +116,8 @@
                             <!-- <controls:BetterAdvancedImage.RenderTransform> -->
                             <!--     <RotateTransform Angle="315"></RotateTransform> -->
                             <!-- </controls:BetterAdvancedImage.RenderTransform> -->
-                        </labs:AsyncImage>
-                        <labs:AsyncImage
+                        </vendorLabs:BetterAsyncImage>
+                        <vendorLabs:BetterAsyncImage
                             Grid.Row="0"
                             Grid.RowSpan="2"
                             CornerRadius="8"
@@ -182,15 +183,14 @@
                                 Classes="transparent"
                                 Padding="10,4">
                                 <StackPanel Orientation="Horizontal" Spacing="6">
-                                    <labs:AsyncImage
+                                    <vendorLabs:BetterAsyncImage
                                         Width="22"
                                         Height="22"
                                         Effect="{StaticResource ImageDropShadowEffect}"
                                         CornerRadius="11"
                                         RenderOptions.BitmapInterpolationMode="HighQuality"
                                         IsVisible="{Binding CivitModel.Creator.Image, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"
-                                        Source="{Binding CivitModel.Creator.Image}">
-                                    </labs:AsyncImage>
+                                        Source="{Binding CivitModel.Creator.Image}"/>
                                     <TextBlock 
                                         VerticalAlignment="Center"
                                         Effect="{StaticResource TextDropShadowEffect}"
diff --git a/StabilityMatrix.Avalonia/Views/Dialogs/OpenArtWorkflowDialog.axaml b/StabilityMatrix.Avalonia/Views/Dialogs/OpenArtWorkflowDialog.axaml
index 8faddf52..a5950c33 100644
--- a/StabilityMatrix.Avalonia/Views/Dialogs/OpenArtWorkflowDialog.axaml
+++ b/StabilityMatrix.Avalonia/Views/Dialogs/OpenArtWorkflowDialog.axaml
@@ -13,6 +13,7 @@
     xmlns:system="clr-namespace:System;assembly=System.Runtime"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
     xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+    xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
     d:DataContext="{x:Static designData:DesignData.OpenArtWorkflowViewModel}"
     d:DesignHeight="650"
     d:DesignWidth="600"
@@ -36,7 +37,7 @@
             <Run Text="{Binding Workflow.Creator.Name}" />
         </TextBlock>
 
-        <labs:AsyncImage
+        <vendorLabs:BetterAsyncImage
             Grid.Row="2"
             Grid.Column="0"
             Height="300"
diff --git a/StabilityMatrix.Avalonia/Views/InstalledWorkflowsPage.axaml b/StabilityMatrix.Avalonia/Views/InstalledWorkflowsPage.axaml
index 4b16cf68..35c104b5 100644
--- a/StabilityMatrix.Avalonia/Views/InstalledWorkflowsPage.axaml
+++ b/StabilityMatrix.Avalonia/Views/InstalledWorkflowsPage.axaml
@@ -15,6 +15,7 @@
                           xmlns:helpers="clr-namespace:StabilityMatrix.Avalonia.Helpers"
                           xmlns:fluent="clr-namespace:FluentIcons.Avalonia.Fluent;assembly=FluentIcons.Avalonia.Fluent"
                           xmlns:input="clr-namespace:FluentAvalonia.UI.Input;assembly=FluentAvalonia"
+                          xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
                           mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
                           d:DataContext="{x:Static designData:DesignData.InstalledWorkflowsViewModel}"
                           x:DataType="viewModels:InstalledWorkflowsViewModel"
@@ -164,7 +165,7 @@
                                 VerticalContentAlignment="Top"
                                 CornerRadius="8">
                                 <Grid RowDefinitions="*, Auto">
-                                    <labs:AsyncImage
+                                    <vendorLabs:BetterAsyncImage
                                         Grid.Row="0"
                                         Grid.RowSpan="2"
                                         CornerRadius="8"
@@ -210,7 +211,7 @@
                                             Classes="transparent"
                                             Padding="10,4">
                                             <StackPanel Orientation="Horizontal" Spacing="6">
-                                                <labs:AsyncImage
+                                                <vendorLabs:BetterAsyncImage
                                                     Width="22"
                                                     Height="22"
                                                     Effect="{StaticResource ImageDropShadowEffect}"
diff --git a/StabilityMatrix.Avalonia/Views/OpenArtBrowserPage.axaml b/StabilityMatrix.Avalonia/Views/OpenArtBrowserPage.axaml
index 216dcc46..c4f8189f 100644
--- a/StabilityMatrix.Avalonia/Views/OpenArtBrowserPage.axaml
+++ b/StabilityMatrix.Avalonia/Views/OpenArtBrowserPage.axaml
@@ -13,6 +13,7 @@
                           xmlns:input="clr-namespace:FluentAvalonia.UI.Input;assembly=FluentAvalonia"
                           xmlns:viewModels="clr-namespace:StabilityMatrix.Avalonia.ViewModels"
                           xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+                          xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
                           x:DataType="viewModels:OpenArtBrowserViewModel"
                           mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
                           x:Class="StabilityMatrix.Avalonia.Views.OpenArtBrowserPage">
@@ -106,7 +107,7 @@
                     Command="{StaticResource OpenWorkflowCommand}"
                     CommandParameter="{Binding }">
                     <Grid RowDefinitions="*, Auto">
-                        <labs:AsyncImage
+                        <vendorLabs:BetterAsyncImage
                             Grid.Row="0"
                             Grid.RowSpan="2"
                             CornerRadius="8"
@@ -143,7 +144,7 @@
                                 Classes="transparent"
                                 Padding="10,4">
                                 <StackPanel Orientation="Horizontal" Spacing="6">
-                                    <labs:AsyncImage
+                                    <vendorLabs:BetterAsyncImage
                                         Width="22"
                                         Height="22"
                                         ClipToBounds="True"
@@ -152,7 +153,7 @@
                                         RenderOptions.BitmapInterpolationMode="HighQuality"
                                         IsVisible="{Binding Creator.Avatar, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"
                                         Source="{Binding Creator.Avatar}">
-                                    </labs:AsyncImage>
+                                    </vendorLabs:BetterAsyncImage>
                                     <TextBlock
                                         VerticalAlignment="Center"
                                         Foreground="{DynamicResource TextControlForeground}"
diff --git a/StabilityMatrix.Avalonia/Views/PackageManagerPage.axaml b/StabilityMatrix.Avalonia/Views/PackageManagerPage.axaml
index ad669d71..37b450db 100644
--- a/StabilityMatrix.Avalonia/Views/PackageManagerPage.axaml
+++ b/StabilityMatrix.Avalonia/Views/PackageManagerPage.axaml
@@ -14,6 +14,7 @@
                           xmlns:avalonia="clr-namespace:SpacedGridControl.Avalonia;assembly=SpacedGridControl.Avalonia"
                           xmlns:markupExtensions="clr-namespace:StabilityMatrix.Avalonia.MarkupExtensions"
                           xmlns:labs="clr-namespace:Avalonia.Labs.Controls;assembly=Avalonia.Labs.Controls"
+                          xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs"
                           mc:Ignorable="d" d:DesignWidth="1000" d:DesignHeight="450"
                           x:DataType="viewModels:PackageManagerViewModel"
                           x:CompileBindings="True"
@@ -45,7 +46,7 @@
                                 </MultiBinding>
                             </controls:Card.Background>
                             <Grid ColumnDefinitions="Auto, *">
-                                <labs:AsyncImage
+                                <vendorLabs:BetterAsyncImage
                                     Grid.Column="0"
                                     Height="150"
                                     Width="150"

From b21e11c0c8401008687e8e3730f601ad6db701b8 Mon Sep 17 00:00:00 2001
From: Ionite <dev@ionite.io>
Date: Wed, 10 Apr 2024 23:36:32 -0400
Subject: [PATCH 5/6] Add control theme for BetterAsyncImage

---
 StabilityMatrix.Avalonia/App.axaml            |  1 +
 .../VendorLabs/Themes/BetterAsyncImage.axaml  | 48 +++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 StabilityMatrix.Avalonia/Controls/VendorLabs/Themes/BetterAsyncImage.axaml

diff --git a/StabilityMatrix.Avalonia/App.axaml b/StabilityMatrix.Avalonia/App.axaml
index 2ca1c5c3..63547818 100644
--- a/StabilityMatrix.Avalonia/App.axaml
+++ b/StabilityMatrix.Avalonia/App.axaml
@@ -29,6 +29,7 @@
                  <ResourceInclude Source="Styles/ListBoxStyles.axaml"/>
                  <ResourceInclude Source="Styles/FAComboBoxStyles.axaml"/>
                  <ResourceInclude Source="Controls/Inference/ImageFolderCard.axaml"/>
+                 <ResourceInclude Source="Controls/VendorLabs/Themes/BetterAsyncImage.axaml"/>
              </ResourceDictionary.MergedDictionaries>
              
              <idcr:ControlRecycling x:Key="ControlRecyclingKey" />
diff --git a/StabilityMatrix.Avalonia/Controls/VendorLabs/Themes/BetterAsyncImage.axaml b/StabilityMatrix.Avalonia/Controls/VendorLabs/Themes/BetterAsyncImage.axaml
new file mode 100644
index 00000000..2b6f1bd0
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/VendorLabs/Themes/BetterAsyncImage.axaml
@@ -0,0 +1,48 @@
+<ResourceDictionary
+    xmlns="https://github.com/avaloniaui"
+  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+  xmlns:vendorLabs="clr-namespace:StabilityMatrix.Avalonia.Controls.VendorLabs">
+  <Design.PreviewWith>
+    <Border Width="200"
+            Height="200">
+        
+    </Border>
+  </Design.PreviewWith>
+
+  <ControlTheme x:Key="{x:Type vendorLabs:BetterAsyncImage}"
+                TargetType="vendorLabs:BetterAsyncImage">
+    <Setter Property="Background" Value="Transparent" />
+    <Setter Property="IsTabStop" Value="False" />
+    <Setter Property="Template">
+        <ControlTemplate>
+            <Border Margin="0"
+                    Padding="0"
+                    ClipToBounds="True"
+                    Background="{TemplateBinding Background}"
+                    BorderBrush="{TemplateBinding BorderBrush}"
+                    BorderThickness="{TemplateBinding BorderThickness}"
+                    CornerRadius="{TemplateBinding CornerRadius}">
+                <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                    <Image Name="PART_PlaceholderImage"
+                           HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+                           VerticalAlignment="{TemplateBinding VerticalAlignment}"
+                           Source="{TemplateBinding PlaceholderSource}"
+                           Stretch="{TemplateBinding PlaceholderStretch}"/>
+                    <Image Name="PART_Image"
+                           HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+                           VerticalAlignment="{TemplateBinding VerticalAlignment}"
+                           Stretch="{TemplateBinding Stretch}"/>
+                </Grid>                
+            </Border>
+        </ControlTemplate>
+    </Setter>
+      <Style Selector="^[State=Failed] /template/ Image#PART_Image">
+          <Setter Property="Opacity"
+                  Value="0.0" />
+      </Style>
+      <Style Selector="^[State=Failed] /template/ Image#PART_PlaceholderImage">
+          <Setter Property="Opacity"
+                  Value="1.0" />
+      </Style>
+  </ControlTheme>
+</ResourceDictionary>

From 2d961be0f396287ebe65038af3b8e38e703f322c Mon Sep 17 00:00:00 2001
From: Ionite <dev@ionite.io>
Date: Wed, 10 Apr 2024 23:36:52 -0400
Subject: [PATCH 6/6] Remove not needed AsyncImage fix

---
 StabilityMatrix.Avalonia/App.axaml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/StabilityMatrix.Avalonia/App.axaml b/StabilityMatrix.Avalonia/App.axaml
index 63547818..d6db2ffd 100644
--- a/StabilityMatrix.Avalonia/App.axaml
+++ b/StabilityMatrix.Avalonia/App.axaml
@@ -88,8 +88,5 @@
         <Style Selector="DockControl">
             <Setter Property="(DockProperties.ControlRecycling)" Value="{StaticResource ControlRecyclingKey}" />
         </Style>
-        <Style Selector="labs|AsyncImage Border">
-            <Setter Property="ClipToBounds" Value="True"/>
-        </Style>
     </Application.Styles>
 </Application>