feat: Convert Lite click interval to CPS with extended range (#19)

* feat: Convert Lite click interval to CPS with extended range

- Replace fixed interval slider (0.1-10s) with logarithmic CPS slider
- Support range from 100 CPS (0.01s) to 1 click per 5 minutes (300s)
- Add dynamic formatting: shows CPS for fast speeds, descriptive text for slow
- Include human-readable descriptions with emojis (⚡ Very Fast to 🦥 Ultra Slow)
- Implement logarithmic scale for smooth control across wide range
- Add validation clamping (0.01s min, 300s max) to prevent unsafe speeds
- Update UI labels and help text to reflect new CPS-based interface

Addresses user request for more precise control over click timing,
especially for high-speed automation (up to 100 CPS).

* refactor: Extract magic numbers and use switch statements

Code quality improvements based on code review:

- Add SpeedLimit enum with named constants for intervals and CPS limits
  - minInterval (0.01s = 100 CPS)
  - maxInterval (300s = 1 click per 5 min)
  - safeGuardInterval (0.001s to prevent division by zero)

- Add SpeedThreshold enum with named constants for speed tiers
  - CPS thresholds for formatting (high/medium/low)
  - CPS thresholds for descriptions (veryFast/fast/normal)
  - Interval thresholds for slow speeds (slow/verySlow)

- Refactor formatClickSpeed() to use switch statement
  - Replace if/else chain with pattern matching
  - More idiomatic Swift code

- Refactor describeClickSpeed() to use nested switch statements
  - Primary switch on CPS for fast speeds
  - Secondary switch on interval for slow speeds
  - Eliminates all magic numbers

Benefits:
- Self-documenting code with clear intent
- Easier to maintain and adjust thresholds
- More idiomatic Swift patterns
- Better readability

---------

Co-authored-by: Claude <[email protected]>

Author: jsonify

Sources/ClickIt/Lite/SimplifiedMainView.swift

@@ -9,6 +9,34 @@ import SwiftUI
 
 struct SimplifiedMainView: View {
 
+    // MARK: - Speed Configuration
+
+    /// Speed limits for click intervals
+    private enum SpeedLimit {
+        static let minInterval: Double = 0.01   // 100 CPS
+        static let maxInterval: Double = 300.0  // 1 click per 5 min
+        static var minCPS: Double { 1.0 / maxInterval }
+        static var maxCPS: Double { 1.0 / minInterval }
+        static let safeGuardInterval: Double = 0.001 // Prevents division by zero
+    }
+
+    /// Thresholds for speed descriptions and formatting
+    private enum SpeedThreshold {
+        // CPS thresholds for formatting
+        static let highCPS: Double = 10.0
+        static let mediumCPS: Double = 1.0
+        static let lowCPS: Double = 0.1
+
+        // CPS thresholds for descriptions
+        static let veryFastCPS: Double = 50.0
+        static let fastCPS: Double = 10.0
+        static let normalCPS: Double = 1.0
+
+        // Interval thresholds for descriptions (seconds)
+        static let slowInterval: Double = 60.0
+        static let verySlowInterval: Double = 120.0
+    }
+
     // MARK: - Properties
 
     @StateObject private var viewModel = SimpleViewModel()
@@ -164,26 +192,102 @@ struct SimplifiedMainView: View {
     private var clickIntervalSection: some View {
         VStack(alignment: .leading, spacing: 8) {
             HStack {
-                Text("Click Interval")
+                Text("Click Speed")
                     .font(.headline)
                 Spacer()
-                Text("\(String(format: "%.1f", viewModel.clickInterval))s")
+                Text(formatClickSpeed(interval: viewModel.clickInterval))
                     .font(.system(.body, design: .monospaced))
                     .foregroundColor(.blue)
             }
 
-            Slider(value: $viewModel.clickInterval, in: 0.1...10.0, step: 0.1)
-                .disabled(viewModel.isRunning)
+            // Logarithmic slider for CPS
+            // Maps log scale to linear slider for better UX across wide range
+            Slider(
+                value: Binding(
+                    get: {
+                        // Convert interval to log(CPS)
+                        let cps = 1.0 / max(viewModel.clickInterval, SpeedLimit.safeGuardInterval)
+                        return log10(cps)
+                    },
+                    set: { logCPS in
+                        // Convert log(CPS) back to interval
+                        let cps = pow(10.0, logCPS)
+                        let interval = 1.0 / cps
+                        // Clamp to valid range
+                        viewModel.clickInterval = min(max(interval, SpeedLimit.minInterval), SpeedLimit.maxInterval)
+                    }
+                ),
+                in: log10(SpeedLimit.minCPS)...log10(SpeedLimit.maxCPS)
+            )
+            .disabled(viewModel.isRunning)
 
             HStack {
-                Text("0.1s")
+                Text("1 / 5 min")
                     .font(.caption)
                     .foregroundColor(.secondary)
                 Spacer()
-                Text("10s")
+                Text("100 CPS")
                     .font(.caption)
                     .foregroundColor(.secondary)
             }
+
+            // Human-readable description
+            Text(describeClickSpeed(interval: viewModel.clickInterval))
+                .font(.caption)
+                .foregroundColor(.secondary)
+                .multilineTextAlignment(.center)
+                .frame(maxWidth: .infinity)
+        }
+    }
+
+    // MARK: - Helper Methods
+
+    /// Format click speed for display
+    private func formatClickSpeed(interval: Double) -> String {
+        let cps = 1.0 / interval
+        let format: String
+
+        switch cps {
+        case SpeedThreshold.highCPS...:
+            format = "%.0f CPS"
+        case SpeedThreshold.mediumCPS..<SpeedThreshold.highCPS:
+            format = "%.1f CPS"
+        case SpeedThreshold.lowCPS..<SpeedThreshold.mediumCPS:
+            format = "%.2f CPS"
+        default:
+            format = "%.3f CPS"
+        }
+
+        return String(format: format, cps)
+    }
+
+    /// Describe click speed in human-readable terms
+    private func describeClickSpeed(interval: Double) -> String {
+        let cps = 1.0 / interval
+
+        switch cps {
+        case SpeedThreshold.veryFastCPS...:
+            return "⚡ Very Fast - \(String(format: "%.1f", interval * 1000))ms per click"
+
+        case SpeedThreshold.fastCPS..<SpeedThreshold.veryFastCPS:
+            return "🚀 Fast - \(String(format: "%.2f", interval))s per click"
+
+        case SpeedThreshold.normalCPS..<SpeedThreshold.fastCPS:
+            return "⏱️ Normal - 1 click every \(String(format: "%.1f", interval))s"
+
+        default:
+            // For CPS < 1.0, describe by interval instead
+            switch interval {
+            case ..<SpeedThreshold.slowInterval:
+                return "🐌 Slow - 1 click every \(String(format: "%.1f", interval))s"
+
+            case SpeedThreshold.slowInterval..<SpeedThreshold.verySlowInterval:
+                return "🐢 Very Slow - 1 click every \(Int(interval))s (~\(Int(interval/60)) min)"
+
+            default:
+                let minutes = Int(interval / 60)
+                return "🦥 Ultra Slow - 1 click every \(minutes) minutes"
+            }
         }
     }