gloomberb 0.14.0 → 0.15.0

package/src/app/global-shortcuts.test.tsx

@@ -4,8 +4,10 @@ import { act } from "react";
 import type { PluginRegistry } from "../plugins/registry";
 import { TestDialogProvider, createOpenTuiTestRoot as createRoot, emitKeypress as emitTuiKeypress, type TestKeyEvent } from "../renderers/opentui/test-utils";
 import { createInitialState, type AppAction, type AppState } from "../state/app/context";
-import { cloneLayout, createDefaultConfig } from "../types/config";
+import { cloneLayout, createDefaultConfig, type KeybindingsConfig } from "../types/config";
+import type { ReleaseInfo } from "../updater";
 import { useAppGlobalShortcuts } from "./global-shortcuts";
+import { resolveKeybindings } from "./keybindings";
 
 let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
 let root: ReturnType<typeof createRoot> | undefined;
@@ -51,26 +53,35 @@ function ShortcutHarness({
   focusedTickerSymbol = null,
   pluginRegistry,
   refreshTicker = () => {},
+  startUpdate = () => {},
   state,
 }: {
   dispatch: (action: AppAction) => void;
   focusedTickerSymbol?: string | null;
   pluginRegistry: PluginRegistry;
   refreshTicker?: (symbol: string, exchange?: string, tickerOverride?: any, priority?: number) => void;
+  startUpdate?: (release: ReleaseInfo) => void;
   state: AppState;
 }) {
   useAppGlobalShortcuts({
     dispatch,
     focusedTickerSymbol,
     isDetachedWindow: false,
+    keybindings: resolveKeybindings(state.config.keybindings),
     pluginRegistry,
     refreshTicker,
-    startUpdate: () => {},
+    startUpdate,
     state,
   });
   return <text>ready</text>;
 }
 
+function stateWithKeybindings(suffix: string, keybindings: KeybindingsConfig, options: Partial<AppState> = {}): AppState {
+  const config = createDefaultConfig(`/tmp/gloomberb-global-shortcuts-${suffix}`);
+  config.keybindings = keybindings;
+  return { ...createInitialState(config), ...options };
+}
+
 async function renderHarness(
   state: AppState,
   registry: PluginRegistry,
@@ -78,6 +89,7 @@ async function renderHarness(
   options: {
     focusedTickerSymbol?: string | null;
     refreshTicker?: (symbol: string, exchange?: string, tickerOverride?: any, priority?: number) => void;
+    startUpdate?: (release: ReleaseInfo) => void;
   } = {},
 ) {
   testSetup = await createTestRenderer({ width: 40, height: 8 });
@@ -90,6 +102,7 @@ async function renderHarness(
           focusedTickerSymbol={options.focusedTickerSymbol}
           pluginRegistry={registry}
           refreshTicker={options.refreshTicker}
+          startUpdate={options.startUpdate}
           state={state}
         />
       </TestDialogProvider>,
@@ -135,6 +148,35 @@ describe("useAppGlobalShortcuts", () => {
     expect(event.propagationStopped).toBe(true);
   });
 
+  // The open bar moves its selection on Ctrl+P, so that chord must reach it.
+  test("leaves Ctrl-P to the open command bar and still closes it with Ctrl-K", async () => {
+    const actions: AppAction[] = [];
+    const state = { ...createInitialState(createDefaultConfig("/tmp/gloomberb-global-shortcuts-open-bar")), commandBarOpen: true };
+    await renderHarness(state, createRegistry(), (action) => actions.push(action));
+
+    const up = await emitKeypress({ name: "p", ctrl: true });
+    expect(actions).toEqual([]);
+    expect(up.defaultPrevented).toBe(false);
+
+    await emitKeypress({ name: "k", ctrl: true });
+    expect(actions).toEqual([{ type: "TOGGLE_COMMAND_BAR" }]);
+  });
+
+  test("U retries a failed self-update", async () => {
+    const started: string[] = [];
+    const release = { version: "9.9.9", updateAction: { kind: "self" } } as unknown as ReleaseInfo;
+    const failed = {
+      ...createInitialState(createDefaultConfig("/tmp/gloomberb-global-shortcuts-update")),
+      updateAvailable: release,
+      updateProgress: { phase: "error" as const, error: "network" },
+    };
+    await renderHarness(failed, createRegistry(), () => {}, { startUpdate: (next) => started.push(next.version) });
+
+    const retry = await emitKeypress({ name: "u" });
+    expect(started).toEqual(["9.9.9"]);
+    expect(retry.defaultPrevented).toBe(true);
+  });
+
   test("opens ticker search with backtick", async () => {
     const actions: AppAction[] = [];
     const state = createInitialState(createDefaultConfig("/tmp/gloomberb-global-shortcuts"));
@@ -152,6 +194,82 @@ describe("useAppGlobalShortcuts", () => {
     expect(event.propagationStopped).toBe(true);
   });
 
+  test("a rebound action answers to its new key and not the old one", async () => {
+    const actions: AppAction[] = [];
+    const state = stateWithKeybindings("rebound", {
+      actions: { "ticker-search": "Ctrl+Shift+S", "command-bar": "Ctrl+Shift+P", help: null },
+    });
+    const openedPanes: string[] = [];
+    await renderHarness(state, createRegistry(undefined, (paneId) => openedPanes.push(paneId)), (action) => actions.push(action));
+
+    const oldKey = await emitKeypress({ name: "`" });
+    expect(actions).toEqual([]);
+    expect(oldKey.defaultPrevented).toBe(false);
+
+    await emitKeypress({ name: "s", ctrl: true, shift: true });
+    expect(actions).toEqual([{
+      type: "SET_COMMAND_BAR",
+      open: true,
+      query: "",
+      launch: { kind: "ticker-search", query: "" },
+    }]);
+
+    await emitKeypress({ name: "p", ctrl: true });
+    expect(actions).toHaveLength(1);
+    await emitKeypress({ name: "p", ctrl: true, shift: true });
+    expect(actions[1]).toEqual({ type: "TOGGLE_COMMAND_BAR" });
+
+    const help = await emitKeypress({ name: "?", shift: true });
+    expect(openedPanes).toEqual([]);
+    expect(help.defaultPrevented).toBe(false);
+  });
+
+  test("a command binding opens the bar with the text to run, unless the bar or a dialog owns the keyboard", async () => {
+    const actions: AppAction[] = [];
+    const state = stateWithKeybindings("command", { commands: { "Alt+1": "DES AAPL" } });
+    await renderHarness(state, createRegistry(), (action) => actions.push(action));
+
+    const event = await emitKeypress({ name: "1", alt: true });
+
+    expect(actions).toEqual([{
+      type: "SET_COMMAND_BAR",
+      open: true,
+      query: "DES AAPL",
+      launch: { kind: "run-query", query: "DES AAPL" },
+    }]);
+    expect(event.defaultPrevented).toBe(true);
+    expect(event.propagationStopped).toBe(true);
+  });
+
+  test("a Control command binding yields to the editor while text is being typed", async () => {
+    const actions: AppAction[] = [];
+    const state = stateWithKeybindings("command-typing", { commands: { "Ctrl+N": "NEWS", F5: "NEWS" } }, { inputCaptured: true });
+    await renderHarness(state, createRegistry(), (action) => actions.push(action));
+
+    const ctrl = await emitKeypress({ name: "n", ctrl: true });
+    expect(actions).toEqual([]);
+    expect(ctrl.defaultPrevented).toBe(false);
+
+    await emitKeypress({ name: "f5" });
+    expect(actions).toEqual([{
+      type: "SET_COMMAND_BAR",
+      open: true,
+      query: "NEWS",
+      launch: { kind: "run-query", query: "NEWS" },
+    }]);
+  });
+
+  test("a plugin shortcut honours its override", async () => {
+    let executed = 0;
+    const state = stateWithKeybindings("plugin-override", { actions: { "plugin:test-shortcut": "Alt+X" } });
+    await renderHarness(state, createRegistry(() => { executed += 1; }), () => {});
+
+    await emitKeypress({ name: "x" });
+    expect(executed).toBe(0);
+    await emitKeypress({ name: "x", alt: true });
+    expect(executed).toBe(1);
+  });
+
   function layoutState(suffix: string, options: { commandBarOpen?: boolean } = {}) {
     const config = createDefaultConfig(`/tmp/gloomberb-global-shortcuts-${suffix}`);
     config.layouts = [

package/src/app/global-shortcuts.ts

@@ -1,24 +1,90 @@
-import type { Dispatch } from "react";
+import { useEffect, useRef, type Dispatch } from "react";
 import { useShortcut } from "../react/input";
-import { useNativeRenderer, useRendererHost } from "../ui";
+import { useNativeRenderer, useRendererHost, useUiHost } from "../ui";
 import { useDialogState } from "../ui/dialog";
+import { useToastHost } from "../ui/toast";
 import type { PluginRegistry } from "../plugins/registry";
 import type { AppAction, AppState } from "../state/app/context";
 import type { TickerRecord } from "../types/ticker";
 import type { ReleaseInfo } from "../updater";
 import { canSelfUpdate } from "../updater";
 import { getVisiblePaneCycleOrder } from "../components/layout/pane/cycle-order";
+import { isMoveDownShortcut, isMoveUpShortcut } from "../components/command-bar/keyboard-handlers";
 import {
   copyActiveSelection,
   isCopyShortcut,
   isPasteShortcut,
   pasteSystemClipboard,
 } from "../utils/selection-clipboard";
+import {
+  describeKeybindingIssue,
+  getDefaultKeybindings,
+  matchKeybinding,
+  matchesKeyChord,
+  requestKeybindingCapture,
+  resolvePluginShortcutChords,
+  type ResolvedKeybindings,
+} from "./keybindings";
+
+/** Long enough to read a few conflicts and choose Review. */
+const KEYBINDING_NOTICE_DURATION_MS = 15_000;
+
+/**
+ * Whether the install-update key has something to do: a release this build
+ * can install itself whose last attempt failed. A fresh one downloads on its
+ * own, and a manual or managed one names its own command.
+ */
+export function canRetryUpdate(
+  state: Pick<AppState, "updateAvailable" | "updateProgress" | "updateCheckInProgress">,
+): boolean {
+  return !!state.updateAvailable
+    && state.updateProgress?.phase === "error"
+    && !state.updateCheckInProgress
+    && canSelfUpdate(state.updateAvailable);
+}
+
+/**
+ * Tells the user once per launch when `config.json` holds a binding that does
+ * not parse, names no action, or lands on a key another action already has.
+ * Silence would read as "I set it and nothing happened".
+ */
+function useKeybindingIssueNotice(
+  keybindings: ResolvedKeybindings,
+  pluginRegistry: PluginRegistry,
+  initialized: boolean,
+) {
+  const noticedRef = useRef<string | null>(null);
+  const issueKey = keybindings.issues.map(describeKeybindingIssue).join("\n");
+  useEffect(() => {
+    if (!initialized || !issueKey || noticedRef.current === issueKey) return;
+    noticedRef.current = issueKey;
+    const lines = keybindings.issues.map(describeKeybindingIssue);
+    const shown = lines.slice(0, 3);
+    const more = lines.length - shown.length;
+    pluginRegistry.notify({
+      body: [
+        "Keybindings need attention:",
+        ...shown,
+        ...(more > 0 ? [`and ${more} more; see Help > Shortcuts.`] : []),
+      ].join("\n"),
+      type: "error",
+      duration: KEYBINDING_NOTICE_DURATION_MS,
+      action: {
+        label: "Review",
+        onClick: () => {
+          requestKeybindingCapture({ kind: "review" });
+          pluginRegistry.showPane("help");
+        },
+      },
+    });
+  }, [initialized, issueKey, keybindings.issues, pluginRegistry]);
+}
 
 export function useAppGlobalShortcuts({
   dispatch,
   focusedTickerSymbol,
   isDetachedWindow,
+  keybindings = getDefaultKeybindings(),
   pluginRegistry,
   refreshTicker,
   startUpdate,
@@ -27,6 +93,8 @@ export function useAppGlobalShortcuts({
   dispatch: Dispatch<AppAction>;
   focusedTickerSymbol: string | null;
   isDetachedWindow: boolean;
+  /** The resolved table; the app resolves it once and shares it with the shell. */
+  keybindings?: ResolvedKeybindings;
   pluginRegistry: PluginRegistry;
   refreshTicker: (symbol: string, exchange?: string, tickerOverride?: TickerRecord | null, priority?: number) => void;
   startUpdate: (release: ReleaseInfo) => void;
@@ -35,6 +103,9 @@ export function useAppGlobalShortcuts({
   const dialogOpen = useDialogState((s) => s.isOpen);
   const nativeRenderer = useNativeRenderer();
   const rendererHost = useRendererHost();
+  const uiKind = useUiHost().kind;
+  const toastHost = useToastHost();
+  useKeybindingIssueNotice(keybindings, pluginRegistry, state.initialized);
 
   useShortcut((event) => {
     if (isCopyShortcut(event) && copyActiveSelection(nativeRenderer)) {
@@ -48,17 +119,18 @@ export function useAppGlobalShortcuts({
       return;
     }
 
+    const match = matchKeybinding(keybindings, event);
+    const action = match?.kind === "action" ? match.id : null;
+
     // Terminals send Ctrl; the browser and the desktop webview send Cmd on
     // macOS, which the OpenTUI host also reports as `super` under the kitty
-    // protocol. Alt stays out so Alt-digit keeps its terminal meaning. While a
-    // dialog, the command bar or an editable field owns the keyboard the digit
-    // must not move layouts, but it still has to be swallowed there or the
-    // webview hands Cmd-digit to the browser's own tab switcher.
-    if (!isDetachedWindow
-      && /^[1-9]$/.test(event.name ?? "")
-      && (event.ctrl || event.meta || event.super)) {
+    // protocol. While a dialog, the command bar or an editable field owns the
+    // keyboard the digit must not move layouts, but it still has to be
+    // swallowed there or the webview hands Cmd-digit to the browser's own tab
+    // switcher.
+    if (!isDetachedWindow && action === "switch-layout" && match?.kind === "action" && match.digit !== null) {
       const layouts = state.config.layouts ?? [];
-      const idx = parseInt(event.name!, 10) - 1;
+      const idx = match.digit - 1;
       const uiOwnsKeyboard = dialogOpen || state.commandBarOpen || event.targetEditable === true;
       if (!uiOwnsKeyboard && idx < layouts.length && idx !== state.config.activeLayoutIndex) {
         dispatch({ type: "SWITCH_LAYOUT", index: idx });
@@ -68,18 +140,30 @@ export function useAppGlobalShortcuts({
       return;
     }
 
+    // Toasts float above everything, so their keys work over a dialog too.
+    if (action === "notification-action" || action === "notification-dismiss") {
+      const handled = action === "notification-action"
+        ? toastHost.activateNewest?.() === true
+        : toastHost.dismissNewest?.() === true;
+      if (handled) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return;
+    }
+
     if (dialogOpen) return;
 
-    if (!isDetachedWindow && (
-      (event.name === "p" && event.ctrl)
-      || (event.name === "k" && (event.ctrl || event.meta || event.super))
-    )) {
+    if (!isDetachedWindow && action === "command-bar") {
+      // Ctrl+P and Ctrl+N move the open bar's selection, so a bar chord that
+      // is one of them only opens it; Esc and the bar's other chords close it.
+      if (state.commandBarOpen && (isMoveUpShortcut(event) || isMoveDownShortcut(event))) return;
       event.preventDefault();
       event.stopPropagation();
       dispatch({ type: "TOGGLE_COMMAND_BAR" });
       return;
     }
-    if (!isDetachedWindow && event.name === "`" && !state.commandBarOpen) {
+    if (!isDetachedWindow && action === "ticker-search" && !state.commandBarOpen) {
       event.preventDefault();
       event.stopPropagation();
       dispatch({
@@ -91,11 +175,9 @@ export function useAppGlobalShortcuts({
       return;
     }
 
-    const hasShortcutModifier = event.ctrl || event.meta || event.super || event.alt;
-
     if (state.commandBarOpen) return;
 
-    if (event.name === "tab") {
+    if (action === "focus-next-pane" || action === "focus-prev-pane") {
       const paneOrder = getVisiblePaneCycleOrder(
         state.config.layout,
         pluginRegistry,
@@ -103,50 +185,64 @@ export function useAppGlobalShortcuts({
       );
       if (paneOrder.length === 0) return;
 
-      if (event.shift) {
-        dispatch({ type: "FOCUS_PREV", paneOrder });
-      } else {
-        dispatch({ type: "FOCUS_NEXT", paneOrder });
-      }
+      dispatch({ type: action === "focus-prev-pane" ? "FOCUS_PREV" : "FOCUS_NEXT", paneOrder });
       event.preventDefault();
       event.stopPropagation();
       return;
     }
 
+    if (match?.kind === "command" && !isDetachedWindow) {
+      // Control chords belong to the editor while text is being typed; Alt,
+      // Command and function keys are never text, so they still fire.
+      const editing = state.inputCaptured || event.targetEditable === true;
+      if (editing && event.ctrl && !(event.meta || event.super)) return;
+      event.preventDefault();
+      event.stopPropagation();
+      dispatch({
+        type: "SET_COMMAND_BAR",
+        open: true,
+        query: match.command.query,
+        launch: { kind: "run-query", query: match.command.query },
+      });
+      return;
+    }
+
     if (state.inputCaptured) return;
 
-    const isQuestionMark = event.name === "?"
-      || event.key === "?"
-      || event.sequence === "?"
-      || (event.name === "/" && event.shift);
-    if (!isDetachedWindow && !hasShortcutModifier && isQuestionMark) {
+    if (!isDetachedWindow && action === "help") {
       event.preventDefault();
       event.stopPropagation();
       pluginRegistry.showPane("help");
       return;
     }
 
-    if (!hasShortcutModifier && !isDetachedWindow && event.name === "q") {
-      rendererHost.requestExit();
-    } else if (!hasShortcutModifier && event.name === "r") {
+    if (!isDetachedWindow && action === "quit") {
+      if (uiKind === "opentui") rendererHost.requestExit();
+    } else if (action === "refresh-ticker") {
       if (focusedTickerSymbol) {
         const ticker = state.tickers.get(focusedTickerSymbol);
         if (ticker) refreshTicker(ticker.metadata.ticker, ticker.metadata.exchange, ticker, 0);
       }
-    } else if (!hasShortcutModifier && (event.name === "R" || (event.name === "r" && event.shift))) {
+    } else if (action === "refresh-all") {
       for (const ticker of state.tickers.values()) {
         refreshTicker(ticker.metadata.ticker, ticker.metadata.exchange, ticker, 1);
       }
-    } else if (!hasShortcutModifier && event.name === "u" && state.updateAvailable && !state.updateProgress && !state.updateCheckInProgress && canSelfUpdate(state.updateAvailable)) {
-      startUpdate(state.updateAvailable);
-    } else {
+    } else if (action === "install-update") {
+      // A release that can install itself starts on its own, so the key is
+      // for the one that failed: it tries again.
+      if (canRetryUpdate(state)) {
+        event.preventDefault();
+        event.stopPropagation();
+        startUpdate(state.updateAvailable!);
+      }
+    } else if (!action) {
       const disabledPlugins = new Set(state.config.disabledPlugins || []);
+      const keybindingsConfig = state.config.keybindings;
       for (const shortcut of pluginRegistry.shortcuts.values()) {
         const ownerId = pluginRegistry.getShortcutPluginId(shortcut.id);
         if (ownerId && disabledPlugins.has(ownerId)) continue;
-        if (shortcut.key === event.name
-            && (shortcut.ctrl ?? false) === (event.ctrl ?? false)
-            && (shortcut.shift ?? false) === (event.shift ?? false)) {
+        const chords = resolvePluginShortcutChords(keybindingsConfig, shortcut);
+        if (chords.some((chord) => matchesKeyChord(chord, event))) {
           shortcut.execute();
           break;
         }