xiaoxue_admin
/
orca
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
orca/docs/editor-find-layout-aware-sh...

7.4 KiB
Raw Blame History

Layout-aware find in editable Monaco editors

Problem

Issue #7953 reports that Cmd+F can type f into a TypeScript file instead of opening find on macOS.

Orca's editable Monaco surfaces currently install its layout-aware save shortcut through editor-shortcuts.ts (src/renderer/src/components/editor/editor-shortcuts.ts:18), but leave find entirely to Monaco's internal keycode dispatch. Orca already declares editor.find as Mod+F (src/shared/keybindings.ts:784) and its matcher resolves logical keys before physical-code fallback (src/shared/keybindings.ts:2041).

A real Electron repro sends a macOS event with logical key f, physical code KeyU, and virtual key code U, as produced by a non-QWERTY layout. Monaco leaves its find widget closed. The equivalent QWERTY KeyF event opens it.

Root cause

Monaco's built-in find keybinding follows the physical/virtual keycode delivered by Chromium. Orca's shortcut system is layout-aware, but its editable Monaco integrations do not use it for find. On layouts where the key that produces f is not physical KeyF, Monaco misses the chord and Native Edit Context remains in editing mode.

Non-goals

  • Reimplementing Monaco's find widget, match navigation, or search state.
  • Changing find behavior in markdown preview, rich markdown, PDF, browser, terminal, or file search.
  • Changing find behavior in read-only diff surfaces.
  • Reworking all Monaco keybindings or making Monaco defaults fully obey shortcut unbinding in this patch.
  • Adding telemetry for a local keyboard action.

Design

  1. Add a focused editor find installer beside the existing save installer in editor-shortcuts.ts. It matches editor.find through editorShortcutMatches, consumes every matched event before it reaches Native Edit Context or Monaco, and invokes a supplied callback only for the initial, non-repeat keydown. Repeat events must still be prevented and propagation-stopped so Monaco's QWERTY binding cannot reopen/reset the widget.
  2. Install that handler on every editable Monaco container in the source editor, editable diff views, and notebook code cells. Run that editor's existing actions.find action and dispose the bridge from its existing teardown callback.
  3. Add unit coverage at the DOM-listener seam for logical f with a non-KeyF physical code, QWERTY/default behavior, repeat suppression, unrelated typing, and cleanup.
  4. Preserve an Electron regression loop that drives both QWERTY and layout-aware raw key events against a real .ts editor and verifies the existing Monaco find widget becomes visible without dirtying the file.

Data flow

  • macOS/Linux/Windows keydown reaches the focused editable Monaco container.
  • editorShortcutMatches('editor.find', event) resolves the active platform, user bindings, modifiers, and logical key.
  • On match, Orca consumes the DOM event and calls Monaco's existing actions.find action.
  • Monaco owns the visible find widget and focus exactly as before.

Edge cases

  • Auto-repeat must be consumed without invoking find again; returning early before prevention would let Monaco handle a repeated QWERTY KeyF event.
  • Ordinary unmodified f typing and unrelated shortcuts must continue to Monaco unchanged.
  • A removed/disposed source editor, diff pane, or notebook cell must not retain the listener.
  • QWERTY Cmd/Ctrl+F must still open the same Monaco widget once, not twice.
  • User-configured bindings accepted by Orca's editor.find matcher should open find; Monaco's own default bindings remain outside the scope of this patch.
  • The behavior is renderer-local and does not read files or execute commands, so local, SSH, and Remote Orca files share the same path.

Test plan

  • Unit: editor-shortcuts.test.ts dispatches keyboard events through a real element and parameterizes the shared bridge across macOS (metaKey) and Linux/Windows (ctrlKey) using logical f with physical KeyU. It also asserts QWERTY/default handling, matched-repeat prevention without a second callback, unrelated typing, and disposal behavior used by every editable Monaco integration.
  • Electron: open a disposable .ts file and drive Cmd+F/Ctrl+F using the platform modifier; assert .find-widget.visible, focused find input, unchanged source text, and clean editor state.
  • Electron layout regression: on macOS, dispatch logical f with non-QWERTY physical/virtual key identity; assert the same find state and unchanged source text.
  • Adjacent smoke: dismiss find, type a normal character, and verify it edits the file rather than reopening find.
  • Static: run focused Vitest, pnpm typecheck, and pnpm lint.

UI quality bar

No new UI. The existing Monaco find widget must appear in its current position and styling, focus its input, and leave the editor content unchanged. No overlap, clipping, duplicate widget, or focus flicker is acceptable.

Review screenshots

  1. QWERTY/default shortcut with the existing Monaco find widget visible in a .ts editor.
  2. Non-QWERTY logical-f regression path with the same find widget visible and source text unchanged.
  3. Adjacent ordinary typing state after find is dismissed, showing the source editor still accepts text normally.

Rollout

  1. Add failing unit coverage for the layout-aware find installer contract.
  2. Implement the installer in editor-shortcuts.ts.
  3. Wire it to each editable Monaco surface's existing find action and lifecycle cleanup.
  4. Run focused tests, typecheck, lint, and the Electron QWERTY/layout/typing scenarios.

Lightweight Eng Review

  • Scope: Kept to one shared shortcut installer and the existing mount/teardown seams for source editors, editable diff panes, and notebook code cells; no new find implementation or global shortcut interception.
  • Architecture/data flow: The renderer-local Monaco container owns the keydown. Orca's canonical matcher resolves the logical key, while Monaco continues to own widget state and rendering. No main/preload/IPC, persistence, network, SSH, or provider boundary changes.
  • Failure modes covered:
    • Non-QWERTY logical key differs from physical/virtual keycode.
    • QWERTY double handling.
    • Auto-repeat escaping to Monaco's native QWERTY handler.
    • Listener surviving editor disposal.
    • Ordinary typing being consumed.
    • Custom editor.find chord accepted by Orca but not Monaco.
  • Test coverage required:
    • DOM-listener unit tests in src/renderer/src/components/editor/editor-shortcuts.test.ts, parameterized for Darwin/Meta, Linux/Ctrl, and Windows/Ctrl.
    • Electron-visible QWERTY and layout-aware .ts scenarios.
    • Adjacent ordinary typing smoke test.
  • Performance/blast radius: One capture listener per mounted editable Monaco editor, doing a constant-time keybinding comparison only for events within that editor. Multiple mounted diff sections do not fan out because each listener is scoped to its own container. Listeners are removed with Monaco disposal; no polling, scans, IPC, storage, or render-loop work.
  • UI quality bar: Existing Monaco find widget only; verify focus, unchanged source text, no duplicate opening, and unchanged styling against docs/STYLEGUIDE.md.
  • Required review screenshots:
    1. Default QWERTY find-open state.
    2. Non-QWERTY logical-key find-open state.
    3. Find-dismissed ordinary typing state.
  • Residual risks: Monaco's internal default bindings remain active when a user explicitly rebinds editor.find; fully suppressing/remapping Monaco's native keybinding table is a separate, larger change.