gloomberb 0.14.0 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",

package/src/api-client/types.ts

@@ -535,6 +535,10 @@ export interface CloudJobsSeriesPoint {
   open: number;
   new: number;
   closed: number;
+  /** Open standing roles the company hires for continuously. */
+  evergreen?: number;
+  /** Open contract and temporary roles. */
+  contract?: number;
 }
 
 export interface CloudJobsBucket {
@@ -554,6 +558,9 @@ export interface CloudJobsPosting {
   location: string | null;
   country: string | null;
   remote: boolean | null;
+  employmentKind?: string | null;
+  /** A standing posting for a continuous-hiring role; null when unjudged. */
+  evergreen?: boolean | null;
   postedAt: string | null;
   postedPrecision: "exact" | "approximate" | "floor" | null;
   firstSeenAt: string;
@@ -595,6 +602,16 @@ export interface CloudJobsSummaryPayload {
   /** Open postings the system dates within the last 30 days. */
   posted30d?: number | null;
   remoteShare: number | null;
+  /**
+   * Open roles that are standing postings for continuous-hiring positions
+   * (baristas, servers, store associates, nurses). One more of those says
+   * nothing about the company's plans; open minus evergreen is the count of
+   * specific roles.
+   */
+  evergreenCount?: number;
+  evergreenShare?: number | null;
+  /** Share of open roles that are contract or temporary, among those known. */
+  contractShare?: number | null;
   medianAgeDays: number | null;
   series: CloudJobsSeriesPoint[];
   /** The current backlog by how long each role has been posted. */

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

@@ -4,8 +4,9 @@ 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 { useAppGlobalShortcuts } from "./global-shortcuts";
+import { resolveKeybindings } from "./keybindings";
 
 let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
 let root: ReturnType<typeof createRoot> | undefined;
@@ -63,6 +64,7 @@ function ShortcutHarness({
     dispatch,
     focusedTickerSymbol,
     isDetachedWindow: false,
+    keybindings: resolveKeybindings(state.config.keybindings),
     pluginRegistry,
     refreshTicker,
     startUpdate: () => {},
@@ -71,6 +73,12 @@ function ShortcutHarness({
   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,
@@ -152,6 +160,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,4 +1,4 @@
-import type { Dispatch } from "react";
+import { useEffect, useRef, type Dispatch } from "react";
 import { useShortcut } from "../react/input";
 import { useNativeRenderer, useRendererHost } from "../ui";
 import { useDialogState } from "../ui/dialog";
@@ -14,11 +14,49 @@ import {
   isPasteShortcut,
   pasteSystemClipboard,
 } from "../utils/selection-clipboard";
+import {
+  describeKeybindingIssue,
+  getDefaultKeybindings,
+  matchKeybinding,
+  matchesKeyChord,
+  resolvePluginShortcutChords,
+  type ResolvedKeybindings,
+} from "./keybindings";
+
+/**
+ * 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",
+    });
+  }, [initialized, issueKey, keybindings.issues, pluginRegistry]);
+}
 
 export function useAppGlobalShortcuts({
   dispatch,
   focusedTickerSymbol,
   isDetachedWindow,
+  keybindings = getDefaultKeybindings(),
   pluginRegistry,
   refreshTicker,
   startUpdate,
@@ -27,6 +65,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 +75,7 @@ export function useAppGlobalShortcuts({
   const dialogOpen = useDialogState((s) => s.isOpen);
   const nativeRenderer = useNativeRenderer();
   const rendererHost = useRendererHost();
+  useKeybindingIssueNotice(keybindings, pluginRegistry, state.initialized);
 
   useShortcut((event) => {
     if (isCopyShortcut(event) && copyActiveSelection(nativeRenderer)) {
@@ -48,17 +89,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 });
@@ -70,16 +112,13 @@ export function useAppGlobalShortcuts({
 
     if (dialogOpen) return;
 
-    if (!isDetachedWindow && (
-      (event.name === "p" && event.ctrl)
-      || (event.name === "k" && (event.ctrl || event.meta || event.super))
-    )) {
+    if (!isDetachedWindow && action === "command-bar") {
       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 +130,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 +140,60 @@ 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") {
+    if (!isDetachedWindow && action === "quit") {
       rendererHost.requestExit();
-    } else if (!hasShortcutModifier && event.name === "r") {
+    } 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") {
+      if (state.updateAvailable && !state.updateProgress && !state.updateCheckInProgress && canSelfUpdate(state.updateAvailable)) {
+        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;
         }

package/src/app/keybindings/actions.ts

@@ -0,0 +1,223 @@
+/**
+ * Every built-in action a key can be bound to, with the chords it ships with.
+ * The ids are what `config.json` and the CLI use, so they read as actions, not
+ * as the keys they happen to sit on today.
+ */
+export type CoreKeybindingActionId =
+  | "command-bar"
+  | "ticker-search"
+  | "help"
+  | "switch-layout"
+  | "focus-next-pane"
+  | "focus-prev-pane"
+  | "refresh-ticker"
+  | "refresh-all"
+  | "install-update"
+  | "quit"
+  | "pane-close"
+  | "close-floating-panes"
+  | "pane-settings"
+  | "pane-fullscreen"
+  | "pane-float"
+  | "pane-pop-out"
+  | "pane-screenshot"
+  | "pane-export-csv"
+  | "pane-share"
+  | "layout-gallery"
+  | "tidy-windows"
+  | "window-move-mode"
+  | "window-resize-mode";
+
+export type KeybindingActionCategory = "Global Keys" | "Pane Management";
+
+export interface KeybindingActionDef {
+  id: CoreKeybindingActionId;
+  category: KeybindingActionCategory;
+  /** Help text. Kept in English here; the help pane translates it. */
+  description: string;
+  defaults: readonly string[];
+  /** Only the desktop app has this action; the terminal hides the row. */
+  desktopOnly?: boolean;
+}
+
+export const PANE_ACTION_IDS = new Set<CoreKeybindingActionId>([
+  "pane-close",
+  "close-floating-panes",
+  "pane-settings",
+  "pane-fullscreen",
+  "pane-float",
+  "pane-pop-out",
+  "pane-screenshot",
+  "pane-export-csv",
+  "pane-share",
+  "layout-gallery",
+  "tidy-windows",
+  "window-move-mode",
+  "window-resize-mode",
+]);
+
+/**
+ * Order matters twice: it is the order the help pane lists rows in, and the
+ * order chords are matched in when two actions share one.
+ */
+export const KEYBINDING_ACTIONS: readonly KeybindingActionDef[] = [
+  {
+    id: "command-bar",
+    category: "Global Keys",
+    description: "Open the command bar.",
+    defaults: ["Ctrl+P", "CmdOrCtrl+K"],
+  },
+  {
+    id: "ticker-search",
+    category: "Global Keys",
+    description: "Open ticker search directly.",
+    // One chord on purpose: the command bar already searches symbols for
+    // free text, so a layout without a backtick key still has Ctrl+P and
+    // typing. A dedicated key is a rebind away for anyone who wants one.
+    defaults: ["`"],
+  },
+  {
+    id: "help",
+    category: "Global Keys",
+    description: "Open help.",
+    defaults: ["?"],
+  },
+  {
+    id: "switch-layout",
+    category: "Global Keys",
+    description: "Switch saved layouts by number.",
+    defaults: ["CmdOrCtrl+Digit"],
+  },
+  {
+    id: "focus-next-pane",
+    category: "Global Keys",
+    description: "Move focus to the next pane or floating window.",
+    defaults: ["Tab"],
+  },
+  {
+    id: "focus-prev-pane",
+    category: "Global Keys",
+    description: "Move focus to the previous pane or floating window.",
+    defaults: ["Shift+Tab"],
+  },
+  {
+    id: "refresh-ticker",
+    category: "Global Keys",
+    description: "Refresh the focused ticker.",
+    defaults: ["R"],
+  },
+  {
+    id: "refresh-all",
+    category: "Global Keys",
+    description: "Refresh everything.",
+    defaults: ["Shift+R"],
+  },
+  {
+    id: "install-update",
+    category: "Global Keys",
+    description: "Install an available app update when one is shown.",
+    defaults: ["U"],
+  },
+  {
+    id: "quit",
+    category: "Global Keys",
+    description: "Quit the terminal app.",
+    defaults: ["Q"],
+  },
+  {
+    id: "pane-close",
+    category: "Pane Management",
+    description: "Close the focused pane, docked or floating. Locked panes stay open.",
+    defaults: ["CmdOrCtrl+W"],
+  },
+  {
+    id: "close-floating-panes",
+    category: "Pane Management",
+    description: "Close all floating panes except locked ones.",
+    defaults: ["CmdOrCtrl+Alt+W"],
+  },
+  {
+    id: "pane-settings",
+    category: "Pane Management",
+    description: "Edit settings for the focused pane.",
+    defaults: ["CmdOrCtrl+,"],
+  },
+  {
+    id: "pane-fullscreen",
+    category: "Pane Management",
+    description: "Fill the window with the focused pane, or restore it.",
+    defaults: ["CmdOrCtrl+Shift+F"],
+  },
+  {
+    id: "pane-float",
+    category: "Pane Management",
+    description: "Dock or float the focused pane.",
+    defaults: ["CmdOrCtrl+Shift+D"],
+  },
+  {
+    id: "pane-pop-out",
+    category: "Pane Management",
+    description: "Pop the focused pane out to a desktop window.",
+    defaults: ["CmdOrCtrl+Shift+O"],
+    desktopOnly: true,
+  },
+  {
+    id: "pane-screenshot",
+    category: "Pane Management",
+    description: "Copy a screenshot of the focused pane.",
+    defaults: ["CmdOrCtrl+Shift+C"],
+    desktopOnly: true,
+  },
+  {
+    id: "pane-export-csv",
+    category: "Pane Management",
+    description: "Export the focused pane's table as CSV.",
+    defaults: ["CmdOrCtrl+Shift+E"],
+  },
+  {
+    id: "pane-share",
+    category: "Pane Management",
+    description: "Share the focused pane.",
+    defaults: ["CmdOrCtrl+Shift+S"],
+  },
+  {
+    id: "layout-gallery",
+    category: "Pane Management",
+    description: "Open layout actions.",
+    defaults: ["CmdOrCtrl+Shift+L"],
+  },
+  {
+    id: "tidy-windows",
+    category: "Pane Management",
+    description: "Tidy Windows",
+    defaults: ["CmdOrCtrl+Shift+G"],
+  },
+  {
+    id: "window-move-mode",
+    category: "Pane Management",
+    description: "Enter window move mode.",
+    defaults: ["CmdOrCtrl+Shift+M"],
+  },
+  {
+    id: "window-resize-mode",
+    category: "Pane Management",
+    description: "Enter window resize mode.",
+    defaults: ["CmdOrCtrl+Shift+R"],
+  },
+];
+
+const ACTION_BY_ID = new Map(KEYBINDING_ACTIONS.map((action) => [action.id, action]));
+
+export function getKeybindingAction(id: string): KeybindingActionDef | undefined {
+  return ACTION_BY_ID.get(id as CoreKeybindingActionId);
+}
+
+export function isCoreKeybindingActionId(id: string): id is CoreKeybindingActionId {
+  return ACTION_BY_ID.has(id as CoreKeybindingActionId);
+}
+
+export const PLUGIN_ACTION_PREFIX = "plugin:";
+
+export function pluginShortcutActionId(shortcutId: string): string {
+  return `${PLUGIN_ACTION_PREFIX}${shortcutId}`;
+}

package/src/app/keybindings/capture-request.ts

@@ -0,0 +1,36 @@
+/**
+ * A request to bind a key to command bar text, handed from the command bar to
+ * the help pane. The bar cannot capture a key itself: the moment it opens, it
+ * owns the keyboard, and the capture has to outlive the bar closing.
+ */
+export interface KeybindingCaptureRequest {
+  kind: "command";
+  query: string;
+}
+
+let pending: KeybindingCaptureRequest | null = null;
+const listeners = new Set<() => void>();
+
+export function requestKeybindingCapture(request: KeybindingCaptureRequest): void {
+  pending = request;
+  for (const listener of listeners) listener();
+}
+
+/** Whether a request is waiting, for a pane deciding which tab to open on. */
+export function hasKeybindingCaptureRequest(): boolean {
+  return pending !== null;
+}
+
+/** Returns and clears the pending request, so it is honoured exactly once. */
+export function takeKeybindingCaptureRequest(): KeybindingCaptureRequest | null {
+  const request = pending;
+  pending = null;
+  return request;
+}
+
+export function subscribeKeybindingCapture(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}