gloomberb 0.13.3 → 0.14.1

package/src/components/layout/shell/pane-occlusion.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { resolveOccludedPaneIds, type OcclusionPane } from "./pane-occlusion";
+
+const bounds = { width: 40, height: 20 };
+
+function pane(paneId: string, rect: [number, number, number, number], zIndex: number | null, order: number): OcclusionPane {
+  return { paneId, rect: { x: rect[0], y: rect[1], width: rect[2], height: rect[3] }, zIndex, order };
+}
+
+describe("resolveOccludedPaneIds", () => {
+  test("a window wholly inside a higher one is hidden, the higher one is not", () => {
+    const occluded = resolveOccludedPaneIds([
+      pane("under", [5, 5, 10, 6], 50, 0),
+      pane("over", [4, 4, 14, 9], 51, 1),
+    ], bounds);
+    expect([...occluded]).toEqual(["under"]);
+  });
+
+  test("the union of two windows hides a pane neither covers alone", () => {
+    const occluded = resolveOccludedPaneIds([
+      pane("under", [0, 0, 20, 10], 50, 0),
+      pane("left", [0, 0, 10, 10], 51, 1),
+      pane("right", [10, 0, 10, 10], 51, 2),
+    ], bounds);
+    expect([...occluded]).toEqual(["under"]);
+  });
+
+  test("a single uncovered cell keeps the pane visible", () => {
+    const occluded = resolveOccludedPaneIds([
+      pane("under", [0, 0, 20, 10], 50, 0),
+      pane("over", [0, 0, 20, 9], 51, 1),
+    ], bounds);
+    expect(occluded.size).toBe(0);
+  });
+
+  test("equal z-index stacks by render order and docked panes sit below floating ones", () => {
+    const occluded = resolveOccludedPaneIds([
+      pane("dock", [0, 0, 40, 20], null, 0),
+      pane("first", [0, 0, 40, 20], 50, 1),
+      pane("second", [0, 0, 40, 20], 50, 2),
+    ], bounds);
+    expect([...occluded].sort()).toEqual(["dock", "first"]);
+  });
+
+  test("a window off the content area does not count as covering", () => {
+    const occluded = resolveOccludedPaneIds([
+      pane("under", [0, 0, 10, 10], 50, 0),
+      pane("outside", [40, 20, 10, 10], 51, 1),
+    ], bounds);
+    expect(occluded.size).toBe(0);
+  });
+});

package/src/components/layout/shell/pane-occlusion.ts

@@ -0,0 +1,63 @@
+import type { LayoutBounds } from "../../../plugins/pane-manager";
+
+export interface OcclusionPane {
+  paneId: string;
+  rect: LayoutBounds;
+  /** Floating panes stack by z-index, then by render order. Docked panes sit below all of them. */
+  zIndex: number | null;
+  order: number;
+}
+
+/**
+ * Panes whose every cell is covered by panes stacked above them.
+ *
+ * The terminal renderer is immediate-mode: it redraws every visible
+ * renderable each frame before diffing, so a pane buried under floating
+ * windows still costs its full draw on every keypress. Marking it invisible
+ * skips the draw while its React tree, state, and subscriptions stay
+ * mounted. Coverage is exact, so a pane hidden by the union of two windows
+ * counts too, not only one wholly inside another.
+ */
+export function resolveOccludedPaneIds(
+  panes: readonly OcclusionPane[],
+  bounds: { width: number; height: number },
+): Set<string> {
+  const occluded = new Set<string>();
+  const width = Math.max(0, Math.floor(bounds.width));
+  const height = Math.max(0, Math.floor(bounds.height));
+  if (width === 0 || height === 0 || panes.length < 2) return occluded;
+
+  const stacked = [...panes].sort((left, right) => {
+    const leftZ = left.zIndex ?? Number.NEGATIVE_INFINITY;
+    const rightZ = right.zIndex ?? Number.NEGATIVE_INFINITY;
+    if (leftZ !== rightZ) return rightZ - leftZ;
+    return right.order - left.order;
+  });
+
+  const covered = new Uint8Array(width * height);
+  for (const pane of stacked) {
+    const x0 = Math.max(0, Math.floor(pane.rect.x));
+    const y0 = Math.max(0, Math.floor(pane.rect.y));
+    const x1 = Math.min(width, Math.ceil(pane.rect.x + pane.rect.width));
+    const y1 = Math.min(height, Math.ceil(pane.rect.y + pane.rect.height));
+    if (x1 <= x0 || y1 <= y0) continue;
+    let hidden = true;
+    for (let y = y0; y < y1 && hidden; y += 1) {
+      const row = y * width;
+      for (let x = x0; x < x1; x += 1) {
+        if (covered[row + x] === 0) {
+          hidden = false;
+          break;
+        }
+      }
+    }
+    if (hidden) {
+      occluded.add(pane.paneId);
+      continue;
+    }
+    for (let y = y0; y < y1; y += 1) {
+      covered.fill(1, y * width + x0, y * width + x1);
+    }
+  }
+  return occluded;
+}

package/src/components/layout/shell/shortcuts.ts

@@ -1,20 +1,12 @@
 import type { KeyEventLike } from "../../../react/input";
-
-export const PANE_MANAGEMENT_ACCELERATORS = {
-  settings: "CmdOrCtrl+,",
-  fullscreen: "CmdOrCtrl+Shift+F",
-  toggleFloating: "CmdOrCtrl+Shift+D",
-  popOut: "CmdOrCtrl+Shift+O",
-  copyScreenshot: "CmdOrCtrl+Shift+C",
-  exportCsv: "CmdOrCtrl+Shift+E",
-  share: "CmdOrCtrl+Shift+S",
-  close: "CmdOrCtrl+W",
-  closeAllFloating: "CmdOrCtrl+Alt+W",
-  layoutGallery: "CmdOrCtrl+Shift+L",
-  gridlockAll: "CmdOrCtrl+Shift+G",
-  windowMode: "CmdOrCtrl+Shift+M",
-  windowResizeMode: "CmdOrCtrl+Shift+R",
-} as const;
+import {
+  getDefaultKeybindings,
+  isPaneKeybindingAction,
+  matchKeybinding,
+  menuAcceleratorFor,
+  type CoreKeybindingActionId,
+  type ResolvedKeybindings,
+} from "../../../app/keybindings";
 
 export type PaneManagementShortcut =
   | "settings"
@@ -31,28 +23,56 @@ export type PaneManagementShortcut =
   | "window-mode"
   | "window-resize-mode";
 
+const PANE_ACTION_TO_SHORTCUT: Partial<Record<CoreKeybindingActionId, PaneManagementShortcut>> = {
+  "pane-settings": "settings",
+  "pane-fullscreen": "toggle-fullscreen",
+  "pane-float": "toggle-floating",
+  "pane-pop-out": "pop-out",
+  "pane-screenshot": "copy-screenshot",
+  "pane-export-csv": "export-csv",
+  "pane-share": "share",
+  "pane-close": "close",
+  "close-floating-panes": "close-all-floating",
+  "layout-gallery": "layout-gallery",
+  "tidy-windows": "gridlock-all",
+  "window-move-mode": "window-mode",
+  "window-resize-mode": "window-resize-mode",
+};
+
+export type PaneManagementAccelerators = Record<
+  "settings" | "fullscreen" | "toggleFloating" | "popOut" | "copyScreenshot" | "exportCsv" | "share" | "close"
+  | "closeAllFloating" | "layoutGallery" | "gridlockAll" | "windowMode" | "windowResizeMode",
+  string | undefined
+>;
+
+/** Menu accelerators for the pane actions, read from the same table the keys are. */
+export function paneManagementAccelerators(keybindings: ResolvedKeybindings): PaneManagementAccelerators {
+  return {
+    settings: menuAcceleratorFor(keybindings, "pane-settings"),
+    fullscreen: menuAcceleratorFor(keybindings, "pane-fullscreen"),
+    toggleFloating: menuAcceleratorFor(keybindings, "pane-float"),
+    popOut: menuAcceleratorFor(keybindings, "pane-pop-out"),
+    copyScreenshot: menuAcceleratorFor(keybindings, "pane-screenshot"),
+    exportCsv: menuAcceleratorFor(keybindings, "pane-export-csv"),
+    share: menuAcceleratorFor(keybindings, "pane-share"),
+    close: menuAcceleratorFor(keybindings, "pane-close"),
+    closeAllFloating: menuAcceleratorFor(keybindings, "close-floating-panes"),
+    layoutGallery: menuAcceleratorFor(keybindings, "layout-gallery"),
+    gridlockAll: menuAcceleratorFor(keybindings, "tidy-windows"),
+    windowMode: menuAcceleratorFor(keybindings, "window-move-mode"),
+    windowResizeMode: menuAcceleratorFor(keybindings, "window-resize-mode"),
+  };
+}
+
+export const PANE_MANAGEMENT_ACCELERATORS = paneManagementAccelerators(getDefaultKeybindings());
+
 export function resolvePaneManagementShortcut(
   event: Pick<KeyEventLike, "name" | "key" | "ctrl" | "meta" | "super" | "shift" | "alt">,
+  keybindings: ResolvedKeybindings = getDefaultKeybindings(),
 ): PaneManagementShortcut | null {
-  if (!event.ctrl && !event.meta && !event.super) return null;
-  const rawName = event.name ?? event.key ?? "";
-  const name = rawName.toLowerCase();
-  const shifted = event.shift || rawName !== name;
-  if (!shifted && event.alt && name === "w") return "close-all-floating";
-  if (!shifted && name === "w") return "close";
-  if (!shifted && name === ",") return "settings";
-  if (!shifted || event.alt) return null;
-  if (name === "c") return "copy-screenshot";
-  if (name === "e") return "export-csv";
-  if (name === "s") return "share";
-  if (name === "d") return "toggle-floating";
-  if (name === "f") return "toggle-fullscreen";
-  if (name === "o") return "pop-out";
-  if (name === "l") return "layout-gallery";
-  if (name === "g") return "gridlock-all";
-  if (name === "m") return "window-mode";
-  if (name === "r") return "window-resize-mode";
-  return null;
+  const match = matchKeybinding(keybindings, event);
+  if (!match || match.kind !== "action" || !isPaneKeybindingAction(match.id)) return null;
+  return PANE_ACTION_TO_SHORTCUT[match.id as CoreKeybindingActionId] ?? null;
 }
 
 export function inputCaptureAllowsPaneManagementShortcut(

package/src/components/layout/status-bar-groups.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import type { TeamSummary } from "../../api-client";
+import {
+  buildStatusBarTabGroups,
+  focusCollapses,
+  groupIdFromMarkerValue,
+  groupMarkerValue,
+} from "./status-bar-groups";
+
+function team(id: string, name: string): TeamSummary {
+  return {
+    id,
+    name,
+    slug: name.toLowerCase(),
+    accentColor: "blue",
+    shortName: name.slice(0, 2).toUpperCase(),
+    allowMemberInvites: false,
+    channelId: `team:${id}`,
+    createdAt: "2026-09-14T12:00:00.000Z",
+    role: "member",
+    memberCount: 2,
+  };
+}
+
+const origin = (teamId: string) => ({
+  kind: "team" as const,
+  teamId,
+  layoutId: "a".repeat(32),
+  revision: 1,
+  contentHash: "x",
+  syncedAt: "2026-09-14T12:00:00.000Z",
+});
+
+const layouts = [
+  { origin: undefined },
+  { origin: origin("rates") },
+  { origin: undefined },
+  { origin: origin("macro") },
+  { origin: origin("rates") },
+];
+const teams = [team("rates", "Rates"), team("macro", "Macro")];
+
+describe("status bar tab groups", () => {
+  test("puts personal tabs first, then teams by name, keeping indexes", () => {
+    const groups = buildStatusBarTabGroups(layouts, 0, teams, "all", new Set());
+    expect(groups.map((group) => [group.id, group.indexes, group.collapsed])).toEqual([
+      ["personal", [0, 2], false],
+      ["team:macro", [3], false],
+      ["team:rates", [1, 4], false],
+    ]);
+  });
+
+  test("FOCUS folds the other groups but never the one holding the active tab", () => {
+    expect(focusCollapses("personal", "team:rates")).toBe(true);
+    expect(focusCollapses("personal", "personal")).toBe(false);
+    expect(focusCollapses({ teamId: "rates" }, "personal")).toBe(true);
+    expect(focusCollapses({ teamId: "rates" }, "team:rates")).toBe(false);
+    expect(focusCollapses("all", "team:rates")).toBe(false);
+
+    const personalFocus = buildStatusBarTabGroups(layouts, 0, teams, "personal", new Set());
+    expect(personalFocus.map((group) => group.collapsed)).toEqual([false, true, true]);
+
+    const activeInRates = buildStatusBarTabGroups(layouts, 4, teams, "personal", new Set());
+    expect(activeInRates.map((group) => group.collapsed)).toEqual([false, true, false]);
+
+    const ratesFocus = buildStatusBarTabGroups(layouts, 1, teams, { teamId: "rates" }, new Set());
+    expect(ratesFocus.map((group) => group.collapsed)).toEqual([true, true, false]);
+  });
+
+  test("a manual toggle flips what FOCUS decided", () => {
+    const groups = buildStatusBarTabGroups(layouts, 0, teams, "personal", new Set(["team:macro"]));
+    expect(groups.map((group) => group.collapsed)).toEqual([false, false, true]);
+    const folded = buildStatusBarTabGroups(layouts, 1, teams, "all", new Set(["team:macro"]));
+    expect(folded.map((group) => group.collapsed)).toEqual([false, true, false]);
+  });
+
+  test("groups without a known team still appear, after the known ones", () => {
+    const groups = buildStatusBarTabGroups(layouts, 0, [team("rates", "Rates")], "all", new Set());
+    expect(groups.map((group) => [group.id, group.team?.name ?? null])).toEqual([
+      ["personal", null],
+      ["team:rates", "Rates"],
+      ["team:macro", null],
+    ]);
+  });
+
+  test("marker values round-trip", () => {
+    expect(groupIdFromMarkerValue(groupMarkerValue("team:rates"))).toBe("team:rates");
+    expect(groupIdFromMarkerValue(groupMarkerValue("personal"))).toBe("personal");
+    expect(groupIdFromMarkerValue("3")).toBeNull();
+    expect(groupIdFromMarkerValue("group:nope")).toBeNull();
+  });
+});

package/src/components/layout/status-bar-groups.ts

@@ -0,0 +1,85 @@
+import type { TeamSummary } from "../../api-client";
+import type { SavedLayout } from "../../types/config";
+import type { TeamStoreSnapshot } from "../../plugins/builtin/cloud/team/store";
+
+export type TabGroupId = "personal" | `team:${string}`;
+
+export interface StatusBarTabGroup {
+  id: TabGroupId;
+  team: TeamSummary | null;
+  /** Indexes into config.layouts, in tab order. */
+  indexes: number[];
+  collapsed: boolean;
+}
+
+export const GROUP_MARKER_PREFIX = "group:";
+
+export function groupIdFor(layout: Pick<SavedLayout, "origin">): TabGroupId {
+  return layout.origin ? `team:${layout.origin.teamId}` : "personal";
+}
+
+/**
+ * What FOCUS says about a group before any manual toggle: personal focus
+ * folds every team, a team focus folds everything but that team, all folds
+ * nothing.
+ */
+export function focusCollapses(focus: TeamStoreSnapshot["focus"], groupId: TabGroupId): boolean {
+  if (focus === "all") return false;
+  if (focus === "personal") return groupId !== "personal";
+  return groupId !== `team:${focus.teamId}`;
+}
+
+/**
+ * Splits the tab strip into a personal group and one per team, in team name
+ * order, keeping `Ctrl+1-9` positional because indexes are carried through.
+ * A group with the active tab is never collapsed: switching into it opens it.
+ */
+export function buildStatusBarTabGroups(
+  layouts: readonly Pick<SavedLayout, "origin">[],
+  activeIndex: number,
+  teams: readonly TeamSummary[],
+  focus: TeamStoreSnapshot["focus"],
+  manualToggles: ReadonlySet<string>,
+): StatusBarTabGroup[] {
+  const personal: number[] = [];
+  const byTeam = new Map<string, number[]>();
+  layouts.forEach((layout, index) => {
+    if (!layout.origin) {
+      personal.push(index);
+      return;
+    }
+    const list = byTeam.get(layout.origin.teamId) ?? [];
+    list.push(index);
+    byTeam.set(layout.origin.teamId, list);
+  });
+  const teamById = new Map(teams.map((team) => [team.id, team]));
+  const teamGroups = [...byTeam.entries()]
+    .map(([teamId, indexes]) => ({ teamId, team: teamById.get(teamId) ?? null, indexes }))
+    // Known teams by name; teams the store has not loaded yet go last.
+    .sort((a, b) => (
+      a.team && b.team
+        ? a.team.name.localeCompare(b.team.name)
+        : a.team ? -1 : b.team ? 1 : a.teamId.localeCompare(b.teamId)
+    ));
+
+  const groups: StatusBarTabGroup[] = [];
+  const push = (id: TabGroupId, team: TeamSummary | null, indexes: number[]) => {
+    if (indexes.length === 0) return;
+    const byFocus = focusCollapses(focus, id);
+    const collapsed = manualToggles.has(id) ? !byFocus : byFocus;
+    groups.push({ id, team, indexes, collapsed: collapsed && !indexes.includes(activeIndex) });
+  };
+  push("personal", null, personal);
+  for (const group of teamGroups) push(`team:${group.teamId}`, group.team, group.indexes);
+  return groups;
+}
+
+export function groupMarkerValue(groupId: TabGroupId): string {
+  return `${GROUP_MARKER_PREFIX}${groupId}`;
+}
+
+export function groupIdFromMarkerValue(value: string): TabGroupId | null {
+  if (!value.startsWith(GROUP_MARKER_PREFIX)) return null;
+  const id = value.slice(GROUP_MARKER_PREFIX.length);
+  return id === "personal" || id.startsWith("team:") ? (id as TabGroupId) : null;
+}

package/src/components/layout/status-bar.test.tsx

@@ -1,13 +1,13 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { act, useEffect, useState } from "react";
+import { getDockedPaneIds } from "../../plugins/pane-manager";
+import { setSharedRegistryForTests } from "../../plugins/registry";
 import { testRender } from "../../renderers/opentui/test-utils";
 import { AppContext, createInitialState } from "../../state/app/context";
 import { cloneLayout, createDefaultConfig, createPaneInstance, type LayoutConfig } from "../../types/config";
 import type { AppNotificationRequest } from "../../types/plugin";
-import { StatusBar } from "./status-bar";
 import { VERSION } from "../../version";
-import { getDockedPaneIds } from "../../plugins/pane-manager";
-import { setSharedRegistryForTests } from "../../plugins/registry";
-import { act, useEffect, useState } from "react";
+import { StatusBar } from "./status-bar";
 import { TransientLayoutProvider, useTransientLayout } from "./transient-layout";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
@@ -220,7 +220,7 @@ describe("StatusBar", () => {
       getTermSizeFn: () => ({ width: 120, height: 40 }),
       updateLayoutFn: (layout: LayoutConfig) => { updatedLayout = layout; },
       notify: (notification: AppNotificationRequest) => { notifications.push(notification); },
-      Slot: () => null,
+      renderSlot: () => null,
     } as any);
 
     testSetup = await testRender(
@@ -280,7 +280,7 @@ describe("StatusBar", () => {
       getTermSizeFn: () => ({ width: 120, height: 40 }),
       updateLayoutFn: (layout: LayoutConfig) => { updatedLayout = layout; },
       notify: (notification: AppNotificationRequest) => { notifications.push(notification); },
-      Slot: () => null,
+      renderSlot: () => null,
     } as any);
 
     testSetup = await testRender(