feat!: collapse the two-level enable model into one master switch (#50)

Signed-off-by: Kevin Cui <bh@bugs.cc>

Author: BlackHole1

README.md

@@ -61,10 +61,10 @@ Either way, the app keeps itself up to date via Sparkle.
 - **Lock or switch** — per-app and per-URL rules can *lock* an input source
   (re-applied whenever it drifts) or just *switch* to it once when you focus the
   app or page, then step out of the way and let you change it freely.
-- **Lock globally, or just switch** — one **Enable LockIME** switch powers
-  everything; a subordinate **Enable locking** toggle controls only the
-  continuous lock. Turn locking off to use LockIME as a pure per-app/per-site
-  switcher — it switches you in, then leaves you free, pinning nothing.
+- **Lock globally, or just switch** — set the global default to one input
+  source to pin it everywhere, or set it to **None** to use LockIME as a pure
+  per-app/per-site switcher — it switches you in, then leaves you free, pinning
+  nothing.
 - **Flexible URL matching** — per-URL rules (enhanced mode) match by a domain and
   its subdomains, an exact domain, a domain keyword, or a regular expression over
   the full URL, and apply in a priority order you drag to arrange — first match
@@ -147,7 +147,7 @@ a GUI switcher).
 ## Automation
 
 LockIME exposes a `lockime://` URL scheme so other apps, scripts, Shortcuts, and
-launchers can drive it — toggle locking, retarget the input source, manage
+launchers can drive it — turn it on or off, retarget the input source, manage
 rules, and read state back with [x-callback-url](https://x-callback-url.com)
 callbacks. It is off by default — turn it on in **Settings ▸ General ▸
 Automation**.

Sources/LockIME/API/URLCommandHandler.swift

@@ -49,16 +49,13 @@ final class URLCommandHandler {
     /// `[[String: Any]]` array) for query commands, `nil` for actions.
     private func perform(_ command: URLCommand) -> Result<Any?, URLCommandError> {
         switch command {
-        // Master ("Enable LockIME") — gates the whole app.
+        // The single on/off ("Enable LockIME") — gates the whole app.
         case .lock:
             state.setMasterEnabled(true); return .success(nil)
         case .unlock:
             state.setMasterEnabled(false); return .success(nil)
         case .toggleLock:
             state.setMasterEnabled(!state.isAppEnabled); return .success(nil)
-        // Lock sub-toggle ("Enable locking").
-        case .setLocking(let flag):
-            state.setLockingEnabled(resolve(flag, current: state.config.lockingEnabled)); return .success(nil)
 
         // Global source targeting
         case .lockToSource(let selector):
@@ -243,11 +240,8 @@ final class URLCommandHandler {
 
     private func statusPayload() -> [String: Any] {
         var payload: [String: Any] = [
-            // `enabled` = the master ("Enable LockIME"); `lockingEnabled` = the
-            // lock sub-toggle; `locked` = both (a continuous lock is in force).
+            // `enabled` = the single "Enable LockIME" switch.
             "enabled": state.isAppEnabled,
-            "lockingEnabled": state.config.lockingEnabled,
-            "locked": state.isLocked,
             "enhancedMode": state.config.enhancedModeEnabled,
             "launchAtLogin": state.launchAtLoginActive,
             "accessibilityGranted": state.accessibilityGranted,

Sources/LockIME/AppState.swift

@@ -101,20 +101,12 @@ final class AppState {
     /// pane can route the user to General's single Accessibility grant.
     var settingsTab: SettingsTab = .general
 
-    /// The master on/off — "Enable LockIME". Mirrors `config.isEnabled`; gates
-    /// the whole app (both locking and switching). Bound by the General master
-    /// toggle.
+    /// The single on/off — "Enable LockIME". Mirrors `config.isEnabled`; gates
+    /// the whole app (both locking and switching). Bound by the General toggle,
+    /// and what every state surface reflects (tray/About icon, menu glyph +
+    /// "Enabled/Disabled" header, the locked-source checkmark).
     var isAppEnabled: Bool { config.isEnabled }
 
-    /// Whether a **continuous lock** is in force right now: the master is on *and*
-    /// the lock sub-toggle is on. This is what the padlock surfaces represent
-    /// (tray/About icon, menu glyph + "Locked/Unlocked" header, the locked-source
-    /// checkmark) — they speak to the *lock* capability, not mere app activeness.
-    /// For anyone who leaves locking on (the default) this equals `isEnabled`, so
-    /// those surfaces look exactly as before; only the opt-in pure-switch mode
-    /// (master on, locking off) shows them "unlocked".
-    var isLocked: Bool { config.isEnabled && config.lockingEnabled }
-
     /// The SwiftData container backing the activation log (for `.modelContainer`).
     var modelContainer: ModelContainer { logStore.container }
 
@@ -229,17 +221,15 @@ final class AppState {
         updateController.onCheckOutcome = { [weak self] outcome in self?.presentUpdateOutcome(outcome) }
         updateController.start()
 
-        // Global toggle-lock shortcut: flips the master ("Enable LockIME") on/off,
-        // the app's quick stop/start. `lockingEnabled` persists across toggles, so
-        // a pure-switch user (locking off) toggling the app off then on stays in
-        // pure-switch mode rather than silently re-engaging the lock.
+        // Global toggle-lock shortcut: flips "Enable LockIME" on/off — the
+        // app's quick stop/start.
         KeyboardShortcuts.onKeyUp(for: .toggleLock) { [weak self] in
             guard let self else { return }
             self.setMasterEnabled(!self.isAppEnabled)
         }
 
         // Global "lock to previous/next source" — cycle the global target
-        // through the input-source list (wrapping), turning locking on.
+        // through the input-source list (wrapping), turning LockIME on.
         KeyboardShortcuts.onKeyUp(for: .globalPreviousSource) { [weak self] in
             self?.cycleGlobalSource(.previous)
         }
@@ -343,39 +333,26 @@ final class AppState {
         commit(reason: .lockEngaged)
     }
 
-    /// Toggle the **continuous-lock** capability (the General "Enable locking"
-    /// sub-toggle), subordinate to the master. Turning it off drops every standing
-    /// lock — the global default, per-app `.locked` rules, URL `.lock` rules, and
-    /// the address-bar lock all go inert — while one-shot switch rules keep firing.
-    /// That is the "act like Input Source Pro" mode: per-context auto-switch with
-    /// no global lock. No effect while the master is off (the app is fully idle).
-    func setLockingEnabled(_ on: Bool) {
-        config.lockingEnabled = on
-        commit(reason: .lockEngaged)
-    }
-
     func setDefaultSource(_ id: InputSourceID?) {
         config.defaultSourceID = id
         commit()
     }
 
     /// Lock to a specific source from the menu bar: make it the global target and
-    /// engage the lock in a single commit — turning **both** the master and the
-    /// lock sub-toggle on, so a one-tap menu pick always pins, even from a
-    /// pure-switch or fully-off state. Clicking the already-locked source instead
-    /// clears the global target via `setDefaultSource(nil)` (leaving the app and
+    /// turn LockIME on in a single commit, so a one-tap menu pick always pins,
+    /// even from an off state. Clicking the already-locked source instead clears
+    /// the global target via `setDefaultSource(nil)` (leaving the app and
     /// switching alive).
     func lockToSource(_ id: InputSourceID) {
         config.defaultSourceID = id
         config.isEnabled = true
-        config.lockingEnabled = true
         commit(reason: .lockEngaged)
     }
 
     // MARK: - Shortcut-driven source cycling
 
     /// Lock the *global* target to the previous/next input source in the list,
-    /// wrapping around the ends, and turn locking on — the same write path as
+    /// wrapping around the ends, and turn LockIME on — the same write path as
     /// `lockToSource`. Never lands on "none", and does nothing when fewer than
     /// two input sources are installed (there's nowhere to cycle).
     func cycleGlobalSource(_ direction: CycleDirection) {
@@ -385,7 +362,6 @@ final class AppState {
         ) else { return }
         config.defaultSourceID = next
         config.isEnabled = true
-        config.lockingEnabled = true
         commit(reason: .lockEngaged)
     }