- Fixed : Cursor visibilit,hide on linux system and Color conversion methods. Improved : AnsiDetector has been improved and Check requires a terminal/console environment at startup.

Author: FRACerqueira

README.md

@@ -33,6 +33,22 @@
 ----
 ## What's new in the latest version
 
+### V5.0.3
+[**Top**](#table-of-contents)
+
+- Improved : AnsiDetector has been improved.
+- Improved : Check requires a terminal/console environment at startup.
+    - System.Console.IsInputRedirected or System.Console.IsOutputRedirected not supported. 
+- Fixed : Cursor visibility/hide on linux system.
+- Fixed : Color conversion methods.
+    - Stackoverflow exception when use ToConsoleColor Extensions. (the Extensions methods were calling themselves recursively).
+    - ForegroundColor/BackgroundColor conversion.
+
+### V5.0.2
+[**Top**](#table-of-contents)
+
+- Fixed : Incorrect PageSize value for widgets.Fixed: ProgressBar control with custom range not updating percentage.
+- 
 ### V5.0.1
 [**Top**](#table-of-contents)
 

docs/api/assemblies/PromptPlus.md

@@ -20,7 +20,6 @@
 | enum [ChartBarType](./PromptPlusLibrary/ChartBarType.md) | Represents the Kinds Progress Bar |
 | class [ChartItem](./PromptPlusLibrary/ChartItem.md) | Represents a chart item. |
 | struct [Color](./PromptPlusLibrary/Color.md) | Represents an RGB color (optionally mapped to an indexed palette entry). |
-| static class [ColorExtensions](./PromptPlusLibrary/ColorExtensions.md) | Extensions for the Color class. |
 | enum [ColorSystem](./PromptPlusLibrary/ColorSystem.md) | Represents the capacity of console color system. |
 | enum [ComponentStyles](./PromptPlusLibrary/ComponentStyles.md) | Represents the different styles that can be applied to components in the PromptPlus library. |
 | enum [DashOptions](./PromptPlusLibrary/DashOptions.md) | Represents a boder when write line with SingleDash/DoubleDash. |

docs/api/assemblies/PromptPlusLibrary/ColorExtensions.md

@@ -40,36 +40,95 @@ public static bool IsValidTerminal(string term)
             return !string.IsNullOrWhiteSpace(term) && _regexes.Any(regex => regex.IsMatch(term));
         }
 
+        /// <summary>
+        /// Detect whether current environment supports ANSI sequences.
+        /// Returns tuple (SupportsAnsi, LegacyConsole).
+        /// - SupportsAnsi: true when we can emit ANSI sequences and they will be interpreted.
+        /// - LegacyConsole: true when environment is a legacy Windows console that doesn't support ANSI.
+        /// </summary>
         public static (bool SupportsAnsi, bool LegacyConsole) Detect()
         {
             // Running on Windows?
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                // Running under ConEmu?
+                // ConEmu explicit opt-in
                 string? conEmu = Environment.GetEnvironmentVariable("ConEmuANSI");
                 if (!string.IsNullOrEmpty(conEmu) && conEmu.Equals("On", StringComparison.OrdinalIgnoreCase))
                 {
                     return (true, false);
                 }
 
-                bool supportsAnsi = Windows.SupportsAnsi(out bool legacyConsole);
-                return (supportsAnsi, legacyConsole);
+                // ANSICON (older ANSI emulator), Windows Terminal (WT_SESSION), and similar env hints
+                if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("ANSICON")) ||
+                    !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("WT_SESSION")) ||
+                    IsKnownTerminalProgram())
+                {
+                    // Even if these env vars are present, we should still try to enable console mode if possible.
+                    bool supports = Windows.SupportsAnsi(out bool legacyConsole);
+                    return (supports, legacyConsole);
+                }
+
+                // Otherwise query Windows console directly (stdout preferred).
+                bool supportsAnsi = Windows.SupportsAnsi(out bool legacy);
+                return (supportsAnsi, legacy);
             }
+            // Non-Windows platforms: decide from TERM/COLORTERM
             return DetectFromTerm();
         }
 
         private static (bool SupportsAnsi, bool LegacyConsole) DetectFromTerm()
         {
-            // Check if the terminal is of type ANSI/VT100/xterm compatible.
+            // If output is redirected, ANSI sequences probably won't be useful.
+            if (Console.IsOutputRedirected && Console.IsErrorRedirected)
+            {
+                return (false, true);
+            }
+
+            // Common variable that indicates color support (truecolor/24bit or general color)
+            string? colorterm = Environment.GetEnvironmentVariable("COLORTERM");
+            if (!string.IsNullOrWhiteSpace(colorterm))
+            {
+                // If COLORTERM is present, assume ANSI/VT sequences are supported on non-Windows
+                return (true, false);
+            }
+
+            // TERM-based detection (xterm, screen, linux, cygwin, etc).
             string? term = Environment.GetEnvironmentVariable("TERM");
             if (!string.IsNullOrWhiteSpace(term) && _regexes.Any(regex => regex.IsMatch(term)))
             {
                 return (true, false);
             }
 
+            // Fallback: if TERM_PROGRAM suggests a modern terminal (vscode, iTerm, Apple_Terminal)
+            if (IsKnownTerminalProgram())
+            {
+                return (true, false);
+            }
+
             return (false, true);
         }
 
+        private static bool IsKnownTerminalProgram()
+        {
+            string? termProgram = Environment.GetEnvironmentVariable("TERM_PROGRAM");
+            if (string.IsNullOrWhiteSpace(termProgram))
+            {
+                return false;
+            }
+
+            // Some known modern terminal identifiers
+            string[] known =
+            [
+                "vscode",      // VS Code integrated terminal
+                "vscode-insiders",
+                "iTerm.app",   // iTerm2 on macOS
+                "Apple_Terminal",
+                "WindowsTerminal",
+            ];
+
+            return known.Any(k => termProgram.Contains(k, StringComparison.OrdinalIgnoreCase));
+        }
+
         [GeneratedRegex("^xterm")]
         private static partial Regex XtermRegex();
 
@@ -121,12 +180,12 @@ private static (bool SupportsAnsi, bool LegacyConsole) DetectFromTerm()
         [GeneratedRegex("alacritty")]
         private static partial Regex AlacrittyRegex();
 
-        unsafe private static partial class Windows
+        private static partial class Windows
         {
+            private const int STD_OUTPUT_HANDLE = -11;
             private const int STD_ERROR_HANDLE = -12;
 
             private const uint ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004;
-
             private const uint DISABLE_NEWLINE_AUTO_RETURN = 0x0008;
 
             [LibraryImport("kernel32.dll")]
@@ -149,39 +208,54 @@ public static bool SupportsAnsi(out bool isLegacy)
 
                 try
                 {
-                    nint @out = GetStdHandle(STD_ERROR_HANDLE);
-                    if (!GetConsoleMode(@out, out uint mode))
+                    // If output is redirected to a file/pipe, the console APIs will fail. Respect redirection.
+                    if (Console.IsOutputRedirected && Console.IsErrorRedirected)
                     {
-                        // Could not get console mode, try TERM (set in cygwin, WSL-Shell).
-                        (bool ansiFromTerm, bool legacyFromTerm) = DetectFromTerm();
-
-                        isLegacy = ansiFromTerm ? legacyFromTerm : isLegacy;
-                        return ansiFromTerm;
+                        isLegacy = false;
+                        return false;
                     }
 
-                    if ((mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) == 0)
+                    // Prefer stdout handle, then stderr.
+                    nint handle = GetStdHandle(STD_OUTPUT_HANDLE);
+                    if (handle == nint.Zero || !GetConsoleMode(handle, out uint mode))
                     {
-                        isLegacy = true;
-
-                        // Try enable ANSI support.
-                        mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;
-                        if (!SetConsoleMode(@out, mode))
+                        // try stderr as fallback
+                        handle = GetStdHandle(STD_ERROR_HANDLE);
+                        if (handle == nint.Zero || !GetConsoleMode(handle, out mode))
                         {
-                            // Enabling failed.
-                            return false;
+                            // Could not get console mode. Fall back to TERM detection (WSL, MSYS, Cygwin)
+                            (bool ansiFromTerm, bool legacyFromTerm) = DetectFromTerm();
+                            isLegacy = ansiFromTerm ? legacyFromTerm : isLegacy;
+                            return ansiFromTerm;
                         }
+                    }
 
-                        isLegacy = false;
+                    // If virtual terminal processing already enabled, we support ANSI
+                    if ((mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0)
+                    {
+                        return true;
+                    }
+
+                    // Attempt to enable virtual terminal processing.
+                    uint newMode = mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;
+                    if (!SetConsoleMode(handle, newMode))
+                    {
+                        // Enabling failed: treat as legacy Windows console.
+                        isLegacy = true;
+                        return false;
                     }
 
+                    // Successfully enabled.
+                    isLegacy = false;
                     return true;
                 }
                 catch
                 {
-                    // All we know here is that we don't support ANSI.
+                    // Unknown failure; assume no ANSI support.
+                    isLegacy = true;
                     return false;
                 }
             }
         }
     }
-}
+}

docs/api/assemblies/PromptPlusLibrary/ColorExtensions/ToConsoleColor.md

@@ -3,42 +3,9 @@
 // The maintenance and evolution is maintained by the PromptPlus project under MIT license
 // ***************************************************************************************
 
-using System;
-
 namespace PromptPlusLibrary.Drivers
 {
     internal sealed class ConsoleDriveLinux(IProfileDrive profile) : ConsoleDriveWindows(profile)
     {
-        private bool _cursorvisible = true;
-
-        public override bool CursorVisible
-        {
-            get
-            {
-                return _cursorvisible;
-            }
-            set
-            {
-                _cursorvisible = value;
-            }
-        }
-
-        public override void HideCursor()
-        {
-            _cursorvisible = false;
-            if (ProfilePlus.SupportsAnsi)
-            {
-                Console.Write("\x1b[?25l");
-            }
-        }
-
-        public override void ShowCursor()
-        {
-            _cursorvisible = true;
-            if (ProfilePlus.SupportsAnsi)
-            {
-                Console.Write("\x1b[?25h");
-            }
-        }
     }
 }

src/Core/Ansi/AnsiDetector.cs

@@ -27,6 +27,7 @@ internal class ConsoleDriveWindows : IConsole, IConsoleExtend
         private CancellationTokenSource _tokenCancelPress;
         private bool _isExistDefaultCancel;
         private bool _isAbortCtrlC;
+        private bool _cursorvisible = true;
 
         public ConsoleDriveWindows(IProfileDrive profile)
         {
@@ -142,7 +143,7 @@ public Color ForegroundColor
                 }
                 else
                 {
-                    Console.ForegroundColor = value.ToConsoleColor();
+                    Console.ForegroundColor = Color.ToConsoleColor(value);
                 }
             }
         }
@@ -162,7 +163,7 @@ public Color BackgroundColor
                 }
                 else
                 {
-                    Console.BackgroundColor = value.ToConsoleColor();
+                    Console.BackgroundColor =  Color.ToConsoleColor(value);
                 }
             }
         }
@@ -171,11 +172,7 @@ public virtual bool CursorVisible
         {
             get
             {
-#pragma warning disable IDE0079 // Remove unnecessary suppression
-#pragma warning disable CA1416 // Validate platform compatibility
-                return Console.CursorVisible;
-#pragma warning restore CA1416 // Validate platform compatibility
-#pragma warning restore IDE0079 // Remove unnecessary suppression
+                return _cursorvisible;
             }
             set
             {
@@ -195,10 +192,19 @@ private void ShowCusor(bool value)
                 {
                     Console.Write(AnsiSequences.RM());
                 }
+                _cursorvisible = value;
             }
             else
             {
-                Console.CursorVisible = value;
+                try
+                {
+                    Console.CursorVisible = value;
+                }
+                catch 
+                {
+                    //ignore exception for non supported
+                }
+                _cursorvisible = value;
             }
         }
 

src/Drivers/ConsoleDriveLinux.cs

@@ -10,6 +10,20 @@ PromptPlus **Supports 4/8/24-bit colors** in the terminal with auto-detection of
 
 #### [Visit the official page for complete documentation of PromptPlus](https://github.com/FRACerqueira/PromptPlus)
 
+## What's new in V5.0.3
+
+- Improved : AnsiDetector has been improved.
+- Improved : Check requires a terminal/console environment at startup.
+    - System.Console.IsInputRedirected or System.Console.IsOutputRedirected not supported. 
+- Fixed : Cursor visibility/hide on linux system.
+- Fixed : Color conversion methods.
+    - Stackoverflow exception when use ToConsoleColor Extensions. (the Extensions methods were calling themselves recursively).
+    - ForegroundColor/BackgroundColor conversion.
+
+## What's new in V5.0.2
+
+- Fixed : Incorrect PageSize value for widgets.Fixed: ProgressBar control with custom range not updating percentage.
+
 ## What's new in V5.0.1
 
 - Removed: Feature multithreading (Incompatible when another process uses the same output stream).