gloomberb 0.9.1 → 0.9.3

package/src/components/layout/transient-layout.tsx

@@ -0,0 +1,57 @@
+import { createContext, useCallback, useContext, useMemo, useState, type ReactNode } from "react";
+
+export interface TransientLayoutState {
+  id: "pane-focus";
+  label: string;
+  active: boolean;
+  onActivate?: () => void;
+  onDeactivate?: () => void;
+  onExit?: () => void;
+}
+
+interface TransientLayoutContextValue {
+  transientLayout: TransientLayoutState | null;
+  setTransientLayout: (layout: TransientLayoutState | null) => void;
+}
+
+const noop = () => {};
+
+const TransientLayoutContext = createContext<TransientLayoutContextValue>({
+  transientLayout: null,
+  setTransientLayout: noop,
+});
+
+function sameTransientLayout(
+  left: TransientLayoutState | null,
+  right: TransientLayoutState | null,
+): boolean {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  return left.id === right.id
+    && left.label === right.label
+    && left.active === right.active
+    && left.onActivate === right.onActivate
+    && left.onDeactivate === right.onDeactivate
+    && left.onExit === right.onExit;
+}
+
+export function TransientLayoutProvider({ children }: { children: ReactNode }) {
+  const [transientLayout, setTransientLayoutState] = useState<TransientLayoutState | null>(null);
+  const setTransientLayout = useCallback((layout: TransientLayoutState | null) => {
+    setTransientLayoutState((current) => (sameTransientLayout(current, layout) ? current : layout));
+  }, []);
+  const value = useMemo(() => ({
+    transientLayout,
+    setTransientLayout,
+  }), [setTransientLayout, transientLayout]);
+
+  return (
+    <TransientLayoutContext.Provider value={value}>
+      {children}
+    </TransientLayoutContext.Provider>
+  );
+}
+
+export function useTransientLayout(): TransientLayoutContextValue {
+  return useContext(TransientLayoutContext);
+}

package/src/components/layout/window-controls.tsx

@@ -1,8 +1,9 @@
 import { Box, useRendererHost } from "../../ui";
 import { useCallback } from "react";
+import { TITLEBAR_OVERLAY_HEIGHT_PX } from "./titlebar-overlay";
 
-const WINDOWS_CONTROL_WIDTH_PX = 30;
-const WINDOWS_CONTROL_TRAILING_PADDING_PX = 10;
+const WINDOWS_CONTROL_SIZE_PX = TITLEBAR_OVERLAY_HEIGHT_PX;
+export const WINDOWS_CONTROL_GROUP_WIDTH_PX = WINDOWS_CONTROL_SIZE_PX * 3;
 
 type WindowControlAction = "minimize" | "toggle-maximize" | "close";
 
@@ -44,7 +45,11 @@ function WindowControlIcon({ action }: { action: WindowControlAction }) {
   );
 }
 
-export function WindowControls() {
+interface WindowControlsProps {
+  windowKind?: "main" | "detached";
+}
+
+export function WindowControls({ windowKind = "main" }: WindowControlsProps) {
   const rendererHost = useRendererHost();
 
   const controlWindow = useCallback((action: WindowControlAction, event: { stopPropagation?: () => void; preventDefault?: () => void }) => {
@@ -57,11 +62,17 @@ export function WindowControls() {
       flexDirection="row"
       alignItems="stretch"
       flexShrink={0}
-      className="electrobun-webkit-app-region-no-drag"
+      width={`${WINDOWS_CONTROL_GROUP_WIDTH_PX}px`}
       data-gloom-role="window-controls"
+      data-window-kind={windowKind}
       aria-hidden={false}
       style={{
-        paddingRight: WINDOWS_CONTROL_TRAILING_PADDING_PX,
+        position: "fixed",
+        top: 0,
+        right: 0,
+        height: `${WINDOWS_CONTROL_SIZE_PX}px`,
+        zIndex: 1000,
+        backgroundColor: "inherit",
       }}
     >
       {WINDOWS_CONTROLS.map((control) => (
@@ -69,18 +80,16 @@ export function WindowControls() {
           key={control.action}
           alignItems="center"
           justifyContent="center"
+          flexShrink={0}
+          width={`${WINDOWS_CONTROL_SIZE_PX}px`}
+          height="100%"
           data-gloom-role="window-control"
           data-window-control-action={control.action}
           data-gloom-interactive="true"
           role="button"
           aria-label={control.label}
           title={control.label}
-          className="electrobun-webkit-app-region-no-drag"
           onMouseDown={(event: { stopPropagation?: () => void; preventDefault?: () => void }) => controlWindow(control.action, event)}
-          style={{
-            width: WINDOWS_CONTROL_WIDTH_PX,
-            height: "100%",
-          }}
         >
           <WindowControlIcon action={control.action} />
         </Box>

package/src/components/layout/window-edit/mode.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import type { LayoutConfig } from "../../../types/config";
-import { cycleWindowEditPane, getWindowEditPaneIds, type WindowEditState } from "./mode";
+import {
+  cycleWindowEditPane,
+  cycleWindowEditTarget,
+  getWindowEditPaneIds,
+  type WindowEditState,
+} from "./mode";
+import { resolveWindowEditDockMovePreview } from "./presentation";
 
 const bounds = { x: 0, y: 0, width: 120, height: 40 };
 
@@ -38,18 +44,83 @@ describe("window edit mode", () => {
       dirty: false,
     };
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("dock-b");
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("float-a");
     expect(state.previewLayout.floating.find((entry) => entry.instanceId === "float-a")?.zIndex)
       .toBeGreaterThan(state.previewLayout.floating.find((entry) => entry.instanceId === "float-b")?.zIndex ?? 0);
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("float-b");
 
-    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout), bounds, {}, 1);
+    state = cycleWindowEditPane(state, getWindowEditPaneIds(state.previewLayout, bounds, {}), bounds, {}, 1);
     expect(state.paneId).toBe("dock-a");
   });
+
+  test("cycles dock move targets without changing the selected window", () => {
+    const layout: LayoutConfig = {
+      dockRoot: {
+        kind: "split",
+        axis: "horizontal",
+        ratio: 0.5,
+        first: { kind: "pane", instanceId: "source" },
+        second: {
+          kind: "split",
+          axis: "vertical",
+          ratio: 0.5,
+          first: { kind: "pane", instanceId: "target-a" },
+          second: { kind: "pane", instanceId: "target-b" },
+        },
+      },
+      instances: [
+        pane("source"),
+        pane("target-a"),
+        pane("target-b"),
+      ],
+      floating: [],
+      detached: [],
+    };
+    const state: WindowEditState = {
+      paneId: "source",
+      previewLayout: layout,
+      mode: "move",
+      focus: { kind: "dock-move", targetId: "target-a", position: "right" },
+      dirty: false,
+    };
+
+    const next = cycleWindowEditTarget(state, bounds, { reserveDividerGutters: true }, 1);
+
+    expect(next.paneId).toBe("source");
+    expect(next.focus).toEqual({ kind: "dock-move", targetId: "target-b", position: "right" });
+  });
+
+  test("uses dock geometry options for dock move preview rectangles", () => {
+    const layout: LayoutConfig = {
+      dockRoot: {
+        kind: "split",
+        axis: "horizontal",
+        ratio: 0.5,
+        first: { kind: "pane", instanceId: "left" },
+        second: { kind: "pane", instanceId: "right" },
+      },
+      instances: [
+        pane("left"),
+        pane("right"),
+      ],
+      floating: [],
+      detached: [],
+    };
+    const state: WindowEditState = {
+      paneId: "left",
+      previewLayout: layout,
+      mode: "move",
+      focus: { kind: "dock-move", targetId: "right", position: "right" },
+      dirty: false,
+    };
+
+    expect(resolveWindowEditDockMovePreview(state, bounds, { reserveDividerGutters: true })?.rect)
+      .toEqual({ x: 61, y: 0, width: 59, height: 40 });
+  });
 });

package/src/components/layout/window-edit/mode.ts

@@ -226,12 +226,57 @@ export function cycleWindowEditFocus(
   return targets[(currentIndex + delta + targets.length) % targets.length] ?? targets[0]!;
 }
 
-export function getWindowEditPaneIds(layout: LayoutConfig): string[] {
-  const dockedIds = getDockLeafLayouts(layout, { x: 0, y: 0, width: 120, height: 40 }).map((entry) => entry.instanceId);
+function getWindowEditDockPaneIds(
+  layout: LayoutConfig,
+  bounds: LayoutBounds,
+  dockGeometryOptions: DockGeometryOptions,
+): string[] {
+  return getDockLeafLayouts(layout, bounds, dockGeometryOptions).map((entry) => entry.instanceId);
+}
+
+export function getWindowEditPaneIds(
+  layout: LayoutConfig,
+  bounds: LayoutBounds,
+  dockGeometryOptions: DockGeometryOptions,
+): string[] {
+  const dockedIds = getWindowEditDockPaneIds(layout, bounds, dockGeometryOptions);
   const floatingIds = layout.floating.map((entry) => entry.instanceId);
   return [...dockedIds, ...floatingIds];
 }
 
+export function cycleWindowEditTarget(
+  state: WindowEditState,
+  bounds: LayoutBounds,
+  dockGeometryOptions: DockGeometryOptions,
+  delta: 1 | -1,
+): WindowEditState {
+  if (state.mode !== "move" || state.focus.kind !== "dock-move") {
+    return state;
+  }
+
+  const targetIds = getWindowEditDockPaneIds(state.previewLayout, bounds, dockGeometryOptions)
+    .filter((paneId) => paneId !== state.paneId);
+  if (targetIds.length === 0) {
+    return {
+      ...state,
+      focus: normalizeWindowEditFocus({ kind: "move" }, state.previewLayout, state.paneId, state.mode, bounds, dockGeometryOptions),
+    };
+  }
+
+  const currentIndex = targetIds.indexOf(state.focus.targetId);
+  const startIndex = currentIndex >= 0
+    ? currentIndex
+    : delta === 1
+      ? -1
+      : 0;
+  const targetId = targetIds[(startIndex + delta + targetIds.length) % targetIds.length] ?? targetIds[0]!;
+  return {
+    ...state,
+    focus: normalizeWindowEditFocus({ ...state.focus, targetId }, state.previewLayout, state.paneId, state.mode, bounds, dockGeometryOptions),
+    notice: undefined,
+  };
+}
+
 export function raiseWindowEditPane(layout: LayoutConfig, paneId: string): LayoutConfig {
   const floating = layout.floating.find((entry) => entry.instanceId === paneId);
   if (!floating) return layout;

package/src/components/layout/window-edit/presentation.ts

@@ -73,7 +73,7 @@ export function windowEditStatusLine(
 export function windowEditHelpText(state: WindowEditState): string {
   if (state.mode === "move") {
     if (state.focus.kind === "dock-move") {
-      return "arrows/hjkl choose side  m retarget  Tab/w window  d float  r resize  Enter commit/exit  Esc exit/cancel";
+      return "arrows/hjkl choose side  Tab/w target  m window  d float  r resize  Enter commit/exit  Esc exit/cancel";
     }
     return "Tab/w window  d dock/float  r resize  arrows/hjkl target/move  Shift fast  Enter commit/exit  Esc exit/cancel";
   }
@@ -100,6 +100,7 @@ export function resolveWindowEditDockMovePreview(
     state.paneId,
     leafDropTarget(focus.targetId, focus.position),
     bounds,
+    dockGeometryOptions,
   );
   if (!simulation.previewRect) return null;
   return {

package/src/components/price-performance.tsx

@@ -0,0 +1,183 @@
+import { Box, ScrollBox, Text } from "../ui";
+import { blendHex, colors, priceColor } from "../theme/colors";
+import { displayWidth, formatPercent, padTo } from "../utils/format";
+import type { PriceReturnField } from "../market-data/performance";
+
+type MouseInteractionEvent = {
+  stopPropagation?: () => void;
+  preventDefault?: () => void;
+};
+
+const STRIP_COLUMN_GAP = 1;
+const RETURN_CELL_MIN_WIDTH = 7;
+const SYMBOL_COLUMN_MIN_WIDTH = 6;
+const SYMBOL_COLUMN_MAX_WIDTH = 12;
+
+export interface PriceReturnTableRow {
+  symbol: string;
+  color: string;
+  fields: PriceReturnField[];
+  selected: boolean;
+}
+
+function formatReturnValue(value: number | null): string {
+  return value == null ? "-" : formatPercent(value);
+}
+
+function returnValueColor(value: number | null): string {
+  return value == null ? colors.textMuted : priceColor(value);
+}
+
+function hasAnyReturn(fields: readonly PriceReturnField[]): boolean {
+  return fields.some((field) => field.value != null);
+}
+
+function chunkFields<T>(fields: readonly T[], size: number): T[][] {
+  const rows: T[][] = [];
+  for (let index = 0; index < fields.length; index += size) {
+    rows.push(fields.slice(index, index + size));
+  }
+  return rows;
+}
+
+export function PriceReturnStrip({
+  fields,
+  width,
+}: {
+  fields: PriceReturnField[];
+  width: number;
+}) {
+  if (!hasAnyReturn(fields)) return null;
+
+  const columnCount = width >= 72
+    ? Math.min(6, fields.length)
+    : width >= 54
+      ? Math.min(4, fields.length)
+      : width >= 36
+        ? Math.min(3, fields.length)
+        : Math.min(2, fields.length);
+  const availableWidth = Math.max(width - STRIP_COLUMN_GAP * Math.max(columnCount - 1, 0), columnCount);
+  const cellWidth = Math.max(RETURN_CELL_MIN_WIDTH, Math.floor(availableWidth / columnCount));
+  const rows = chunkFields(fields, columnCount);
+
+  return (
+    <Box flexDirection="column" width={width}>
+      {rows.map((row, rowIndex) => (
+        <Box key={rowIndex} flexDirection="row" height={1}>
+          {row.map((field, columnIndex) => {
+            const labelWidth = Math.min(3, Math.max(2, displayWidth(field.label)));
+            const valueWidth = Math.max(1, cellWidth - labelWidth);
+            return (
+              <Box key={field.id} flexDirection="row">
+                {columnIndex > 0 && <Box width={STRIP_COLUMN_GAP} />}
+                <Box flexDirection="row" width={cellWidth}>
+                  <Text fg={colors.textDim}>{padTo(field.label, labelWidth)}</Text>
+                  <Box width={valueWidth} overflow="hidden">
+                    <Text fg={returnValueColor(field.value)}>{padTo(formatReturnValue(field.value), valueWidth, "right")}</Text>
+                  </Box>
+                </Box>
+              </Box>
+            );
+          })}
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+function getFieldById(fields: readonly PriceReturnField[], id: string): PriceReturnField | null {
+  return fields.find((field) => field.id === id) ?? null;
+}
+
+function chooseComparisonFieldIds(width: number, availableIds: readonly string[]): string[] {
+  const preferred = width >= 86
+    ? ["RNG", "1M", "3M", "6M", "1Y", "3Y", "5Y"]
+    : width >= 72
+      ? ["RNG", "1M", "3M", "1Y", "3Y", "5Y"]
+      : width >= 58
+        ? ["RNG", "1M", "1Y", "3Y", "5Y"]
+        : width >= 44
+          ? ["RNG", "1M", "1Y", "5Y"]
+          : ["1Y", "5Y"];
+  const available = new Set(availableIds);
+  return preferred.filter((id) => available.has(id));
+}
+
+export function PriceReturnTable({
+  height,
+  onFocusInteraction,
+  onOpenSymbol,
+  onSelectSymbol,
+  rows,
+  width,
+}: {
+  height: number;
+  onFocusInteraction?: (event: MouseInteractionEvent | null | undefined) => void;
+  onOpenSymbol: (symbol: string) => void;
+  onSelectSymbol: (symbol: string) => void;
+  rows: PriceReturnTableRow[];
+  width: number;
+}) {
+  if (height <= 0 || rows.length === 0) return null;
+
+  const availableIds = rows[0]?.fields.map((field) => field.id) ?? [];
+  const fieldIds = chooseComparisonFieldIds(width, availableIds);
+  if (fieldIds.length === 0) return null;
+
+  const valueWidth = Math.max(
+    RETURN_CELL_MIN_WIDTH,
+    Math.floor((width - SYMBOL_COLUMN_MIN_WIDTH - fieldIds.length) / Math.max(fieldIds.length, 1)),
+  );
+  const symbolWidth = Math.min(
+    SYMBOL_COLUMN_MAX_WIDTH,
+    Math.max(SYMBOL_COLUMN_MIN_WIDTH, width - fieldIds.length * (valueWidth + 1)),
+  );
+  const fieldsById = rows[0]?.fields ?? [];
+
+  return (
+    <ScrollBox height={height} scrollY>
+      <Box flexDirection="column" width={width}>
+        <Box flexDirection="row" height={1}>
+          <Text fg={colors.textDim}>{padTo("Sym", symbolWidth)}</Text>
+          {fieldIds.map((fieldId) => {
+            const field = getFieldById(fieldsById, fieldId);
+            return (
+              <Box key={fieldId} flexDirection="row">
+                <Text fg={colors.textDim}>{" "}</Text>
+                <Text fg={colors.textDim}>{padTo(field?.label ?? fieldId, valueWidth, "right")}</Text>
+              </Box>
+            );
+          })}
+        </Box>
+
+        {rows.map((row) => (
+          <Box
+            key={row.symbol}
+            flexDirection="row"
+            height={1}
+            width={width}
+            backgroundColor={row.selected ? blendHex(colors.panel, colors.borderFocused, 0.18) : colors.panel}
+            onMouseMove={() => onSelectSymbol(row.symbol)}
+            onMouseDown={(event: any) => {
+              onFocusInteraction?.(event);
+              onSelectSymbol(row.symbol);
+              onOpenSymbol(row.symbol);
+            }}
+          >
+            <Text fg={row.color}>{padTo(`${row.selected ? ">" : " "} ${row.symbol}`, symbolWidth)}</Text>
+            {fieldIds.map((fieldId) => {
+              const field = getFieldById(row.fields, fieldId);
+              const value = field?.value ?? null;
+              return (
+                <Box key={fieldId} flexDirection="row">
+                  <Text fg={colors.textDim}>{" "}</Text>
+                  <Text fg={returnValueColor(value)}>{padTo(formatReturnValue(value), valueWidth, "right")}</Text>
+                </Box>
+              );
+            })}
+          </Box>
+        ))}
+      </Box>
+    </ScrollBox>
+  );
+}

package/src/core/app-services.ts

@@ -12,7 +12,7 @@ import { assetDataProvider, newsProvider } from "../capabilities";
 import type { AppConfig } from "../types/config";
 import type { DataProvider } from "../types/data-provider";
 import { debugLog } from "../utils/debug-log";
-import { measurePerf } from "../utils/perf-marks";
+import { measurePerf, measurePerfAsync } from "../utils/perf-marks";
 import { setIbkrPortfolioPerformanceResourceStore } from "../plugins/ibkr/portfolio-performance";
 
 const servicesLog = debugLog.createLogger("services");
@@ -25,6 +25,7 @@ export interface AppServices {
   marketData: MarketDataCoordinator;
   pluginRegistry: PluginRegistry;
   newsService: NewsService;
+  ready: Promise<void>;
   destroy(): void;
 }
 
@@ -68,10 +69,11 @@ export function createAppServices({
   setSharedMarketDataCoordinator(marketData);
 
   const plugins = getLoadablePlugins(externalPlugins);
+  const pluginReadyPromises: Promise<void>[] = [];
   for (const plugin of plugins) {
-    measurePerf("startup.services.register-plugin", () => {
-      void pluginRegistry.register(plugin);
-    }, { pluginId: plugin.id });
+    pluginReadyPromises.push(measurePerfAsync("startup.services.register-plugin", () => (
+      pluginRegistry.register(plugin)
+    ), { pluginId: plugin.id }));
   }
   measurePerf("startup.services.news-start", () => {
     newsService.start();
@@ -86,6 +88,7 @@ export function createAppServices({
     marketData,
     pluginRegistry,
     newsService,
+    ready: Promise.all(pluginReadyPromises).then(() => {}),
     destroy() {
       setSharedMarketDataCoordinator(null);
       setSharedNewsService(null);

package/src/data/config/store/index.ts

@@ -21,8 +21,7 @@ export function setConfigStoreHost(host: ConfigStoreHost | null): void {
 
 async function loadNodeHost(): Promise<ConfigStoreHost> {
   if (!nodeHostPromise) {
-    const modulePath = "./node";
-    nodeHostPromise = import(modulePath) as Promise<ConfigStoreHost>;
+    nodeHostPromise = import("./node") as Promise<ConfigStoreHost>;
   }
   return nodeHostPromise;
 }

package/src/market-data/performance.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+import {
+  appendQuoteToPriceReturnHistory,
+  buildPriceReturnFields,
+  computePriceReturnForHorizon,
+  PRICE_RETURN_HORIZONS,
+} from "./performance";
+import type { PricePoint } from "../types/financials";
+
+function point(date: string, close: number): PricePoint {
+  return { date: new Date(`${date}T00:00:00Z`), close };
+}
+
+describe("price performance", () => {
+  test("computes horizon return from the closest prior baseline", () => {
+    const history = [
+      point("2025-12-31", 100),
+      point("2026-01-02", 102),
+      point("2026-01-31", 110),
+      point("2026-02-01", 120),
+    ];
+
+    const oneMonth = PRICE_RETURN_HORIZONS.find((horizon) => horizon.id === "1M")!;
+
+    expect(computePriceReturnForHorizon(history, oneMonth)).toBeCloseTo(20 / 100);
+  });
+
+  test("leaves fixed horizons empty when history does not reach the baseline date", () => {
+    const history = [
+      point("2026-01-15", 100),
+      point("2026-02-01", 110),
+    ];
+
+    const fields = buildPriceReturnFields(history);
+
+    expect(fields.find((field) => field.id === "1M")?.value).toBeNull();
+    expect(fields.find((field) => field.id === "1Y")?.value).toBeNull();
+  });
+
+  test("can include a newer live quote as the latest return point", () => {
+    const history = [
+      point("2025-01-31", 100),
+      point("2026-01-31", 120),
+    ];
+    const withQuote = appendQuoteToPriceReturnHistory(history, {
+      price: 150,
+      lastUpdated: Date.parse("2026-02-01T15:30:00Z"),
+    });
+    const oneYear = PRICE_RETURN_HORIZONS.find((horizon) => horizon.id === "1Y")!;
+
+    expect(withQuote).toHaveLength(3);
+    expect(computePriceReturnForHorizon(withQuote, oneYear)).toBeCloseTo(50 / 100);
+  });
+});