feat: Simplify store configuration with default middleware and diagnostics support

Author: mashrulhaque

README.md

@@ -23,8 +23,10 @@ Inspired by Zustand • Built for C# • Designed for Developer Joy
 - ⚡ **Blazing-fast performance** - Granular updates with selectors for 25x fewer re-renders in high-frequency scenarios
 - 🎨 **Smart optimizations** - Memoization, batch updates, and lazy loading built right in
 - 🧰 **Powerful DevTools** - Time-travel debugging with Redux DevTools integration
+- 📊 **Built-in Diagnostics** - Real-time monitoring of state changes, renders, and performance metrics (DEBUG mode)
 - 🚀 **Async-first** - First-class support for async operations without extra ceremony
 - 📦 **Tiny API surface** - Learn the entire API in minutes, not days
+- 🎁 **Simplified API** - One-liner setup with `WithDefaults()` for common configurations
 
 **If you've used Zustand in React, you'll feel right at home. If you haven't, you'll wonder why state management was ever complicated.**
 
@@ -50,6 +52,7 @@ Inspired by Zustand • Built for C# • Designed for Developer Joy
   - [Async Operations](#async-operations)
   - [Persistence](#persistence)
   - [DevTools](#devtools)
+  - [Diagnostics & Monitoring](#diagnostics--monitoring) 🆕
   - [Middleware](#middleware)
 - [API Reference](#api-reference)
 - [Best Practices](#best-practices)
@@ -98,11 +101,22 @@ public record CounterState(int Count, string? LastAction = null)
 In your `Program.cs`:
 
 ```csharp
+// Simple - with default setup (DevTools + Logging)
 builder.Services.AddStore(
-    new CounterState(0),  // Initial state
-    store => store.WithDevTools("Counter"));  // Optional: Enable DevTools
+    new CounterState(0),
+    (store, sp) => store.WithDefaults(sp, "Counter"));
+
+// Or manual configuration
+builder.Services.AddStore(
+    new CounterState(0),
+    (store, sp) => store
+        .WithJSRuntime(sp.GetRequiredService<IJSRuntime>())
+        .WithDevTools("Counter")
+        .WithLogging());
 ```
 
+> 💡 **New in this version**: Use `WithDefaults()` for one-liner setup with JSRuntime, DevTools, and Logging!
+
 ### Step 3: Use in Components
 
 ```razor
@@ -1184,20 +1198,30 @@ async Task LoadUsers()
 Automatically save and restore state:
 
 ```csharp
+// NEW: Simplified API
 builder.Services.AddStore(
     new AppState(),
-    store => store.WithPersistence(
-        PersistenceType.LocalStorage,  // or SessionStorage
-        "app-state",                    // storage key
-        debounceMs: 500                 // optional: debounce saves
-    ));
+    (store, sp) => store
+        .WithDefaults(sp, "MyApp")
+        .WithPersistence(sp, "app-state"));  // Auto-creates LocalStorageProvider
+
+// Or with manual provider configuration
+builder.Services.AddStore(
+    new AppState(),
+    (store, sp) => {
+        var jsRuntime = sp.GetRequiredService<IJSRuntime>();
+        var localStorage = new LocalStorageProvider(jsRuntime);
+        return store.WithPersistence(localStorage, "app-state");
+    });
 ```
 
 State is automatically:
 - Saved to storage on every update (debounced)
 - Restored when the app loads
 - Serialized/deserialized with System.Text.Json
 
+> 💡 **New**: The simplified `WithPersistence(sp, key)` method automatically creates a LocalStorageProvider for you!
+
 ### DevTools
 
 Time-travel debugging with Redux DevTools:
@@ -1217,6 +1241,101 @@ builder.Services.AddStore(
 
 **Install:** [Redux DevTools Extension](https://github.com/reduxjs/redux-devtools)
 
+---
+
+### Diagnostics & Monitoring
+
+> 🆕 **New Feature**: Real-time diagnostics panel for monitoring state changes, component renders, and performance.
+
+**Built-in diagnostics system** (available only in DEBUG builds) provides deep visibility into your application's state management:
+
+#### Setup
+
+```csharp
+// In Program.cs
+builder.Services.AddStoreDiagnostics();  // Register diagnostics service
+
+builder.Services.AddStore(
+    new CounterState(0),
+    (store, sp) => store
+        .WithDefaults(sp, "Counter")
+        .WithDiagnosticsIfAvailable(sp));  // Safely adds diagnostics if available
+```
+
+#### Features
+
+The diagnostics system tracks:
+
+- **📜 Action History** - Every state update with:
+  - Action names and timestamps
+  - Before/after state snapshots
+  - State diffs showing what changed
+  - Update duration timings
+
+- **📊 Performance Metrics** - Real-time performance data:
+  - Average, min, and max update times
+  - Total update count
+  - P95/P99 percentiles
+
+- **🎨 Render Tracking** - Component render monitoring:
+  - Which components rendered and when
+  - Render frequency per component
+  - Render counts for optimization insights
+
+- **🔌 Subscription Monitoring** - Track all subscriptions:
+  - Active subscriptions count
+  - Component lifecycle tracking
+  - Subscription creation/disposal events
+
+#### Usage
+
+Add the `DiagnosticPanel` component to any page:
+
+```razor
+@page "/diagnostics"
+
+<h1>Store Diagnostics</h1>
+
+#if DEBUG
+<DiagnosticPanel DisplayMode="DiagnosticDisplayMode.Inline" InitiallyCollapsed="false" />
+#else
+<p>Diagnostics only available in DEBUG builds</p>
+#endif
+```
+
+**Display modes:**
+- `Inline` - Full-width panel embedded in page
+- `Floating` - Draggable overlay (default)
+
+**Example diagnostic output:**
+
+```
+📊 Performance Metrics
+Store: Counter
+├─ Total Updates: 47
+├─ Avg Duration: 0.8ms
+├─ Min Duration: 0.3ms
+├─ Max Duration: 2.1ms
+└─ P95 Duration: 1.5ms
+
+📜 Recent Actions
+1. INCREMENT (0.5ms ago)
+   Counter: 5 → 6
+2. INCREMENT (1.2s ago)
+   Counter: 4 → 5
+3. RESET (5.3s ago)
+   Counter: 15 → 0
+
+🎨 Component Renders
+├─ Counter.razor: 8 renders
+├─ CounterDisplay.razor: 8 renders
+└─ CounterStats.razor: 3 renders
+```
+
+> ⚠️ **Note**: Diagnostics are compiled out in Release builds to ensure zero performance overhead in production.
+
+---
+
 ### Middleware
 
 Intercept state updates for cross-cutting concerns:
@@ -1251,6 +1370,7 @@ builder.Services.AddStore(
 - `DevToolsMiddleware` - Redux DevTools integration
 - `PersistenceMiddleware` - LocalStorage/SessionStorage sync
 - `LoggingMiddleware` - State change logging
+- `DiagnosticsMiddleware` - Performance monitoring and diagnostics (DEBUG only)
 
 ---
 
@@ -1298,19 +1418,37 @@ public interface IStore<TState>
 ### Registration
 
 ```csharp
-// Simple
+// Simple - no configuration
 services.AddStore(new MyState());
 
-// With configuration
+// With defaults (recommended)
 services.AddStore(
     new MyState(),
-    store => store
+    (store, sp) => store.WithDefaults(sp, "MyStore"));
+
+// Full configuration
+services.AddStore(
+    new MyState(),
+    (store, sp) => store
+        .WithDefaults(sp, "StoreName")
+        .WithPersistence(sp, "storage-key")
+        .WithDiagnosticsIfAvailable(sp)
+        .WithMiddleware<MyMiddleware>()
+);
+
+// Manual configuration (for advanced scenarios)
+services.AddStore(
+    new MyState(),
+    (store, sp) => store
+        .WithJSRuntime(sp.GetRequiredService<IJSRuntime>())
         .WithDevTools("StoreName")
-        .WithPersistence(PersistenceType.LocalStorage, "key")
+        .WithLogging()
         .WithMiddleware<MyMiddleware>()
 );
 ```
 
+> 💡 **Tip**: The new `(store, sp) =>` pattern gives you access to the service provider for dependency injection within store configuration.
+
 ---
 
 ## Best Practices
@@ -1629,6 +1767,30 @@ Explore comprehensive documentation:
 
 ---
 
+## What's New
+
+### Recent Updates
+
+**🆕 Diagnostics & Monitoring System**
+- Built-in diagnostics panel for monitoring state changes, renders, and performance
+- Real-time action history with state diffs
+- Performance metrics tracking (update timings, P95/P99)
+- Component render tracking and subscription monitoring
+- Zero performance overhead (DEBUG-only compilation)
+
+**🎁 Simplified API**
+- `WithDefaults(sp, name)` - One-liner for common setup
+- `WithPersistence(sp, key)` - Simplified persistence without manual provider creation
+- `WithDiagnosticsIfAvailable(sp)` - Safe diagnostics addition
+- New `(store, sp) =>` registration pattern for dependency injection
+
+**📦 Enhanced Store Registration**
+- Service provider access in configuration
+- Cleaner, more composable builder pattern
+- Better support for dependency injection
+
+---
+
 ## Contributing
 
 We welcome contributions! This library is designed to stay simple and focused.