fix: md viewer skips auto-refocus for parent-side picker shortcuts

When the md viewer iframe forwards an unhandled shortcut to Phoenix,
it re-focuses its own viewer-content 100ms later so commands like
Save return focus to the editor. That timer also fired for shortcuts
that open parent UIs (Quick Open, Find in Files) — pulling focus out
of the picker and making the dropdown vanish on the first keystroke.

Send the set of "skip refocus" key strings from the parent to the
iframe at runtime. MarkdownSync reads the bindings for the relevant
commands from KeyBindingManager and posts MDVIEWR_SKIP_REFOCUS_KEYS
on iframe ready and whenever a binding changes. The iframe stores
the set and builds the same canonical key string KBM uses from each
keydown to decide whether to skip the refocus. Adding more shortcuts
is now just appending a command id to SKIP_REFOCUS_COMMANDS in
MarkdownSync — no hardcoded keys in the iframe.

Also remove the QuickOpen design-mode exit branch added earlier:
the floating picker variant replaces that workaround entirely.

Author: abose

src-mdviewer/src/bridge.js

@@ -20,6 +20,35 @@ let _baseURL = "";
 let _cursorPosBeforeEdit = null; // cursor position before current edit batch
 let _cursorPosDirty = false; // true after content changes, reset when emitted
 let _pendingReloadScroll = null; // { filePath, scrollSourceLine } for scroll restore after reload
+// Key strings ("Ctrl-Shift-O", "Ctrl-Shift-F", …) for shortcuts Phoenix
+// handles by opening a UI that needs focus — we must not auto-refocus our
+// own editor after forwarding those. Populated from the parent via the
+// MDVIEWR_SKIP_REFOCUS_KEYS message; starts empty so bugs in the parent
+// can't break the default refocus behavior.
+let _skipRefocusKeys = new Set();
+const _isMacForKey = /Mac|iPhone|iPad/.test(navigator.platform);
+
+/**
+ * Mirror Phoenix's KeyBindingManager _buildKeyDescriptor to produce the
+ * same canonical key string from a KeyboardEvent so we can look it up in
+ * _skipRefocusKeys. Non-mac: "Ctrl-Shift-O"; mac: "Shift-Cmd-O".
+ */
+function _eventToKeyString(e) {
+    const parts = [];
+    if (_isMacForKey && e.ctrlKey) { parts.push("Ctrl"); }
+    if (e.altKey) { parts.push("Alt"); }
+    if (e.shiftKey) { parts.push("Shift"); }
+    if (!_isMacForKey && e.ctrlKey) { parts.unshift("Ctrl"); }
+    if (_isMacForKey && e.metaKey) { parts.push("Cmd"); }
+    let key = e.key || "";
+    if (key.length === 1) { key = key.toUpperCase(); }
+    parts.push(key);
+    return parts.join("-");
+}
+
+function _isSkipRefocusShortcut(e) {
+    return _skipRefocusKeys.has(_eventToKeyString(e));
+}
 
 /**
  * Check if a URL is absolute (not relative to the document).
@@ -317,6 +346,14 @@ export function initBridge() {
                 window.getSelection().removeAllRanges();
                 document.body.click();
                 break;
+            case "MDVIEWR_SKIP_REFOCUS_KEYS":
+                // Phoenix tells us which forwarded shortcuts should NOT
+                // trigger our auto-refocus (e.g. Quick Open, Find in Files
+                // — shortcuts that open parent-side UI which needs focus).
+                if (Array.isArray(data.keys)) {
+                    _skipRefocusKeys = new Set(data.keys);
+                }
+                break;
         }
     });
 
@@ -416,13 +453,18 @@ export function initBridge() {
                     altKey: e.altKey
                 });
                 // Refocus md editor after Phoenix handles the shortcut
-                // (some commands like Save focus the CM editor)
-                setTimeout(() => {
-                    const content = document.getElementById("viewer-content");
-                    if (content && getState().editMode) {
-                        content.focus({ preventScroll: true });
-                    }
-                }, 100);
+                // (e.g. Save focuses the CM editor). Phoenix sends us the
+                // list of shortcuts for which focus should stay with the
+                // parent (Quick Open, Find in Files …) via
+                // MDVIEWR_SKIP_REFOCUS_KEYS. Don't refocus for those.
+                if (!_isSkipRefocusShortcut(e)) {
+                    setTimeout(() => {
+                        const content = document.getElementById("viewer-content");
+                        if (content && getState().editMode) {
+                            content.focus({ preventScroll: true });
+                        }
+                    }, 100);
+                }
             }
         }
     }, true);

src/extensionsIntegrated/Phoenix-live-preview/MarkdownSync.js

@@ -25,8 +25,23 @@ define(function (require, exports, module) {
     const ThemeManager = require("view/ThemeManager"),
         NativeApp = require("utils/NativeApp"),
         EditorManager = require("editor/EditorManager"),
+        AppInit = require("utils/AppInit"),
+        CommandManager = require("command/CommandManager"),
+        Commands = require("command/Commands"),
+        KeyBindingManager = require("command/KeyBindingManager"),
         utils = require("./utils");
 
+    // Commands whose shortcuts, when forwarded from the md viewer iframe,
+    // open a parent-side UI that needs to keep keyboard focus. The iframe's
+    // 100ms auto-refocus must skip these shortcuts — otherwise it yanks
+    // focus out of the picker immediately after it opens. We send the raw
+    // key strings (resolved at runtime from KeyBindingManager) so the
+    // iframe stays theme/rebind-agnostic.
+    const SKIP_REFOCUS_COMMANDS = [
+        Commands.NAVIGATE_QUICK_OPEN,
+        Commands.CMD_FIND_IN_FILES
+    ];
+
     let _active = false;
     let _doc = null;
     let _$iframe = null;
@@ -348,16 +363,52 @@ define(function (require, exports, module) {
 
     // --- iframe ready ---
 
+    /**
+     * Collect the current `key` strings bound to each SKIP_REFOCUS_COMMANDS
+     * command and send them to the iframe so its keyboard-shortcut forward
+     * path can skip its own 100ms auto-refocus for these shortcuts.
+     */
+    function _sendSkipRefocusShortcuts() {
+        const iframeWindow = _getIframeWindow();
+        if (!iframeWindow) { return; }
+        const keys = [];
+        SKIP_REFOCUS_COMMANDS.forEach(function (cmdID) {
+            const bindings = KeyBindingManager.getKeyBindings(cmdID) || [];
+            bindings.forEach(function (b) {
+                if (b && b.key) { keys.push(b.key); }
+            });
+        });
+        iframeWindow.postMessage({
+            type: "MDVIEWR_SKIP_REFOCUS_KEYS",
+            keys: keys
+        }, "*");
+    }
+
     function _onIframeReady() {
         _iframeReady = true;
         _sendContent();
         _sendTheme();
         _sendLocale();
+        _sendSkipRefocusShortcuts();
         if (_onIframeReadyCallback) {
             _onIframeReadyCallback();
         }
     }
 
+    // Re-send shortcuts if the user rebinds Quick Open / Find in Files.
+    // Deferred to appReady so the commands have been registered before we
+    // try to hook their key-binding-change events.
+    AppInit.appReady(function () {
+        SKIP_REFOCUS_COMMANDS.forEach(function (cmdID) {
+            const cmd = CommandManager.get(cmdID);
+            if (cmd && cmd.on) {
+                cmd.on(KeyBindingManager.EVENT_KEY_BINDING_ADDED, function () {
+                    if (_iframeReady) { _sendSkipRefocusShortcuts(); }
+                });
+            }
+        });
+    });
+
     // --- Phoenix → iframe ---
 
     /**

src/search/QuickOpen.js

@@ -108,22 +108,29 @@ define(function (require, exports, module) {
             if (isInPicker(e.target)) { return; }
             close();
         }
-        window.document.addEventListener("mousedown", onMousedown, true);
-        // Clicks inside the live-preview iframe never surface as mousedown
-        // events on the parent document — the iframe consumes them. Detect
-        // that case via the window blur event (focus moves to the iframe's
-        // content window) and a slight delay to let focus settle before
-        // deciding whether we really moved out of the picker.
+        // Defer attaching the dismiss listeners by a tick so any transient
+        // focus / blur events fired while the picker is opening (common when
+        // the shortcut was forwarded from an iframe like the md viewer —
+        // focus transfers between iframe and parent input can fire spurious
+        // window.blur) don't close the picker before it's ready.
+        let dismissArmed = false;
         function onWindowBlur() {
+            if (!dismissArmed) { return; }
             window.setTimeout(function () {
                 if (closed) { return; }
                 const active = window.document.activeElement;
                 if (active && isInPicker(active)) { return; }
                 close();
             }, 0);
         }
-        window.addEventListener("blur", onWindowBlur);
+        const armTimer = window.setTimeout(function () {
+            if (closed) { return; }
+            dismissArmed = true;
+            window.document.addEventListener("mousedown", onMousedown, true);
+            window.addEventListener("blur", onWindowBlur);
+        }, 120);
         closeHandlers.push(function () {
+            window.clearTimeout(armTimer);
             window.document.removeEventListener("mousedown", onMousedown, true);
             window.removeEventListener("blur", onWindowBlur);
         });