gloomberb 0.5.1 → 0.6.1

package/src/state/config-save-scheduler.ts

@@ -0,0 +1,35 @@
+import { saveConfig } from "../data/config-store";
+import type { AppConfig } from "../types/config";
+import { debugLog } from "../utils/debug-log";
+import { measurePerfAsync } from "../utils/perf-marks";
+import {
+  CONFIG_SAVE_DEBOUNCE_MS,
+  createPersistScheduler,
+} from "./persist-scheduler";
+
+const log = debugLog.createLogger("persist");
+
+const configSaveScheduler = createPersistScheduler<AppConfig>({
+  delayMs: CONFIG_SAVE_DEBOUNCE_MS,
+  save: (config) => measurePerfAsync("persist.config.save", () => saveConfig(config)),
+  onError: (error) => {
+    log.warn("config.save.failed", { error: error instanceof Error ? error.message : String(error) });
+  },
+});
+
+export function scheduleConfigSave(config: AppConfig): void {
+  configSaveScheduler.schedule(config);
+}
+
+export function flushScheduledConfigSave(): Promise<void> {
+  return configSaveScheduler.flush();
+}
+
+export function cancelScheduledConfigSave(): void {
+  configSaveScheduler.cancel();
+}
+
+export async function saveConfigImmediately(config: AppConfig): Promise<void> {
+  cancelScheduledConfigSave();
+  await measurePerfAsync("persist.config.save", () => saveConfig(config));
+}

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/persist-scheduler.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import { createPersistScheduler } from "./persist-scheduler";
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("createPersistScheduler", () => {
+  test("coalesces scheduled saves and writes the latest value", async () => {
+    const saved: number[] = [];
+    const scheduler = createPersistScheduler<number>({
+      delayMs: 5,
+      save: (value) => saved.push(value),
+    });
+
+    scheduler.schedule(1);
+    scheduler.schedule(2);
+    scheduler.schedule(3);
+    await delay(15);
+
+    expect(saved).toEqual([3]);
+  });
+
+  test("flush saves immediately", async () => {
+    const saved: string[] = [];
+    const scheduler = createPersistScheduler<string>({
+      delayMs: 1000,
+      save: (value) => saved.push(value),
+    });
+
+    scheduler.schedule("pending");
+    await scheduler.flush();
+
+    expect(saved).toEqual(["pending"]);
+  });
+
+  test("cancel drops pending value", async () => {
+    const saved: string[] = [];
+    const scheduler = createPersistScheduler<string>({
+      delayMs: 5,
+      save: (value) => saved.push(value),
+    });
+
+    scheduler.schedule("pending");
+    scheduler.cancel();
+    await delay(15);
+
+    expect(saved).toEqual([]);
+  });
+
+  test("save errors are reported without escaping timer", async () => {
+    const errors: unknown[] = [];
+    const scheduler = createPersistScheduler<string>({
+      delayMs: 5,
+      save: () => {
+        throw new Error("boom");
+      },
+      onError: (error) => errors.push(error),
+    });
+
+    scheduler.schedule("pending");
+    await delay(15);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toBeInstanceOf(Error);
+  });
+});

package/src/state/persist-scheduler.ts

@@ -0,0 +1,69 @@
+export const CONFIG_SAVE_DEBOUNCE_MS = 500;
+export const SESSION_SAVE_DEBOUNCE_MS = 1000;
+export const PLUGIN_STATE_SAVE_DEBOUNCE_MS = 500;
+
+export interface PersistSchedulerOptions<T> {
+  delayMs: number;
+  save: (value: T) => Promise<void> | void;
+  onError?: (error: unknown) => void;
+}
+
+export interface PersistScheduler<T> {
+  schedule(value: T): void;
+  flush(): Promise<void>;
+  cancel(): void;
+}
+
+export function createPersistScheduler<T>({
+  delayMs,
+  save,
+  onError,
+}: PersistSchedulerOptions<T>): PersistScheduler<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let pendingValue: T | undefined;
+  let hasPendingValue = false;
+  let inFlight: Promise<void> = Promise.resolve();
+
+  const clearTimer = () => {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = null;
+  };
+
+  const runSave = async (value: T) => {
+    try {
+      await save(value);
+    } catch (error) {
+      onError?.(error);
+    }
+  };
+
+  const drain = async () => {
+    clearTimer();
+    if (!hasPendingValue) return inFlight;
+    const value = pendingValue as T;
+    pendingValue = undefined;
+    hasPendingValue = false;
+    inFlight = inFlight.then(() => runSave(value));
+    return inFlight;
+  };
+
+  return {
+    schedule(value: T): void {
+      pendingValue = value;
+      hasPendingValue = true;
+      clearTimer();
+      timer = setTimeout(() => {
+        void drain();
+      }, Math.max(0, delayMs));
+    },
+    flush(): Promise<void> {
+      return drain();
+    },
+    cancel(): void {
+      clearTimer();
+      pendingValue = undefined;
+      hasPendingValue = false;
+    },
+  };
+}

package/src/state/selectors-ui.ts

@@ -0,0 +1,55 @@
+import type { AppState } from "../core/state/app-state";
+import type { LayoutConfig, SavedLayout } from "../types/config";
+import type { ReleaseInfo, UpdateProgress } from "../updater";
+
+export function selectLayout(state: AppState): LayoutConfig {
+  return state.config.layout;
+}
+
+export function selectFocusedPaneId(state: AppState): string | null {
+  return state.focusedPaneId;
+}
+
+export function selectCommandBarOpen(state: AppState): boolean {
+  return state.commandBarOpen;
+}
+
+export function selectStatusBarVisible(state: AppState): boolean {
+  return state.statusBarVisible;
+}
+
+export function selectBaseCurrency(state: AppState): string {
+  return state.config.baseCurrency;
+}
+
+export function selectSavedLayouts(state: AppState): SavedLayout[] {
+  return state.config.layouts;
+}
+
+export function selectActiveLayoutIndex(state: AppState): number {
+  return state.config.activeLayoutIndex;
+}
+
+export function selectGridlockTipVisible(state: AppState): boolean {
+  return state.gridlockTipVisible;
+}
+
+export function selectGridlockTipSequence(state: AppState): number {
+  return state.gridlockTipSequence;
+}
+
+export function selectUpdateAvailable(state: AppState): ReleaseInfo | null {
+  return state.updateAvailable;
+}
+
+export function selectUpdateProgress(state: AppState): UpdateProgress | null {
+  return state.updateProgress;
+}
+
+export function selectUpdateCheckInProgress(state: AppState): boolean {
+  return state.updateCheckInProgress;
+}
+
+export function selectUpdateNotice(state: AppState): string | null {
+  return state.updateNotice;
+}

package/src/state/selectors.ts

@@ -1,63 +1,29 @@
 import type { AppState } from "./app-context";
-import { resolveCollectionForPane } from "./app-context";
 import type { TickerRecord } from "../types/ticker";
 
-/** Get tickers belonging to a specific portfolio */
-export function getPortfolioTickers(state: AppState, portfolioId: string): TickerRecord[] {
-  const result: TickerRecord[] = [];
-  for (const ticker of state.tickers.values()) {
-    if (ticker.metadata.portfolios.includes(portfolioId)) {
-      result.push(ticker);
-    }
-  }
-  return result.sort((a, b) => a.metadata.ticker.localeCompare(b.metadata.ticker));
-}
-
-/** Get tickers belonging to a specific watchlist */
-export function getWatchlistTickers(state: AppState, watchlistId: string): TickerRecord[] {
-  const result: TickerRecord[] = [];
-  for (const ticker of state.tickers.values()) {
-    if (ticker.metadata.watchlists.includes(watchlistId)) {
-      result.push(ticker);
-    }
-  }
-  return result.sort((a, b) => a.metadata.ticker.localeCompare(b.metadata.ticker));
+function getCollectionMembershipKey(state: AppState, collectionId: string | null): "portfolios" | "watchlists" | null {
+  if (!collectionId) return null;
+  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) return "portfolios";
+  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) return "watchlists";
+  return null;
 }
 
 export function getCollectionTickers(state: AppState, collectionId: string | null): TickerRecord[] {
-  if (!collectionId) return [];
-  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) {
-    return getPortfolioTickers(state, collectionId);
-  }
-  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) {
-    return getWatchlistTickers(state, collectionId);
-  }
-  return [];
+  const membershipKey = getCollectionMembershipKey(state, collectionId);
+  if (!collectionId || !membershipKey) return [];
+  return [...state.tickers.values()]
+    .filter((ticker) => ticker.metadata[membershipKey].includes(collectionId))
+    .sort((a, b) => a.metadata.ticker.localeCompare(b.metadata.ticker));
 }
 
 export function getCollectionTickerCount(state: AppState, collectionId: string | null): number {
-  if (!collectionId) return 0;
-
+  const membershipKey = getCollectionMembershipKey(state, collectionId);
+  if (!collectionId || !membershipKey) return 0;
   let count = 0;
-  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) {
-    for (const ticker of state.tickers.values()) {
-      if (ticker.metadata.portfolios.includes(collectionId)) {
-        count += 1;
-      }
-    }
-    return count;
-  }
-
-  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) {
-    for (const ticker of state.tickers.values()) {
-      if (ticker.metadata.watchlists.includes(collectionId)) {
-        count += 1;
-      }
-    }
-    return count;
+  for (const ticker of state.tickers.values()) {
+    if (ticker.metadata[membershipKey].includes(collectionId)) count += 1;
   }
-
-  return 0;
+  return count;
 }
 
 export function getCollectionName(state: AppState, collectionId: string | null): string {
@@ -68,25 +34,3 @@ export function getCollectionName(state: AppState, collectionId: string | null):
   if (watchlist) return watchlist.name;
   return collectionId;
 }
-
-export function getCollectionType(state: AppState, collectionId: string | null): "portfolio" | "watchlist" | null {
-  if (!collectionId) return null;
-  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) return "portfolio";
-  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) return "watchlist";
-  return null;
-}
-
-export function getPaneCollectionTickers(state: AppState, paneId: string): TickerRecord[] {
-  return getCollectionTickers(state, resolveCollectionForPane(state, paneId));
-}
-
-export function getAllCollections(state: AppState): Array<{ id: string; name: string; type: "portfolio" | "watchlist" }> {
-  const collections: Array<{ id: string; name: string; type: "portfolio" | "watchlist" }> = [];
-  for (const portfolio of state.config.portfolios) {
-    collections.push({ id: portfolio.id, name: portfolio.name, type: "portfolio" });
-  }
-  for (const watchlist of state.config.watchlists) {
-    collections.push({ id: watchlist.id, name: watchlist.name, type: "watchlist" });
-  }
-  return collections;
-}

package/src/state/session-persistence.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { createDefaultConfig, createPaneInstance } from "../types/config";
 import type { TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
-import { buildAppSessionSnapshot, reconcileAppSessionSnapshot } from "./session-persistence";
+import { buildAppSessionSnapshot, reconcileAppSessionSnapshot } from "../core/state/session-persistence";
 
 function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
   return {

package/src/state/ticker-refresh-queue.ts

@@ -1,14 +1,26 @@
+
+import { debugLog } from "../utils/debug-log";
+import { measurePerfAsync } from "../utils/perf-marks";
+
 export interface TickerRefreshTask {
   key: string;
   priority: number;
   run: () => Promise<void>;
 }
 
+interface QueuedTickerRefreshTask extends TickerRefreshTask {
+  enqueuedAt: number;
+}
+
+const TASK_WARN_MS = 500;
+const WAIT_WARN_MS = 1000;
+const refreshQueueLog = debugLog.createLogger("refresh-queue");
+
 export class TickerRefreshQueue {
   private active = 0;
   private paused = false;
   private readonly pendingKeys = new Set<string>();
-  private readonly queue: TickerRefreshTask[] = [];
+  private readonly queue: QueuedTickerRefreshTask[] = [];
 
   constructor(private readonly concurrency = 3) {}
 
@@ -20,8 +32,15 @@ export class TickerRefreshQueue {
   enqueue(task: TickerRefreshTask): void {
     if (this.pendingKeys.has(task.key)) return;
     this.pendingKeys.add(task.key);
-    this.queue.push(task);
+    this.queue.push({ ...task, enqueuedAt: Date.now() });
     this.queue.sort((a, b) => a.priority - b.priority);
+    refreshQueueLog.info("task queued", {
+      key: task.key,
+      priority: task.priority,
+      active: this.active,
+      pending: this.queue.length,
+      paused: this.paused,
+    });
     this.pump();
   }
 
@@ -30,7 +49,37 @@ export class TickerRefreshQueue {
     while (this.active < this.concurrency && this.queue.length > 0) {
       const next = this.queue.shift()!;
       this.active += 1;
-      void next.run().finally(() => {
+      const waitMs = Date.now() - next.enqueuedAt;
+      refreshQueueLog.info("task started", {
+        key: next.key,
+        priority: next.priority,
+        waitMs,
+        active: this.active,
+        pending: this.queue.length,
+      });
+      void measurePerfAsync(
+        `refresh-queue.${next.key}`,
+        next.run,
+        {
+          key: next.key,
+          priority: next.priority,
+          waitMs,
+        },
+      ).finally(() => {
+        const durationMs = Date.now() - next.enqueuedAt - waitMs;
+        const payload = {
+          key: next.key,
+          priority: next.priority,
+          waitMs,
+          durationMs,
+          active: this.active - 1,
+          pending: this.queue.length,
+        };
+        if (durationMs >= TASK_WARN_MS || waitMs >= WAIT_WARN_MS) {
+          refreshQueueLog.warn("task finished slowly", payload);
+        } else {
+          refreshQueueLog.info("task finished", payload);
+        }
         this.active -= 1;
         this.pendingKeys.delete(next.key);
         this.pump();