gloomberb 0.7.4 → 0.8.0

package/src/renderers/electrobun/view/desktop-window-bridge.ts

@@ -1,70 +0,0 @@
-import type { PaneRuntimeState } from "../../../core/state/app-state";
-import type {
-  DesktopDockPreviewState,
-  DesktopSharedStateSnapshot,
-  DesktopThemePreviewState,
-  DesktopWindowBridge,
-} from "../../../types/desktop-window";
-import { backendRequest, getElectrobunBackendInitSnapshot, onDesktopDockPreview, onDesktopState, onDesktopThemePreview } from "./backend-rpc";
-import { detachedSnapshotKey, prepareDetachedSnapshot } from "./desktop-window-snapshot";
-
-export function createDesktopWindowBridge(kind: "main" | "detached", paneId?: string): DesktopWindowBridge {
-  const initialDesktopSnapshot = getElectrobunBackendInitSnapshot()?.desktopSnapshot ?? null;
-  let lastDetachedSnapshotKey = kind === "detached" && paneId && initialDesktopSnapshot
-    ? detachedSnapshotKey(initialDesktopSnapshot, paneId)
-    : null;
-
-  return {
-    kind,
-    paneId,
-    syncMainState: kind === "main"
-      ? async (snapshot: DesktopSharedStateSnapshot) => {
-        await backendRequest("desktop.syncMainState", { snapshot });
-      }
-      : undefined,
-    syncThemePreview: kind === "main"
-      ? async (preview: DesktopThemePreviewState) => {
-        await backendRequest("desktop.setThemePreview", { preview });
-      }
-      : undefined,
-    replaceDetachedPaneState: kind === "detached"
-      ? async (targetPaneId: string, paneState: PaneRuntimeState) => {
-        await backendRequest("desktop.replaceDetachedPaneState", { paneId: targetPaneId, paneState });
-      }
-      : undefined,
-    popOutPane: async (targetPaneId: string) => {
-      await backendRequest("desktop.popOutPane", { paneId: targetPaneId });
-    },
-    dockDetachedPane: async (targetPaneId: string) => {
-      await backendRequest("desktop.dockDetachedPane", { paneId: targetPaneId });
-    },
-    closeDetachedPane: async (targetPaneId: string) => {
-      await backendRequest("desktop.closeDetachedPane", { paneId: targetPaneId });
-    },
-    focusDetachedPane: async (targetPaneId: string) => {
-      await backendRequest("desktop.focusDetachedPane", { paneId: targetPaneId });
-    },
-    subscribeState(listener: (snapshot: DesktopSharedStateSnapshot) => void) {
-      return onDesktopState((message) => {
-        if (kind === "detached" && paneId) {
-          const nextKey = detachedSnapshotKey(message.snapshot, paneId);
-          if (nextKey === lastDetachedSnapshotKey) return;
-          lastDetachedSnapshotKey = nextKey;
-          listener(prepareDetachedSnapshot(message.snapshot, paneId));
-          return;
-        }
-        listener(message.snapshot);
-      });
-    },
-    subscribeDockPreview(listener: (preview: DesktopDockPreviewState) => void) {
-      return onDesktopDockPreview((message) => {
-        listener(message.preview);
-      });
-    },
-    subscribeThemePreview(listener: (preview: DesktopThemePreviewState) => void) {
-      return onDesktopThemePreview((message) => {
-        listener(message.preview);
-      });
-    },
-  };
-}

package/src/renderers/electrobun/view/desktop-window-snapshot.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createDefaultConfig } from "../../../types/config";
-import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
-import { detachedSnapshotKey } from "./desktop-window-snapshot";
-
-function createSnapshot(): DesktopSharedStateSnapshot {
-  const config = createDefaultConfig("/tmp/gloomberb-test");
-  config.layout.detached = [{ instanceId: "ticker-detail:main", x: 20, y: 20, width: 640, height: 420 }];
-  return {
-    config,
-    paneState: {
-      "portfolio-list:main": { cursorSymbol: "AAPL", collectionId: "main" },
-      "ticker-detail:main": { activeTabId: "overview" },
-    },
-    focusedPaneId: "portfolio-list:main",
-    activePanel: "left",
-    statusBarVisible: true,
-  };
-}
-
-describe("detached desktop snapshots", () => {
-  test("ignores unrelated window state", () => {
-    const snapshot = createSnapshot();
-    const key = detachedSnapshotKey(snapshot, "ticker-detail:main");
-
-    expect(detachedSnapshotKey({
-      ...snapshot,
-      activePanel: "right",
-      focusedPaneId: "chat:main",
-      paneState: {
-        ...snapshot.paneState,
-        "chat:main": { draft: "unrelated" },
-      },
-    }, "ticker-detail:main")).toBe(key);
-  });
-
-  test("tracks the detached pane and its follow source", () => {
-    const snapshot = createSnapshot();
-    const key = detachedSnapshotKey(snapshot, "ticker-detail:main");
-
-    expect(detachedSnapshotKey({
-      ...snapshot,
-      paneState: {
-        ...snapshot.paneState,
-        "ticker-detail:main": { activeTabId: "financials" },
-      },
-    }, "ticker-detail:main")).not.toBe(key);
-
-    expect(detachedSnapshotKey({
-      ...snapshot,
-      paneState: {
-        ...snapshot.paneState,
-        "portfolio-list:main": { cursorSymbol: "MSFT", collectionId: "main" },
-      },
-    }, "ticker-detail:main")).not.toBe(key);
-  });
-});

package/src/renderers/electrobun/view/desktop-window-snapshot.ts

@@ -1,41 +0,0 @@
-import { findPaneInstance } from "../../../types/config";
-import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
-
-export function prepareDetachedSnapshot(
-  snapshot: DesktopSharedStateSnapshot,
-  paneId: string,
-): DesktopSharedStateSnapshot {
-  return snapshot.focusedPaneId === paneId ? snapshot : { ...snapshot, focusedPaneId: paneId };
-}
-
-function collectPaneStateIds(snapshot: DesktopSharedStateSnapshot, paneId: string): string[] {
-  const ids: string[] = [];
-  const seen = new Set<string>();
-  let currentPaneId: string | null = paneId;
-
-  while (currentPaneId && !seen.has(currentPaneId)) {
-    seen.add(currentPaneId);
-    ids.push(currentPaneId);
-
-    const instance = findPaneInstance(snapshot.config.layout, currentPaneId);
-    currentPaneId = instance?.binding?.kind === "follow" ? instance.binding.sourceInstanceId : null;
-  }
-
-  return ids;
-}
-
-export function detachedSnapshotKey(snapshot: DesktopSharedStateSnapshot, paneId: string): string {
-  const paneStateIds = collectPaneStateIds(snapshot, paneId);
-  return JSON.stringify({
-    theme: snapshot.config.theme,
-    baseCurrency: snapshot.config.baseCurrency,
-    portfolios: snapshot.config.portfolios,
-    watchlists: snapshot.config.watchlists,
-    brokerInstances: snapshot.config.brokerInstances,
-    pluginConfig: snapshot.config.pluginConfig,
-    disabledPlugins: snapshot.config.disabledPlugins,
-    chartPreferences: snapshot.config.chartPreferences,
-    instances: paneStateIds.map((id) => findPaneInstance(snapshot.config.layout, id) ?? null),
-    paneState: Object.fromEntries(paneStateIds.map((id) => [id, snapshot.paneState[id] ?? {}])),
-  });
-}

package/src/renderers/electrobun/view/native-stubs/chart-kitty-support.ts

@@ -1,9 +0,0 @@
-import type { NativeRendererHost } from "../../../../ui";
-
-export function getCachedKittySupport(_renderer: NativeRendererHost): boolean {
-  return false;
-}
-
-export function ensureKittySupport(_renderer: NativeRendererHost): Promise<boolean> {
-  return Promise.resolve(false);
-}

package/src/renderers/opentui/image-loader.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Jimp } from "jimp";
-import { resizeImageToBitmap, type JimpImageLike } from "./image-loader";
-
-describe("resizeImageToBitmap", () => {
-  test("preserves aspect ratio for contained images", () => {
-    const source = new Jimp({ width: 4, height: 2, color: 0xff0000ff }) as unknown as JimpImageLike;
-    const bitmap = resizeImageToBitmap(source, { width: 4, height: 4, objectFit: "contain" });
-
-    expect(bitmap.width).toBe(4);
-    expect(bitmap.height).toBe(4);
-    expect([...bitmap.pixels.slice(0, 4)]).toEqual([0, 0, 0, 0]);
-    expect([...bitmap.pixels.slice(4 * 4, 4 * 4 + 4)]).toEqual([255, 0, 0, 255]);
-  });
-
-  test("fills the target for covered images", () => {
-    const source = new Jimp({ width: 4, height: 2, color: 0xff0000ff }) as unknown as JimpImageLike;
-    const bitmap = resizeImageToBitmap(source, { width: 4, height: 4, objectFit: "cover" });
-
-    expect(bitmap.width).toBe(4);
-    expect(bitmap.height).toBe(4);
-    expect([...bitmap.pixels.slice(0, 4)]).toEqual([255, 0, 0, 255]);
-    expect([...bitmap.pixels.slice((bitmap.pixels.length - 4), bitmap.pixels.length)]).toEqual([255, 0, 0, 255]);
-  });
-});

package/src/renderers/opentui/image-loader.ts

@@ -1,105 +0,0 @@
-import { Jimp } from "jimp";
-import type { NativeChartBitmap } from "../../components/chart/native/chart-rasterizer";
-
-type ImageObjectFit = "contain" | "cover";
-
-export interface JimpImageLike {
-  bitmap: {
-    width: number;
-    height: number;
-    data: Uint8Array;
-  };
-  clone(): JimpImageLike;
-  contain(options: { w: number; h: number }): JimpImageLike;
-  cover(options: { w: number; h: number }): JimpImageLike;
-}
-
-interface ImageBitmapOptions {
-  width: number;
-  height: number;
-  objectFit: ImageObjectFit;
-}
-
-const MAX_REMOTE_IMAGE_BYTES = 12 * 1024 * 1024;
-const IMAGE_CACHE_LIMIT = 48;
-
-const sourceImageCache = new Map<string, Promise<JimpImageLike>>();
-const bitmapCache = new Map<string, Promise<NativeChartBitmap>>();
-
-function remember<K, V>(cache: Map<K, V>, key: K, value: V) {
-  cache.set(key, value);
-  while (cache.size > IMAGE_CACHE_LIMIT) {
-    const firstKey = cache.keys().next().value as K | undefined;
-    if (firstKey === undefined) break;
-    cache.delete(firstKey);
-  }
-}
-
-async function fetchImageBytes(src: string): Promise<Buffer> {
-  const response = await fetch(src, {
-    headers: {
-      "User-Agent": "Gloomberb/0.6 image renderer",
-    },
-  });
-  if (!response.ok) {
-    throw new Error(`Image request failed with HTTP ${response.status}`);
-  }
-
-  const data = await response.arrayBuffer();
-  if (data.byteLength > MAX_REMOTE_IMAGE_BYTES) {
-    throw new Error("Image is too large to render inline");
-  }
-
-  return Buffer.from(data);
-}
-
-function loadSourceImage(src: string): Promise<JimpImageLike> {
-  const cached = sourceImageCache.get(src);
-  if (cached) return cached;
-
-  const promise = fetchImageBytes(src)
-    .then((bytes) => Jimp.read(bytes) as Promise<JimpImageLike>)
-    .catch((error) => {
-      sourceImageCache.delete(src);
-      throw error;
-    });
-
-  remember(sourceImageCache, src, promise);
-  return promise;
-}
-
-export function resizeImageToBitmap(source: JimpImageLike, options: ImageBitmapOptions): NativeChartBitmap {
-  const width = Math.max(1, Math.round(options.width));
-  const height = Math.max(1, Math.round(options.height));
-  const image = source.clone();
-
-  if (options.objectFit === "cover") {
-    image.cover({ w: width, h: height });
-  } else {
-    image.contain({ w: width, h: height });
-  }
-
-  return {
-    width: image.bitmap.width,
-    height: image.bitmap.height,
-    pixels: new Uint8Array(image.bitmap.data),
-  };
-}
-
-export function loadOpenTuiImageBitmap(src: string, options: ImageBitmapOptions): Promise<NativeChartBitmap> {
-  const width = Math.max(1, Math.round(options.width));
-  const height = Math.max(1, Math.round(options.height));
-  const key = `${src}\n${options.objectFit}\n${width}x${height}`;
-  const cached = bitmapCache.get(key);
-  if (cached) return cached;
-
-  const promise = loadSourceImage(src)
-    .then((image) => resizeImageToBitmap(image, { width, height, objectFit: options.objectFit }))
-    .catch((error) => {
-      bitmapCache.delete(key);
-      throw error;
-    });
-
-  remember(bitmapCache, key, promise);
-  return promise;
-}

package/src/renderers/opentui/image-surface.tsx

@@ -1,266 +0,0 @@
-import { createElement, forwardRef, useCallback, useEffect, useMemo, useRef, useState, type ForwardedRef } from "react";
-import {
-  computeBitmapSize,
-  intersectCellRects,
-  type CellRect,
-  type NativeChartBitmap,
-} from "../../components/chart/native/chart-rasterizer";
-import { getCachedKittySupport, ensureKittySupport } from "../../components/chart/native/kitty-support";
-import { getNativeSurfaceManager } from "../../components/chart/native/surface-manager";
-import {
-  getRenderableCellRect,
-  resolveNativeSurfaceVisibleRect,
-  type NativeSurfaceRenderableNode,
-} from "../../components/chart/native/surface-visibility";
-import { useOptionalPaneInstanceId } from "../../state/app-context";
-import { useNativeRenderer, type BoxRenderable, type ImageSurfaceProps } from "../../ui";
-import { loadOpenTuiImageBitmap } from "./image-loader";
-
-interface NativeRenderableNode extends BoxRenderable, NativeSurfaceRenderableNode {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  parent: NativeRenderableNode | null;
-  onLifecyclePass: (() => void) | null;
-}
-
-interface SurfaceTarget {
-  rect: CellRect;
-  visibleRect: CellRect | null;
-  pixelWidth: number;
-  pixelHeight: number;
-  bitmapKey: string;
-}
-
-interface CellInsets {
-  top: number;
-  right: number;
-  bottom: number;
-  left: number;
-}
-
-let nextImageSurfaceId = 1;
-
-function assignRef(ref: ForwardedRef<unknown>, value: unknown) {
-  if (typeof ref === "function") {
-    ref(value);
-    return;
-  }
-  if (ref) {
-    (ref as { current: unknown }).current = value;
-  }
-}
-
-function readInset(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-
-function resolveInsets(props: Record<string, unknown>): CellInsets {
-  const border = props.border ? 1 : 0;
-  const padding = readInset(props.padding);
-  const paddingX = readInset(props.paddingX ?? padding);
-  const paddingY = readInset(props.paddingY ?? padding);
-  return {
-    top: border + readInset(props.paddingTop ?? paddingY),
-    right: border + readInset(props.paddingRight ?? paddingX),
-    bottom: border + readInset(props.paddingBottom ?? paddingY),
-    left: border + readInset(props.paddingLeft ?? paddingX),
-  };
-}
-
-function sameRect(left: CellRect | null, right: CellRect | null): boolean {
-  if (left === right) return true;
-  if (!left || !right) return false;
-  return left.x === right.x
-    && left.y === right.y
-    && left.width === right.width
-    && left.height === right.height;
-}
-
-function sameTarget(left: SurfaceTarget | null, right: SurfaceTarget | null): boolean {
-  if (left === right) return true;
-  if (!left || !right) return false;
-  return left.bitmapKey === right.bitmapKey
-    && left.pixelWidth === right.pixelWidth
-    && left.pixelHeight === right.pixelHeight
-    && sameRect(left.rect, right.rect)
-    && sameRect(left.visibleRect, right.visibleRect);
-}
-
-function insetRect(rect: CellRect, insets: CellInsets): CellRect | null {
-  const width = rect.width - insets.left - insets.right;
-  const height = rect.height - insets.top - insets.bottom;
-  if (width <= 0 || height <= 0) return null;
-  return {
-    x: rect.x + insets.left,
-    y: rect.y + insets.top,
-    width,
-    height,
-  };
-}
-
-export const OpenTuiImageSurface = forwardRef<unknown, ImageSurfaceProps>(function OpenTuiImageSurface(
-  { children, src, alt: _alt, objectFit = "contain", ...props },
-  forwardedRef,
-) {
-  const renderer = useNativeRenderer();
-  const paneId = useOptionalPaneInstanceId();
-  const nativeSurfaceManager = useMemo(() => getNativeSurfaceManager(renderer), [renderer]);
-  const surfaceId = useRef(`opentui-image:${nextImageSurfaceId++}`).current;
-  const renderableRef = useRef<NativeRenderableNode | null>(null);
-  const [kittySupport, setKittySupport] = useState<boolean | null>(() => getCachedKittySupport(renderer));
-  const [target, setTarget] = useState<SurfaceTarget | null>(null);
-  const [bitmapState, setBitmapState] = useState<{ key: string; bitmap: NativeChartBitmap } | null>(null);
-  const [loadFailed, setLoadFailed] = useState(false);
-  const imageSrc = typeof src === "string" ? src.trim() : "";
-  const resolvedObjectFit = objectFit === "cover" ? "cover" : "contain";
-  const insets = useMemo(() => resolveInsets(props), [
-    props.border,
-    props.padding,
-    props.paddingX,
-    props.paddingY,
-    props.paddingTop,
-    props.paddingRight,
-    props.paddingBottom,
-    props.paddingLeft,
-  ]);
-
-  const setRenderableRef = useCallback((node: unknown) => {
-    renderableRef.current = node as NativeRenderableNode | null;
-    assignRef(forwardedRef, node);
-  }, [forwardedRef]);
-
-  useEffect(() => {
-    let cancelled = false;
-    setKittySupport(getCachedKittySupport(renderer));
-    ensureKittySupport(renderer).then((supported) => {
-      if (!cancelled) setKittySupport(supported);
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [renderer]);
-
-  useEffect(() => {
-    setLoadFailed(false);
-    setBitmapState(null);
-  }, [imageSrc]);
-
-  useEffect(() => {
-    const renderable = renderableRef.current;
-    if (!renderable || !imageSrc || kittySupport !== true) {
-      setTarget(null);
-      return;
-    }
-
-    let mountTimer: Timer | null = null;
-    const previousLifecyclePass = renderable.onLifecyclePass;
-    const syncTarget = () => {
-      const outerRect = getRenderableCellRect(renderable);
-      const rect = insetRect(outerRect, insets);
-      if (!rect || !renderer.resolution || renderer.terminalWidth <= 0 || renderer.terminalHeight <= 0) {
-        setTarget((current) => (current === null ? current : null));
-        return;
-      }
-
-      const outerVisibleRect = resolveNativeSurfaceVisibleRect(renderable, renderer.terminalWidth, renderer.terminalHeight);
-      const visibleRect = outerVisibleRect ? intersectCellRects(rect, outerVisibleRect) : null;
-      const bitmapSize = computeBitmapSize(rect, renderer.resolution, renderer.terminalWidth, renderer.terminalHeight);
-      const bitmapKey = `${imageSrc}\n${resolvedObjectFit}\n${bitmapSize.pixelWidth}x${bitmapSize.pixelHeight}`;
-      const nextTarget: SurfaceTarget = {
-        rect,
-        visibleRect,
-        pixelWidth: bitmapSize.pixelWidth,
-        pixelHeight: bitmapSize.pixelHeight,
-        bitmapKey,
-      };
-      setTarget((current) => (sameTarget(current, nextTarget) ? current : nextTarget));
-    };
-    const lifecyclePass = () => {
-      previousLifecyclePass?.();
-      syncTarget();
-    };
-
-    renderable.onLifecyclePass = lifecyclePass;
-    renderer.registerLifecyclePass(renderable);
-    syncTarget();
-    mountTimer = setTimeout(() => {
-      syncTarget();
-      renderer.requestRender();
-    }, 0);
-
-    return () => {
-      if (mountTimer) clearTimeout(mountTimer);
-      if (renderable.onLifecyclePass === lifecyclePass) {
-        renderable.onLifecyclePass = previousLifecyclePass;
-      }
-      renderer.unregisterLifecyclePass(renderable);
-      setTarget(null);
-    };
-  }, [imageSrc, insets, kittySupport, renderer, resolvedObjectFit]);
-
-  useEffect(() => {
-    if (!target || !imageSrc || kittySupport !== true) {
-      setBitmapState(null);
-      return;
-    }
-
-    let cancelled = false;
-    setBitmapState((current) => (current?.key === target.bitmapKey ? current : null));
-    loadOpenTuiImageBitmap(imageSrc, {
-      width: target.pixelWidth,
-      height: target.pixelHeight,
-      objectFit: resolvedObjectFit,
-    }).then((bitmap) => {
-      if (!cancelled) {
-        setLoadFailed(false);
-        setBitmapState({ key: target.bitmapKey, bitmap });
-      }
-    }).catch(() => {
-      if (!cancelled) {
-        setLoadFailed(true);
-        setBitmapState(null);
-      }
-    });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [imageSrc, kittySupport, resolvedObjectFit, target]);
-
-  useEffect(() => {
-    return () => {
-      nativeSurfaceManager.removeSurface(surfaceId);
-    };
-  }, [nativeSurfaceManager, surfaceId]);
-
-  useEffect(() => {
-    if (kittySupport !== true
-      || loadFailed
-      || !target?.visibleRect
-      || !bitmapState
-      || bitmapState.key !== target.bitmapKey) {
-      nativeSurfaceManager.removeSurface(surfaceId);
-      return;
-    }
-
-    nativeSurfaceManager.upsertSurface({
-      id: surfaceId,
-      paneId: paneId ?? "__global__",
-      rect: target.rect,
-      visibleRect: target.visibleRect,
-      bitmap: bitmapState.bitmap,
-      bitmapKey: bitmapState.key,
-    });
-    renderer.requestRender();
-  }, [bitmapState, kittySupport, loadFailed, nativeSurfaceManager, paneId, renderer, surfaceId, target]);
-
-  const showFallback = kittySupport !== true
-    || loadFailed
-    || !target
-    || !bitmapState
-    || bitmapState.key !== target.bitmapKey;
-
-  return (createElement as any)("box", { ...props, ref: setRenderableRef }, showFallback ? children : null);
-});