gloomberb 0.6.0 → 0.7.0

package/src/state/pane-scroll-registry.tsx

@@ -0,0 +1,254 @@
+import { useImperativeHandle, useLayoutEffect, useRef, type ForwardedRef, type RefObject } from "react";
+import { useShortcut } from "../react/input";
+import { useNativeRenderer, type ScrollBoxRenderable } from "../ui/host";
+import { useAppSelector, useOptionalPaneInstanceId } from "./app-context";
+
+type ScrollDirection = "up" | "down";
+
+interface PaneScrollAction {
+  direction: ScrollDirection;
+  resolveTarget(scrollBox: ScrollBoxRenderable): number | null;
+}
+
+interface PaneScrollEntry {
+  order: number;
+  ref: RefObject<ScrollBoxRenderable | null>;
+  onScrollActivity?: (event: { scroll: { direction: ScrollDirection; delta: number } }) => void;
+}
+
+interface PaneScrollKeyEvent {
+  name?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  alt?: boolean;
+  option?: boolean;
+  defaultPrevented?: boolean;
+  propagationStopped?: boolean;
+  preventDefault?: () => void;
+  stopPropagation?: () => void;
+}
+
+const paneScrollBoxes = new Map<string, Map<number, PaneScrollEntry>>();
+let nextScrollEntryId = 1;
+let nextScrollEntryOrder = 1;
+const MIN_ARROW_SCROLL_LINES = 3;
+
+function hasHiddenAncestor(scrollBox: ScrollBoxRenderable): boolean {
+  let node: unknown = scrollBox;
+  const seen = new Set<unknown>();
+
+  while (node && typeof node === "object" && !seen.has(node)) {
+    seen.add(node);
+    const renderable = node as { visible?: unknown; parent?: unknown };
+    if (renderable.visible === false) return true;
+    node = renderable.parent;
+  }
+
+  return false;
+}
+
+function hasCollapsedBounds(scrollBox: ScrollBoxRenderable): boolean {
+  const bounds = scrollBox.getBoundingClientRect?.();
+  return bounds != null && (bounds.width <= 0 || bounds.height <= 0);
+}
+
+function isVisibleScrollBox(scrollBox: ScrollBoxRenderable): boolean {
+  return !hasHiddenAncestor(scrollBox) && !hasCollapsedBounds(scrollBox);
+}
+
+function clampScrollTop(scrollBox: ScrollBoxRenderable, target: number): number | null {
+  const viewportHeight = Math.max(0, scrollBox.viewport?.height ?? 0);
+  if (viewportHeight <= 0) return null;
+  const maxScrollTop = Math.max(0, scrollBox.scrollHeight - viewportHeight);
+  if (maxScrollTop <= 0) return null;
+  return Math.max(0, Math.min(maxScrollTop, target));
+}
+
+function scrollTargetByDelta(scrollBox: ScrollBoxRenderable, delta: number): number | null {
+  const target = clampScrollTop(scrollBox, scrollBox.scrollTop + delta);
+  return target == null || target === scrollBox.scrollTop ? null : target;
+}
+
+function arrowScrollLines(scrollBox: ScrollBoxRenderable): number {
+  return Math.max(MIN_ARROW_SCROLL_LINES, Math.floor((scrollBox.viewport?.height ?? 0) / 4));
+}
+
+function resolveKeyScrollAction(event: PaneScrollKeyEvent): PaneScrollAction | null {
+  if (event.ctrl || event.meta || event.alt || event.option) return null;
+
+  switch (event.name) {
+    case "down":
+      return {
+        direction: "down",
+        resolveTarget: (scrollBox) => scrollTargetByDelta(scrollBox, arrowScrollLines(scrollBox)),
+      };
+    case "up":
+      return {
+        direction: "up",
+        resolveTarget: (scrollBox) => scrollTargetByDelta(scrollBox, -arrowScrollLines(scrollBox)),
+      };
+    case "pagedown":
+      return {
+        direction: "down",
+        resolveTarget: (scrollBox) => scrollTargetByDelta(
+          scrollBox,
+          Math.max(1, (scrollBox.viewport?.height ?? 1) - 1),
+        ),
+      };
+    case "pageup":
+      return {
+        direction: "up",
+        resolveTarget: (scrollBox) => scrollTargetByDelta(
+          scrollBox,
+          -Math.max(1, (scrollBox.viewport?.height ?? 1) - 1),
+        ),
+      };
+    case "home":
+      return {
+        direction: "up",
+        resolveTarget: (scrollBox) => (
+          scrollBox.scrollTop > 0 ? 0 : null
+        ),
+      };
+    case "end":
+      return {
+        direction: "down",
+        resolveTarget: (scrollBox) => {
+          const target = clampScrollTop(scrollBox, Number.MAX_SAFE_INTEGER);
+          return target == null || target === scrollBox.scrollTop ? null : target;
+        },
+      };
+    default:
+      return null;
+  }
+}
+
+function getEntryScore(entry: PaneScrollEntry, scrollBox: ScrollBoxRenderable): number {
+  const viewportHeight = scrollBox.viewport?.height ?? 0;
+  const scrollHeight = scrollBox.scrollHeight;
+  return viewportHeight * 100_000 + Math.min(scrollHeight, 99_999) + entry.order / 100_000;
+}
+
+function findScrollableEntry(paneId: string, action: PaneScrollAction): {
+  entry: PaneScrollEntry;
+  scrollBox: ScrollBoxRenderable;
+  target: number;
+} | null {
+  const entries = paneScrollBoxes.get(paneId);
+  if (!entries) return null;
+
+  let best: { entry: PaneScrollEntry; scrollBox: ScrollBoxRenderable; target: number; score: number } | null = null;
+  for (const entry of entries.values()) {
+    const scrollBox = entry.ref.current;
+    if (!scrollBox) continue;
+    if (!isVisibleScrollBox(scrollBox)) continue;
+
+    const target = action.resolveTarget(scrollBox);
+    if (target == null) continue;
+
+    const score = getEntryScore(entry, scrollBox);
+    if (!best || score > best.score) {
+      best = { entry, scrollBox, target, score };
+    }
+  }
+
+  if (!best) return null;
+  return { entry: best.entry, scrollBox: best.scrollBox, target: best.target };
+}
+
+function scrollPaneByKey(paneId: string, event: PaneScrollKeyEvent): boolean {
+  const action = resolveKeyScrollAction(event);
+  if (!action) return false;
+
+  const match = findScrollableEntry(paneId, action);
+  if (!match) return false;
+
+  const previousTop = match.scrollBox.scrollTop;
+  match.scrollBox.scrollTo(match.target);
+  if (match.scrollBox.scrollTop !== match.target) {
+    match.scrollBox.scrollTop = match.target;
+  }
+
+  const delta = Math.abs(match.scrollBox.scrollTop - previousTop);
+  if (delta > 0) {
+    match.entry.onScrollActivity?.({ scroll: { direction: action.direction, delta } });
+  }
+  return delta > 0;
+}
+
+export function useForwardedScrollBoxRef<T>(
+  forwardedRef: ForwardedRef<T>,
+): RefObject<T | null> {
+  const localRef = useRef<T | null>(null);
+  useImperativeHandle(forwardedRef, () => localRef.current as T);
+  return localRef;
+}
+
+export function useRegisterPaneScrollBox(
+  ref: RefObject<ScrollBoxRenderable | null>,
+  options: {
+    enabled: boolean;
+    onScrollActivity?: PaneScrollEntry["onScrollActivity"];
+  },
+): void {
+  const paneId = useOptionalPaneInstanceId();
+  const entryIdRef = useRef<number | null>(null);
+
+  useLayoutEffect(() => {
+    if (!paneId || !options.enabled) return;
+
+    const entryId = nextScrollEntryId++;
+    entryIdRef.current = entryId;
+    let entries = paneScrollBoxes.get(paneId);
+    if (!entries) {
+      entries = new Map();
+      paneScrollBoxes.set(paneId, entries);
+    }
+    entries.set(entryId, {
+      order: nextScrollEntryOrder++,
+      ref,
+      onScrollActivity: options.onScrollActivity,
+    });
+
+    return () => {
+      const currentEntries = paneScrollBoxes.get(paneId);
+      currentEntries?.delete(entryId);
+      if (currentEntries?.size === 0) {
+        paneScrollBoxes.delete(paneId);
+      }
+      if (entryIdRef.current === entryId) {
+        entryIdRef.current = null;
+      }
+    };
+  }, [paneId, options.enabled, options.onScrollActivity, ref]);
+}
+
+export function PaneKeyboardScrollController({
+  paneId,
+  focused,
+}: {
+  paneId: string;
+  focused: boolean;
+}) {
+  const nativeRenderer = useNativeRenderer();
+  const inputCaptured = useAppSelector((state) => state.inputCaptured);
+  const focusedRef = useRef(focused);
+  const inputCapturedRef = useRef(inputCaptured);
+  const paneIdRef = useRef(paneId);
+
+  focusedRef.current = focused;
+  inputCapturedRef.current = inputCaptured;
+  paneIdRef.current = paneId;
+
+  useShortcut((event) => {
+    if (!focusedRef.current || inputCapturedRef.current) return;
+    if (event.defaultPrevented || event.propagationStopped) return;
+    if (!scrollPaneByKey(paneIdRef.current, event)) return;
+
+    event.preventDefault();
+    event.stopPropagation();
+    nativeRenderer.requestRender();
+  }, { phase: "after" });
+
+  return null;
+}

package/src/state/use-inline-tickers.test.tsx

@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../renderers/opentui/test-utils";
+import { setSharedMarketDataCoordinator } from "../market-data/coordinator";
+import { setSharedRegistryForTests, type PluginRegistry } from "../plugins/registry";
+import { createDefaultConfig } from "../types/config";
+import { AppContext, createInitialState } from "./app-context";
+import { useInlineTickers } from "./use-inline-tickers";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+function InlineTickerHarness() {
+  const { catalog } = useInlineTickers(["$LGD1L"]);
+  return <text>{catalog.LGD1L?.status ?? "none"}</text>;
+}
+
+afterEach(() => {
+  testSetup?.renderer.destroy();
+  testSetup = undefined;
+  setSharedMarketDataCoordinator(null);
+  setSharedRegistryForTests(undefined);
+});
+
+describe("useInlineTickers", () => {
+  test("does not leak rejected quote lookups for existing inline tickers", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-inline-tickers-test");
+    const state = createInitialState(config);
+    state.tickers.set("LGD1L", {
+      metadata: {
+        ticker: "LGD1L",
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: "Unsupported quote",
+        portfolios: [],
+        watchlists: [],
+        positions: [],
+        broker_contracts: [],
+        custom: {},
+        tags: [],
+      },
+    });
+    const actions: unknown[] = [];
+    setSharedRegistryForTests({
+      marketData: {
+        getQuote: async () => {
+          throw new Error("No quote provider available for LGD1L");
+        },
+      },
+      pinTicker: () => {},
+    } as unknown as PluginRegistry);
+
+    await act(async () => {
+      testSetup = await testRender(
+        <AppContext value={{ state, dispatch: (action) => actions.push(action) }}>
+          <InlineTickerHarness />
+        </AppContext>,
+        { width: 20, height: 1 },
+      );
+    });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    expect(testSetup.captureCharFrame()).toContain("missing");
+    expect(actions).toEqual([]);
+  });
+});

package/src/state/use-inline-tickers.ts

@@ -18,6 +18,7 @@ export interface InlineTickerCatalogEntry {
 const resolutionInFlight = new Map<string, Promise<void>>();
 const quoteInFlight = new Map<string, Promise<void>>();
 const missingSymbols = new Set<string>();
+const quoteMissingSymbols = new Set<string>();
 const initialQuoteRequested = new Set<string>();
 
 function normalizeSymbols(texts: readonly string[]): string[] {
@@ -54,6 +55,7 @@ export function useInlineTickers(texts: readonly string[]): {
 
       if (currentTicker && currentQuote) {
         missingSymbols.delete(symbol);
+        quoteMissingSymbols.delete(symbol);
         initialQuoteRequested.delete(symbol);
         continue;
       }
@@ -123,8 +125,12 @@ export function useInlineTickers(texts: readonly string[]): {
               }
               : undefined,
           );
+          quoteMissingSymbols.delete(symbol);
           current.dispatch({ type: "MERGE_QUOTE", symbol, quote });
         })()
+          .catch(() => {
+            quoteMissingSymbols.add(symbol);
+          })
           .finally(() => {
             quoteInFlight.delete(symbol);
           });
@@ -167,7 +173,7 @@ export function useInlineTickers(texts: readonly string[]): {
     const ticker = tickers.get(symbol) ?? null;
     const quote = financials.get(symbol)?.quote ?? null;
     const status: InlineTickerStatus = ticker
-      ? (quote ? "ready" : "loading")
+      ? (quote ? "ready" : quoteMissingSymbols.has(symbol) ? "missing" : "loading")
       : (missingSymbols.has(symbol) ? "missing" : "loading");
     catalog[symbol] = { status, ticker, quote };
   }

package/src/test-support/plugin-runtime.ts

@@ -23,8 +23,9 @@ export function createTestPluginRuntime(
     switchTab() {},
     switchPanel() {},
     openCommandBar() {},
-    showWidget() {},
-    hideWidget() {},
+    showPane() {},
+    hidePane() {},
+    openPaneSettings() {},
     openPluginCommandWorkflow() {},
     notify() {},
     subscribeResumeState: () => () => {},

package/src/theme/colors.ts

@@ -74,7 +74,7 @@ export function commandBarOverlayBg(): string {
 export function commandBarSelectedBg(): string {
   const base = commandBarBg();
   const accent = higherContrast(colors.selectedText, colors.textBright, colors.selected);
-  return blendForContrast(colors.selected, base, accent, 1.6);
+  return blendForContrast(colors.selected, base, accent, 1.45);
 }
 
 export function commandBarHoverBg(): string {
@@ -89,7 +89,12 @@ export function commandBarText(): string {
 
 export function commandBarHeadingText(): string {
   const base = commandBarBg();
-  return blendForContrast("#8f959e", base, "#b7bec8", 3.6);
+  const fallback = higherContrast(
+    higherContrast(colors.textDim, colors.text, base),
+    higherContrast(colors.textBright, colors.selectedText, base),
+    base,
+  );
+  return blendForContrast(colors.textMuted, base, fallback, 3.6);
 }
 
 export function commandBarSubtleText(): string {
@@ -101,7 +106,11 @@ export function commandBarSubtleText(): string {
 export function commandBarSelectedText(): string {
   const base = commandBarSelectedBg();
   const preferred = higherContrast(colors.selectedText, colors.text, base);
-  const fallback = higherContrast(colors.textBright, "#f2f2f2", base);
+  const fallback = higherContrast(
+    higherContrast(colors.textBright, colors.text, base),
+    higherContrast("#ffffff", "#000000", base),
+    base,
+  );
   return blendForContrast(preferred, base, fallback, 4.5);
 }
 

package/src/theme/themes.test.ts

@@ -1,5 +1,17 @@
 import { afterEach, describe, test } from "bun:test";
-import { applyTheme, floatingPaneTitleBg, paneTitleBg, paneTitleText } from "./colors";
+import {
+  applyTheme,
+  commandBarBg,
+  commandBarHeadingText,
+  commandBarPanelBg,
+  commandBarSelectedBg,
+  commandBarSelectedText,
+  commandBarSubtleText,
+  commandBarText,
+  floatingPaneTitleBg,
+  paneTitleBg,
+  paneTitleText,
+} from "./colors";
 import { contrastRatio } from "./color-utils";
 import { DEFAULT_THEME, themes } from "./themes";
 
@@ -44,4 +56,14 @@ describe("theme contrast", () => {
       assertMinContrast(id, "floatingPaneTitleText/unfocused", paneTitleText(false, true), floatingPaneTitleBg(false), CHROME_TEXT_MIN);
     }
   });
+
+  test("keeps command bar text readable", () => {
+    for (const id of Object.keys(themes)) {
+      applyTheme(id);
+      assertMinContrast(id, "commandBarText/bg", commandBarText(), commandBarBg(), BODY_TEXT_MIN);
+      assertMinContrast(id, "commandBarHeadingText/bg", commandBarHeadingText(), commandBarBg(), SUBTLE_TEXT_MIN);
+      assertMinContrast(id, "commandBarSubtleText/panel", commandBarSubtleText(), commandBarPanelBg(), SUBTLE_TEXT_MIN);
+      assertMinContrast(id, "commandBarSelectedText/selected", commandBarSelectedText(), commandBarSelectedBg(), BODY_TEXT_MIN);
+    }
+  });
 });

package/src/theme/themes.ts

@@ -305,6 +305,121 @@ const rawThemes: Record<string, Theme> = {
     commandBorder: "#cccccc",
   },
 
+  paper: {
+    name: "Paper",
+    description: "Warm light terminal palette",
+    bg: "#f7f3e8",
+    panel: "#fffaf0",
+    border: "#d8cdb7",
+    borderFocused: "#a05a2c",
+    text: "#2f2a23",
+    textDim: "#5f5548",
+    textBright: "#17130f",
+    textMuted: "#776b5d",
+    positive: "#2f7d4a",
+    negative: "#b33630",
+    neutral: "#6e6256",
+    warning: "#946200",
+    header: "#eadcc4",
+    headerText: "#7a3f1f",
+    selected: "#ead1ab",
+    selectedText: "#211810",
+    commandBg: "#fff7e8",
+    commandBorder: "#a05a2c",
+  },
+
+  "github-light": {
+    name: "GitHub Light",
+    description: "Clean light code palette",
+    bg: "#ffffff",
+    panel: "#f6f8fa",
+    border: "#d0d7de",
+    borderFocused: "#0969da",
+    text: "#24292f",
+    textDim: "#57606a",
+    textBright: "#0b1220",
+    textMuted: "#6e7781",
+    positive: "#1a7f37",
+    negative: "#cf222e",
+    neutral: "#57606a",
+    warning: "#9a6700",
+    header: "#eaeef2",
+    headerText: "#0969da",
+    selected: "#ddf4ff",
+    selectedText: "#0b1220",
+    commandBg: "#f6f8fa",
+    commandBorder: "#0969da",
+  },
+
+  "solarized-light": {
+    name: "Solarized Light",
+    description: "Ethan Schoonover's light palette",
+    bg: "#fdf6e3",
+    panel: "#eee8d5",
+    border: "#93a1a1",
+    borderFocused: "#b58900",
+    text: "#586e75",
+    textDim: "#657b83",
+    textBright: "#073642",
+    textMuted: "#7c8a8a",
+    positive: "#859900",
+    negative: "#dc322f",
+    neutral: "#657b83",
+    warning: "#b58900",
+    header: "#e6dfc9",
+    headerText: "#268bd2",
+    selected: "#dce6d6",
+    selectedText: "#073642",
+    commandBg: "#eee8d5",
+    commandBorder: "#b58900",
+  },
+
+  "gruvbox-light": {
+    name: "Gruvbox Light",
+    description: "Retro earthy light palette",
+    bg: "#fbf1c7",
+    panel: "#f2e5bc",
+    border: "#d5c4a1",
+    borderFocused: "#af3a03",
+    text: "#3c3836",
+    textDim: "#665c54",
+    textBright: "#282828",
+    textMuted: "#7c6f64",
+    positive: "#79740e",
+    negative: "#9d0006",
+    neutral: "#665c54",
+    warning: "#b57614",
+    header: "#ebdbb2",
+    headerText: "#af3a03",
+    selected: "#d5c4a1",
+    selectedText: "#282828",
+    commandBg: "#f2e5bc",
+    commandBorder: "#af3a03",
+  },
+
+  "nord-light": {
+    name: "Nord Light",
+    description: "Soft arctic light palette",
+    bg: "#eceff4",
+    panel: "#e5e9f0",
+    border: "#d8dee9",
+    borderFocused: "#5e81ac",
+    text: "#2e3440",
+    textDim: "#4c566a",
+    textBright: "#1f2530",
+    textMuted: "#687286",
+    positive: "#4b7f36",
+    negative: "#bf616a",
+    neutral: "#4c566a",
+    warning: "#9a7500",
+    header: "#d8dee9",
+    headerText: "#5e81ac",
+    selected: "#c8d5e8",
+    selectedText: "#1f2530",
+    commandBg: "#e5e9f0",
+    commandBorder: "#5e81ac",
+  },
+
   tokyo: {
     name: "Tokyo Night",
     description: "Cool blue-purple palette",

package/src/types/broker.ts

@@ -67,7 +67,7 @@ export interface BrokerConnectionStatus {
 export interface BrokerProfileAction {
   id: string;
   label: string;
-  widgetId?: string;
+  paneId?: string;
   disabled?: boolean;
   disabledReason?: string;
 }

package/src/types/data-provider.ts

@@ -2,7 +2,6 @@ import type {
   AnalystResearchData,
   CorporateActionsData,
   Quote,
-  Fundamentals,
   TickerFinancials,
   PricePoint,
   OptionsChain,

package/src/types/plugin.ts

@@ -455,8 +455,6 @@ export interface GloomPluginContext {
   on<K extends keyof PluginEvents>(event: K, handler: (payload: PluginEvents[K]) => void): () => void;
   emit<K extends keyof PluginEvents>(event: K, payload: PluginEvents[K]): void;
 
-  showWidget(widgetId: string): void;
-  hideWidget(widgetId: string): void;
   notify(notification: AppNotificationRequest): void;
 }
 

package/src/ui/host.tsx

@@ -99,6 +99,9 @@ export interface ScrollBoxRenderable {
   scrollLeft?: number;
   scrollHeight: number;
   viewport?: { width: number; height: number };
+  visible?: boolean;
+  parent?: unknown;
+  getBoundingClientRect?: () => { x: number; y: number; width: number; height: number };
   horizontalScrollBar?: { visible: boolean };
   verticalScrollBar?: { visible: boolean };
   scrollTo(target: number | { x?: number; y?: number }, y?: number): void;
@@ -242,6 +245,7 @@ export interface UiHost {
     cellHeightPx?: number;
     pixelRatio?: number;
     canvasCharts?: boolean;
+    nativeCharts?: boolean;
     nativeContextMenu?: boolean;
   };
   Box: ComponentType<BoxProps>;

package/src/ui/index.tsx

@@ -1,4 +1,5 @@
 import { createElement, forwardRef } from "react";
+import { useForwardedScrollBoxRef, useRegisterPaneScrollBox } from "../state/pane-scroll-registry";
 import { useUiHost } from "./host";
 export {
   RGBA,
@@ -85,7 +86,14 @@ Underline.displayName = "Underline";
 
 export const ScrollBox = forwardRef<any, import("./host").ScrollBoxProps>((props, ref) => {
   const { ScrollBox: HostScrollBox } = useUiHost();
-  return createElement(HostScrollBox as any, { ...props, ref });
+  const localRef = useForwardedScrollBoxRef<any>(ref);
+  useRegisterPaneScrollBox(localRef, {
+    enabled: props.scrollY === true,
+    onScrollActivity: typeof props.onMouseScroll === "function"
+      ? props.onMouseScroll as (event: { scroll: { direction: "up" | "down"; delta: number } }) => void
+      : undefined,
+  });
+  return createElement(HostScrollBox as any, { ...props, ref: localRef });
 });
 ScrollBox.displayName = "ScrollBox";
 

package/src/utils/back-navigation.ts

@@ -1,11 +1,20 @@
 export interface BackNavigationEventLike {
   name?: string;
+  key?: string;
   ctrl?: boolean;
   meta?: boolean;
   option?: boolean;
   shift?: boolean;
 }
 
+export interface BackNavigationMouseEventLike {
+  button?: unknown;
+}
+
+export const MOUSE_BACK_NAVIGATION_EVENT_NAME = "mouse-back";
+export const WEB_MOUSE_BACK_NAVIGATION_BUTTON = 3;
+export const TERMINAL_MOUSE_BACK_NAVIGATION_BUTTON = 8;
+
 export function isPlainBackspace(event: BackNavigationEventLike): boolean {
   return event.name === "backspace"
     && !event.ctrl
@@ -29,5 +38,19 @@ export function isBackNavigationKey(event: BackNavigationEventLike): boolean {
 export function isDetailBackNavigationKey(
   event: BackNavigationEventLike,
 ): boolean {
-  return isPlainBackspace(event);
+  return isPlainBackspace(event)
+    || isPlainEscape(event)
+    || event.name === MOUSE_BACK_NAVIGATION_EVENT_NAME
+    || event.key === MOUSE_BACK_NAVIGATION_EVENT_NAME;
+}
+
+export function isMouseBackNavigationButton(button: unknown): boolean {
+  return button === WEB_MOUSE_BACK_NAVIGATION_BUTTON
+    || button === TERMINAL_MOUSE_BACK_NAVIGATION_BUTTON;
+}
+
+export function isMouseBackNavigationEvent(
+  event: BackNavigationMouseEventLike | null | undefined,
+): boolean {
+  return isMouseBackNavigationButton(event?.button);
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.6.0";
+export const VERSION = "0.7.0";