BlazorUI theme improvements ii (#12320)

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.razor.cs

@@ -111,7 +111,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             }
             catch
             {
-                // Interop unavailable (e.g. during prerender) — stay at the fixed virtual size.
+                // Interop unavailable (e.g. during prerender) - stay at the fixed virtual size.
                 _sizeRegistered = false;
             }
         }
@@ -131,7 +131,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         }
         catch
         {
-            // Interop unavailable (e.g. during prerender) — zoom stays inert.
+            // Interop unavailable (e.g. during prerender) - zoom stays inert.
             _zoomRegistered = false;
         }
     }
@@ -279,7 +279,7 @@ private void Recompute()
 
         // Decide whether to (re)play the entry animation. We key off a signature of the data
         // values (not pixel positions), so data changes replay the animation while resize/zoom/pan
-        // — which leave the values unchanged — do not.
+        // - which leave the values unchanged - do not.
         long sig = ComputeSignature();
         bool dataChanged = _initialized && sig != _lastSig;
         _lastSig = sig;
@@ -656,7 +656,7 @@ private string? DataGroupStyle
         }
     }
 
-    /// <summary>Class for the series (line/area) group — animates with the same proven group mechanism.
+    /// <summary>Class for the series (line/area) group - animates with the same proven group mechanism.
     /// Radial/circular charts (e.g. radar) grow from the center so the web matches its joint points.</summary>
     private string SeriesGroupClass =>
         CanAnimate

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.ts

@@ -5,7 +5,7 @@ namespace BitBlazorUI {
         drag: boolean;
     }
 
-    // BitChart pointer interop — used for responsive sizing (always) and zoom/pan (optional).
+    // BitChart pointer interop - used for responsive sizing (always) and zoom/pan (optional).
     // Computes normalized cursor fractions and forwards wheel/drag gestures to .NET. All drawing
     // (geometry, scales, layout, animation) is done in C# and rendered as plain SVG.
     export class BitChart {

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/Rendering/BitChartDataElement.cs

@@ -18,7 +18,7 @@ public sealed class BitChartDataElement
     public BitChartSvgNode? BorderShape { get; init; }
     /// <summary>Per-element entry animation CSS class (e.g. grow from baseline for bars, pop for points).</summary>
     public string? EnterAnim { get; init; }
-    /// <summary>Transform origin (in view-box/pixel coordinates) for the entry animation — the bar baseline
+    /// <summary>Transform origin (in view-box/pixel coordinates) for the entry animation - the bar baseline
     /// or the point center.</summary>
     public double AnimOriginX { get; init; }
     public double AnimOriginY { get; init; }

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/Rendering/BitChartRenderer.Series.cs

@@ -672,7 +672,7 @@ private static string BuildPath(List<(double x, double y)> p, double tension, Bi
         return sb.ToString();
     }
 
-    /// <summary>Monotone cubic interpolation (Fritsch–Carlson) emitted as cubic beziers — never overshoots.</summary>
+    /// <summary>Monotone cubic interpolation (Fritsch–Carlson) emitted as cubic beziers - never overshoots.</summary>
     private static string MonotonePath(List<(double x, double y)> p)
     {
         int n = p.Count;

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/Rendering/BitChartRenderer.cs

@@ -3,7 +3,7 @@ namespace Bit.BlazorUI;
 
 /// <summary>
 /// Computes a <see cref="BitChartScene"/> (pure SVG primitives + interaction metadata) from a
-/// <see cref="BitChartConfig"/>. This is the heart of the native Blazor renderer — no JavaScript or
+/// <see cref="BitChartConfig"/>. This is the heart of the native Blazor renderer - no JavaScript or
 /// canvas is involved.
 /// </summary>
 public sealed partial class BitChartRenderer

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/Rendering/BitChartScene.cs

@@ -9,7 +9,7 @@ public sealed class BitChartScene
 
     public List<BitChartSvgNode> Background { get; } = new();
     /// <summary>Series paths (lines + area fills) drawn above the grid and below the data points.
-    /// Rendered in an animated group so every line — solid, dashed or per-segment — animates uniformly.</summary>
+    /// Rendered in an animated group so every line - solid, dashed or per-segment - animates uniformly.</summary>
     public List<BitChartSvgNode> Series { get; } = new();
     public List<BitChartDataElement> Elements { get; } = new();
     public List<BitChartSvgNode> Foreground { get; } = new();

src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/Rendering/Plugins/BitChartCenterTextPlugin.cs

@@ -2,7 +2,7 @@
 namespace Bit.BlazorUI;
 
 /// <summary>
-/// Draws one or more lines of text in the center of a doughnut/pie chart — a very common
+/// Draws one or more lines of text in the center of a doughnut/pie chart - a very common
 /// dashboard pattern (e.g. a total or KPI in the cutout).
 /// </summary>
 public sealed class BitChartCenterTextPlugin : IBitChartPlugin

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor

@@ -289,7 +289,7 @@
                         {
                             <div class="bit-dtg-row bit-dtg-infinite-end" role="row" style="grid-template-columns:var(--bit-dtg-template);">
                                 <div class="bit-dtg-cell" role="gridcell" style="grid-column:1 / -1;">
-                                    <span>— End of results —</span>
+                                    <span>- End of results -</span>
                                 </div>
                             </div>
                         }

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.razor.cs

@@ -24,7 +24,7 @@ public partial class BitDataGrid<TItem> : ComponentBase, IAsyncDisposable
 
     /// <summary>
     /// Infinite-scrolling data callback. When set, the grid loads rows in batches and appends the
-    /// next batch automatically as the user scrolls to the end of the viewport — with no paging UI
+    /// next batch automatically as the user scrolls to the end of the viewport - with no paging UI
     /// and no knowledge of the total row count. Each call receives a <see cref="BitDataGridReadRequest"/>
     /// whose <c>Skip</c> is the number of rows already loaded and whose <c>Take</c> is
     /// <see cref="LoadMoreBatchSize"/>. The grid stops requesting more once a batch returns fewer rows
@@ -83,7 +83,7 @@ public partial class BitDataGrid<TItem> : ComponentBase, IAsyncDisposable
     /// respond to arrow keys, <kbd>Home</kbd>/<kbd>End</kbd>, <kbd>PageUp</kbd>/<kbd>PageDown</kbd>
     /// (and <kbd>Ctrl</kbd> variants). <kbd>Enter</kbd>/<kbd>F2</kbd> begins editing an editable
     /// cell and <kbd>Esc</kbd> cancels. Mirrors react-data-grid's Cell Navigation. No JavaScript
-    /// is used — focus is driven by Blazor's built-in <c>FocusAsync</c>.
+    /// is used - focus is driven by Blazor's built-in <c>FocusAsync</c>.
     /// </summary>
     [Parameter] public bool CellNavigation { get; set; }
 
@@ -260,7 +260,7 @@ internal bool AddColumn(BitDataGridColumn<TItem> column)
         _columns.Add(column);
         _columnsById[column.Id] = column;
 
-        // A column registering itself must not trigger a fresh data fetch in server/infinite modes —
+        // A column registering itself must not trigger a fresh data fetch in server/infinite modes -
         // doing so once per column re-queries the backend (or resets the infinite list) repeatedly.
         // Instead recompute footer/aggregate values from the rows already loaded and just re-render so
         // late-registered footer columns still get their values. In client mode RefreshAsync only
@@ -345,8 +345,8 @@ internal void RemoveColumn(BitDataGridColumn<TItem> column)
     /// <summary>
     /// Re-keys a column in the registry after its <see cref="BitDataGridColumn{TItem}.Id"/> changes
     /// (its <c>ColumnId</c>/<c>Field</c> parameters were mutated after the initial registration).
-    /// Without this the registry keeps the stale key and sort/filter/group lookups — which resolve
-    /// columns by id — would no longer find the column. Active descriptors are migrated to the new id.
+    /// Without this the registry keeps the stale key and sort/filter/group lookups - which resolve
+    /// columns by id - would no longer find the column. Active descriptors are migrated to the new id.
     /// </summary>
     internal void UpdateColumnRegistration(BitDataGridColumn<TItem> column, string oldId)
     {
@@ -705,7 +705,7 @@ private async Task<bool> LoadNextBatchAsync()
 
         // Only after a batch was genuinely appended do we ask JS whether the viewport still isn't
         // filled (e.g. a short first batch) and therefore needs another load. Gating the re-check on a
-        // real append is essential: re-checking after a no-op load would spin a tight JS<->.NET loop —
+        // real append is essential: re-checking after a no-op load would spin a tight JS<->.NET loop -
         // while the initial batch is still in flight the viewport is empty (so it always looks "near the
         // end"), every check() would re-enter here, hit the _infiniteLoading guard, return immediately
         // and re-check again, starving the in-flight batch's continuation and freezing the UI thread.

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridCellEditor.razor

@@ -138,7 +138,7 @@
     // <input type="datetime-local"> has no time-zone/Kind information, so a naive parse back through
     // the property accessor yields DateTimeKind.Unspecified and would drop the original Utc/Local
     // semantics (changing the represented instant on round-trip). Re-stamp the parsed value with the
-    // current value's Kind so edited DateTimes preserve Utc/Local consistently — mirroring how
+    // current value's Kind so edited DateTimes preserve Utc/Local consistently - mirroring how
     // SetDateTimeOffset reconstructs the offset.
     private void SetDateTime(object? raw)
     {

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridDataProcessor.cs

@@ -334,7 +334,7 @@ private static bool TryDateOnlyEquals(object? value, object? filterValue, out bo
     // Coerces a filter operand to the row value's runtime type before comparison. This mirrors the
     // type-specific parsing in BitDataGridPropertyAccessor.TryConvertValue (Guid/DateOnly/TimeOnly/
     // DateTimeOffset and enums are not handled by Convert.ChangeType), so a filter value entered as a
-    // string is converted to the property's real type the same way edits are — keeping filtering,
+    // string is converted to the property's real type the same way edits are - keeping filtering,
     // sorting and editing consistent. Parsing uses the invariant culture to match the ISO/invariant
     // strings the editors emit. Returns false when the operand can't be turned into the target type, so
     // callers fail the comparison closed instead of comparing mixed types (which the value comparer

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridPropertyAccessor.cs

@@ -63,7 +63,7 @@ public bool TryConvertValue(object? value, out object? result)
     {
         // A cleared edit can arrive as an empty string (e.g. a select/text editor reset to "") rather
         // than null. Normalize it to null up front so the nullable-target handling below clears the
-        // value — but only for non-string targets. For a string-typed property, "" is a legitimate
+        // value - but only for non-string targets. For a string-typed property, "" is a legitimate
         // user edit (an intentionally emptied text cell) and must be preserved rather than nulled.
         if (value is string es && es.Length == 0 && PropertyType != typeof(string))
             value = null;

src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/Infrastructure/BitDataGridValueComparer.cs

@@ -22,7 +22,7 @@ internal static bool HasMeaningfulToString(Type type)
     // also guarantees an equal GetHashCode, i.e. the BCL scalar/value types whose CompareTo and
     // GetHashCode are defined consistently. An arbitrary custom IComparable may report CompareTo == 0 for
     // two instances while their (un-overridden) GetHashCode differ, which would group/sort them as equal
-    // yet hash them apart — an Equals/GetHashCode contract violation. For those types we fall back to the
+    // yet hash them apart - an Equals/GetHashCode contract violation. For those types we fall back to the
     // same normalized projection (meaningful ToString, else the canonical key) that GetHashCode uses, so
     // comparison and hashing always agree.
     internal static bool IsTrustedComparable(Type type)
@@ -96,7 +96,7 @@ public int Compare(object? x, object? y)
 /// <summary>
 /// Equality comparer that mirrors <see cref="BitDataGridValueComparer"/>'s ordering semantics
 /// (two values are equal when the comparer ranks them as equal), so grouping keys collapse the same
-/// way sorting and Equals-based filtering treat them — e.g. strings group case-insensitively.
+/// way sorting and Equals-based filtering treat them - e.g. strings group case-insensitively.
 /// </summary>
 internal sealed class BitDataGridValueEqualityComparer : IEqualityComparer<object?>
 {
@@ -106,11 +106,11 @@ internal sealed class BitDataGridValueEqualityComparer : IEqualityComparer<objec
 
     // Must stay consistent with Equals: values the comparer treats as equal have to hash alike.
     // Strings compare case-insensitively, so hash them that way. Trusted BCL comparables fall back to
-    // their own hash code (where CompareTo == 0 implies an equal hash). For any other value — including
-    // a custom IComparable that the comparer does NOT shortcut — the comparer ranks two instances equal
+    // their own hash code (where CompareTo == 0 implies an equal hash). For any other value - including
+    // a custom IComparable that the comparer does NOT shortcut - the comparer ranks two instances equal
     // only when the type has a meaningful ToString() override and their text matches; hash on that same
     // canonical string. When ToString() is not overridden the comparer keeps distinct instances distinct
-    // via the same collision-free canonical key it orders them by, so hash on that key too — keeping
+    // via the same collision-free canonical key it orders them by, so hash on that key too - keeping
     // Equals/GetHashCode consistent without the identity-hash collisions a raw RuntimeHelpers.GetHashCode
     // could introduce. Null hashes to 0.
     public int GetHashCode(object? obj) => obj switch

src/BlazorUI/Bit.BlazorUI.Extras/Components/MarkdownViewer/Parsing/BitMarkdownViewerDelimiterResolver.cs

@@ -50,7 +50,7 @@ public static void Process(List<Tok> tokens, BitMarkdownViewerPipeline pipeline)
                 if (opener.Kind == TokKind.Delim && opener.Active && opener.CanOpen
                     && opener.DelimChar == dc)
                 {
-                    // CommonMark "rule of three" — scoped to emphasis processors only,
+                    // CommonMark "rule of three" - scoped to emphasis processors only,
                     // so non-emphasis pairs (e.g. ~~) aren't rejected before TryCreate runs.
                     bool oddMatch = processor.AppliesRuleOfThree
                         && (closer.CanOpen || opener.CanClose)

src/BlazorUI/Bit.BlazorUI.Extras/Components/MarkdownViewer/Pipeline/IBitMarkdownViewerExtension.cs

@@ -9,7 +9,7 @@ namespace Bit.BlazorUI;
 /// A built <see cref="BitMarkdownViewerPipeline"/> is immutable and is cached and shared
 /// across concurrent parses, components and (in Blazor Server) circuits. The pipeline also
 /// caches and reuses every registration across parses and renders, so anything an extension
-/// registers — parsers, delimiter/AST processors and renderers — MUST be stateless and
+/// registers - parsers, delimiter/AST processors and renderers - MUST be stateless and
 /// thread-safe: it must not retain mutable state between calls. All per-parse/per-render
 /// state must live solely in the <c>state</c>/<c>builder</c> objects passed to each call.
 /// Creating a new instance inside <see cref="Setup"/> does not make a stateful component safe,

src/BlazorUI/Bit.BlazorUI.Extras/Components/QuickGrid/Pagination/BitQuickGridPaginator.razor.cs

@@ -60,7 +60,7 @@ public BitQuickGridPaginator()
         // The "total item count" handler doesn't need to do anything except cause this component to
         // re-render. Invoking this EventCallback already routes through the paginator's
         // IHandleEvent.HandleEventAsync (the receiver is `this`), which re-renders the component on its
-        // own, so the callback body is intentionally empty — calling StateHasChanged() here as well
+        // own, so the callback body is intentionally empty - calling StateHasChanged() here as well
         // would queue a second, redundant render.
         _totalItemCountChanged = new(EventCallback.Factory.Create<BitQuickGridPaginationState>(this, () => { }));
     }