gloomberb 0.6.0 → 0.7.0

package/src/components/chart/comparison-stock-chart.tsx

@@ -54,12 +54,10 @@ import {
   normalizeChartResolutionSupport,
   sortChartResolutions,
   type ChartResolutionSupport,
-  type ManualChartResolution,
 } from "./chart-resolution";
 import { RIGHT_EDGE_ANCHOR_RATIO, resolveAnchoredChartZoom } from "./chart-viewport";
 import {
   buildComparisonChartScene,
-  formatComparisonAxisValue,
   formatComparisonCursorAxisValue,
   renderComparisonChart,
 } from "./comparison-chart-renderer";
@@ -82,7 +80,6 @@ import {
 } from "./chart-types";
 import {
   computeBitmapSize,
-  intersectCellRects,
   renderNativeComparisonChartBase,
   renderNativeCrosshairOverlay,
   type CellRect,
@@ -93,7 +90,13 @@ import { ensureKittySupport, getCachedKittySupport } from "./native/kitty-suppor
 import { resolveChartRendererState } from "./native/renderer-selection";
 import { getNativeSurfaceManager } from "./native/surface-manager";
 import { syncCachedNativeSurface } from "./native/surface-sync";
+import {
+  getRenderableCellRect,
+  resolveNativeSurfaceVisibleRect,
+  type NativeSurfaceRenderableNode,
+} from "./native/surface-visibility";
 import { formatAxisCell, formatDateShort, resolveChartAxisWidth, type StyledContent } from "./chart-renderer";
+import { TimeAxisLabel } from "./time-axis-label";
 
 const MODE_CHIPS: Record<ComparisonChartRenderMode, string> = {
   area: "A",
@@ -108,6 +111,7 @@ interface ComparisonStockChartProps {
   symbols: string[];
   axisMode: ChartAxisMode;
   onOpenSymbol: (symbol: string) => void;
+  onEditTickers?: () => void;
 }
 
 interface ComparisonChartSymbolSource {
@@ -169,14 +173,6 @@ interface DisplayCursorState {
   pixelY: number | null;
 }
 
-interface RenderableNode {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  parent: RenderableNode | null;
-}
-
 const EMPTY_DISPLAY_CURSOR: DisplayCursorState = {
   cellX: null,
   cellY: null,
@@ -384,41 +380,6 @@ function resolveCursorMotionKind(
     : "cell";
 }
 
-function extractCellRect(renderable: RenderableNode): CellRect {
-  return {
-    x: renderable.x,
-    y: renderable.y,
-    width: renderable.width,
-    height: renderable.height,
-  };
-}
-
-function resolveVisibleRect(
-  renderable: RenderableNode | null,
-  terminalWidth: number,
-  terminalHeight: number,
-): CellRect | null {
-  if (!renderable) return null;
-
-  let visible: CellRect = {
-    x: 0,
-    y: 0,
-    width: terminalWidth,
-    height: terminalHeight,
-  };
-  let current: RenderableNode | null = renderable;
-
-  while (current) {
-    const currentRect = extractCellRect(current);
-    const nextVisible = intersectCellRects(visible, currentRect);
-    if (!nextVisible) return null;
-    visible = nextVisible;
-    current = current.parent;
-  }
-
-  return visible;
-}
-
 function buildBlankPlotLines(width: number, height: number): string[] {
   return Array.from({ length: height }, () => " ".repeat(width));
 }
@@ -553,6 +514,7 @@ function ComparisonStockChartView({
   preferredRenderer,
   symbolSources,
   onOpenSymbol,
+  onEditTickers,
 }: ComparisonStockChartViewProps) {
   const renderer = useNativeRenderer();
   const { canvasCharts, cellWidthPx = 8, cellHeightPx = 18, pixelRatio = 1 } = useUiCapabilities();
@@ -587,6 +549,7 @@ function ComparisonStockChartView({
   const lastCanvasBaseBitmapRef = useRef<{ key: string; bitmap: NativeChartBitmap } | null>(null);
   const displayCursorRef = useRef<DisplayCursorState>(EMPTY_DISPLAY_CURSOR);
   const targetCursorRef = useRef<DisplayCursorState>(EMPTY_DISPLAY_CURSOR);
+  const mouseCrosshairDisabledRef = useRef(false);
   const cursorMotionKindRef = useRef<ChartCursorMotionKind>("discrete");
   const animationFrameRef = useRef<number | null>(null);
   const pendingCanonicalResetRef = useRef(1);
@@ -947,11 +910,10 @@ function ComparisonStockChartView({
       }
       return {
         ...current,
-        panOffset: clamp(pendingExpansion.targetPanOffset, 0, getMaxComparisonPanOffset(series, current.presetRange, current.zoomLevel, chartWidth)),
+        panOffset: clamp(pendingExpansion.targetPanOffset, 0, getMaxComparisonPanOffset(series, current.zoomLevel)),
       };
     });
   }, [
-    chartWidth,
     series,
     seriesDates,
     viewState.activePreset,
@@ -1021,8 +983,8 @@ function ComparisonStockChartView({
   }), [viewState.panOffset, viewState.renderMode, viewState.zoomLevel]);
 
   const visibleWindow = useMemo(() => (
-    getVisibleComparisonWindow(series, projectionViewState, chartWidth)
-  ), [chartWidth, projectionViewState, series]);
+    getVisibleComparisonWindow(series, projectionViewState)
+  ), [projectionViewState, series]);
 
   const projection = useMemo(() => (
     projectComparisonChartData(series, chartWidth, projectionViewState, axisMode)
@@ -1076,6 +1038,14 @@ function ComparisonStockChartView({
     selectedSymbol: viewState.selectedSymbol,
     colors: chartColors,
   }), [chartColors, chartHeight, chartWidth, projection, viewState.selectedSymbol]);
+  const displayScene = useMemo(() => buildComparisonChartScene(projection, {
+    width: chartWidth,
+    height: chartHeight,
+    cursorX: displayCursorX,
+    cursorY: displayCursorY,
+    selectedSymbol: viewState.selectedSymbol,
+    colors: chartColors,
+  }), [chartColors, chartHeight, chartWidth, displayCursorX, displayCursorY, projection, viewState.selectedSymbol]);
 
   const staticResult = useMemo(() => renderComparisonChart(projection, {
     width: chartWidth,
@@ -1127,6 +1097,12 @@ function ComparisonStockChartView({
     };
 
     return [
+      ...(onEditTickers ? [{
+        id: "tickers",
+        key: "t",
+        label: "ickers",
+        onPress: onEditTickers,
+      }] : []),
       {
         id: "mode",
         key: "m",
@@ -1150,26 +1126,13 @@ function ComparisonStockChartView({
       { id: "reset", key: "0", label: "reset", onPress: resetView },
       ...(width >= 72 ? [{ id: "range", key: "1-7", label: "range", onPress: cycleRange }] : []),
     ];
-  }, [effectiveResolution, resolutionChips, series, supportMap, viewState.presetRange, visibleDateWindow, width]);
+  }, [effectiveResolution, onEditTickers, resolutionChips, series, supportMap, viewState.presetRange, visibleDateWindow, width]);
 
   usePaneFooter("comparison-chart", () => ({
     order: 10,
     hints: footerHints,
   }), [footerHints]);
 
-  const liveScene = useMemo(() => (
-    effectiveRenderer === "kitty"
-      ? staticScene
-      : buildComparisonChartScene(projection, {
-        width: chartWidth,
-        height: chartHeight,
-        cursorX: displayCursorX,
-        cursorY: displayCursorY,
-        selectedSymbol: viewState.selectedSymbol,
-        colors: chartColors,
-      })
-  ), [chartColors, chartHeight, chartWidth, displayCursorX, displayCursorY, effectiveRenderer, projection, staticScene, viewState.selectedSymbol]);
-
   const nativeCrosshair = useMemo<NativeCrosshairOverlay | null>(() => {
     if (displayCursor.cellX === null || displayCursor.cellY === null) return null;
     return {
@@ -1201,8 +1164,9 @@ function ComparisonStockChartView({
 
     const syncPlacement = () => {
       if (effectiveRenderer !== "kitty" || !rendererState.nativeReady || !plotRef.current) return;
-      const rect = extractCellRect(plotRef.current);
-      const visibleRect = resolveVisibleRect(plotRef.current, renderer.terminalWidth, renderer.terminalHeight);
+      const plot = plotRef.current as NativeSurfaceRenderableNode;
+      const rect = getRenderableCellRect(plot);
+      const visibleRect = resolveNativeSurfaceVisibleRect(plot, renderer.terminalWidth, renderer.terminalHeight);
       const previous = lastNativeGeometryRef.current;
       if (previous
         && previous.rect.x === rect.x
@@ -1257,8 +1221,9 @@ function ComparisonStockChartView({
       return;
     }
 
-    const plotRect = extractCellRect(plotRef.current);
-    const visibleRect = resolveVisibleRect(plotRef.current, renderer.terminalWidth, renderer.terminalHeight);
+    const plot = plotRef.current as NativeSurfaceRenderableNode;
+    const plotRect = getRenderableCellRect(plot);
+    const visibleRect = resolveNativeSurfaceVisibleRect(plot, renderer.terminalWidth, renderer.terminalHeight);
     const bitmapSize = computeBitmapSize(plotRect, renderer.resolution, renderer.terminalWidth, renderer.terminalHeight);
     const bitmapKey = buildComparisonNativeBitmapKey(
       symbols.length,
@@ -1314,8 +1279,9 @@ function ComparisonStockChartView({
       return;
     }
 
-    const plotRect = extractCellRect(plotRef.current);
-    const visibleRect = resolveVisibleRect(plotRef.current, renderer.terminalWidth, renderer.terminalHeight);
+    const plot = plotRef.current as NativeSurfaceRenderableNode;
+    const plotRect = getRenderableCellRect(plot);
+    const visibleRect = resolveNativeSurfaceVisibleRect(plot, renderer.terminalWidth, renderer.terminalHeight);
     const bitmapSize = computeBitmapSize(plotRect, renderer.resolution, renderer.terminalWidth, renderer.terminalHeight);
     const renderablePixelSize = getRenderablePixelSize(plotRef.current, renderer);
     const overlayPixelX = scaleLocalPixelCoordinate(
@@ -1421,7 +1387,7 @@ function ComparisonStockChartView({
         return;
       case "a": {
         const panStep = getKeyboardPanCellCount(chartWidth);
-        if (viewState.panOffset >= getMaxComparisonPanOffset(series, viewState.presetRange, viewState.zoomLevel, chartWidth) && expandBufferRange({
+        if (viewState.panOffset >= getMaxComparisonPanOffset(series, viewState.zoomLevel) && expandBufferRange({
           kind: "pan-left",
           targetPanOffset: viewState.panOffset + panStep,
         })) {
@@ -1429,7 +1395,7 @@ function ComparisonStockChartView({
         }
         setViewState((current) => ({
           ...clearActivePreset(current),
-          panOffset: clamp(current.panOffset + panStep, 0, getMaxComparisonPanOffset(series, current.presetRange, current.zoomLevel, chartWidth)),
+          panOffset: clamp(current.panOffset + panStep, 0, getMaxComparisonPanOffset(series, current.zoomLevel)),
         }));
         return;
       }
@@ -1437,7 +1403,7 @@ function ComparisonStockChartView({
         const panStep = getKeyboardPanCellCount(chartWidth);
         setViewState((current) => ({
           ...clearActivePreset(current),
-          panOffset: clamp(current.panOffset - panStep, 0, getMaxComparisonPanOffset(series, current.presetRange, current.zoomLevel, chartWidth)),
+          panOffset: clamp(current.panOffset - panStep, 0, getMaxComparisonPanOffset(series, current.zoomLevel)),
         }));
         return;
       }
@@ -1453,7 +1419,11 @@ function ComparisonStockChartView({
         setResolution(nextResolution);
         return;
       }
+      case "t":
+        onEditTickers?.();
+        return;
       case "h":
+        mouseCrosshairDisabledRef.current = false;
         cursorMotionKindRef.current = "discrete";
         setViewState((current) => ({
           ...current,
@@ -1461,6 +1431,7 @@ function ComparisonStockChartView({
         }));
         return;
       case "l":
+        mouseCrosshairDisabledRef.current = false;
         cursorMotionKindRef.current = "discrete";
         setViewState((current) => ({
           ...current,
@@ -1468,6 +1439,7 @@ function ComparisonStockChartView({
         }));
         return;
       case "escape":
+        mouseCrosshairDisabledRef.current = true;
         updateDisplayCursorTarget(EMPTY_DISPLAY_CURSOR, "discrete");
         setViewState((current) => ({ ...current, cursorX: null, cursorY: null }));
         return;
@@ -1524,6 +1496,7 @@ function ComparisonStockChartView({
   });
 
   const handlePlotMove = (event: ChartMouseEvent) => {
+    if (mouseCrosshairDisabledRef.current) return;
     const localPointer = getLocalPlotPointer(event, plotRef.current, renderer);
     if (!localPointer) return;
     const selectionCursor = resolveSelectionCursor(localPointer, projection.dates.length, chartWidth);
@@ -1542,6 +1515,7 @@ function ComparisonStockChartView({
   };
 
   const handlePlotDown = (event: ChartMouseEvent) => {
+    mouseCrosshairDisabledRef.current = false;
     const localPointer = getLocalPlotPointer(event, plotRef.current, renderer);
     if (!localPointer) return;
     const selectionCursor = resolveSelectionCursor(localPointer, projection.dates.length, chartWidth);
@@ -1564,6 +1538,7 @@ function ComparisonStockChartView({
   };
 
   const handlePlotDrag = (event: ChartMouseEvent) => {
+    if (mouseCrosshairDisabledRef.current && !dragRef.current) return;
     const localPointer = getLocalPlotPointer(event, plotRef.current, renderer);
     if (localPointer) {
       const selectionCursor = resolveSelectionCursor(localPointer, projection.dates.length, chartWidth);
@@ -1628,7 +1603,7 @@ function ComparisonStockChartView({
     if (scrollPanCells === 0) return;
 
     const targetPanOffset = viewState.panOffset + scrollPanCells;
-    if (scrollPanCells > 0 && viewState.panOffset >= getMaxComparisonPanOffset(series, viewState.presetRange, viewState.zoomLevel, chartWidth) && expandBufferRange({
+    if (scrollPanCells > 0 && viewState.panOffset >= getMaxComparisonPanOffset(series, viewState.zoomLevel) && expandBufferRange({
       kind: "pan-left",
       targetPanOffset,
     })) {
@@ -1639,7 +1614,7 @@ function ComparisonStockChartView({
       panOffset: clamp(
         current.panOffset + scrollPanCells,
         0,
-        getMaxComparisonPanOffset(series, current.presetRange, current.zoomLevel, chartWidth),
+        getMaxComparisonPanOffset(series, current.zoomLevel),
       ),
     }));
   };
@@ -1649,7 +1624,8 @@ function ComparisonStockChartView({
   }
 
   const hasChartData = series.some((entry) => entry.points.length > 0);
-  const cursorScene = effectiveRenderer === "kitty" ? staticScene : liveScene;
+  const hasDisplayCursor = displayCursorX !== null && displayCursorY !== null;
+  const cursorScene = hasDisplayCursor ? displayScene : staticScene;
   const selectedSeries = hasChartData ? (cursorScene?.selectedSeries ?? staticResult.selectedSeries) : null;
   const selectedPoint = hasChartData ? (cursorScene?.selectedPoint ?? staticResult.selectedPoint) : null;
   const selectedRawValue = selectedPoint?.rawValue ?? selectedSeries?.latestRawValue ?? null;
@@ -1677,6 +1653,8 @@ function ComparisonStockChartView({
     start: visibleWindow.dates[0] ?? null,
     end: visibleWindow.dates[visibleWindow.dates.length - 1] ?? null,
   });
+  const cursorTimeAxisColumn = hasDisplayCursor ? displayScene?.cursorColumn ?? null : null;
+  const cursorTimeAxisDate = hasDisplayCursor ? displayScene?.activeDate ?? null : null;
 
   const canvasBitmapSize = useMemo(() => {
     if (!canvasCharts) return null;
@@ -1965,7 +1943,14 @@ function ComparisonStockChartView({
       </Box>
 
       <Box height={timeAxisRows}>
-        <Text fg={colors.textDim}>{timeAxisLabel}</Text>
+        <TimeAxisLabel
+          timeLabels={timeAxisLabel}
+          width={chartWidth}
+          cursorColumn={cursorTimeAxisColumn}
+          cursorDate={cursorTimeAxisDate}
+          dates={projection.dates}
+          cursorColor={chartColors.crosshairColor}
+        />
       </Box>
 
       {legendRows > 0 && (

package/src/components/chart/native/kitty.test.ts

@@ -17,6 +17,7 @@ import { chunkBase64Payload, encodeKittyTransmitRgba } from "./kitty-protocol";
 import { resolveChartRendererState } from "./renderer-selection";
 import { computeSurfaceVisibleFragments, NativeSurfaceManager } from "./surface-manager";
 import { syncCachedNativeSurface } from "./surface-sync";
+import { resolveNativeSurfaceVisibleRect, type NativeSurfaceRenderableNode } from "./surface-visibility";
 
 describe("resolveChartRendererState", () => {
   test("resolves auto and forced kitty correctly", () => {
@@ -98,6 +99,28 @@ describe("computeNativePlacement", () => {
   });
 });
 
+describe("resolveNativeSurfaceVisibleRect", () => {
+  test("treats hidden ancestors as invisible for native graphics", () => {
+    const hiddenParent: NativeSurfaceRenderableNode = {
+      x: 0,
+      y: 0,
+      width: 80,
+      height: 20,
+      visible: false,
+      parent: null,
+    };
+    const child: NativeSurfaceRenderableNode = {
+      x: 2,
+      y: 3,
+      width: 20,
+      height: 8,
+      parent: hiddenParent,
+    };
+
+    expect(resolveNativeSurfaceVisibleRect(child, 100, 30)).toBeNull();
+  });
+});
+
 describe("renderNativeChartBase", () => {
   test("leaves untouched bitmap pixels transparent", () => {
     const palette = resolveChartPalette({

package/src/components/chart/native/surface-visibility.ts

@@ -0,0 +1,48 @@
+import { intersectCellRects, type CellRect } from "./chart-rasterizer";
+
+export interface NativeSurfaceRenderableNode {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  visible?: boolean;
+  parent: NativeSurfaceRenderableNode | null;
+}
+
+export function getRenderableCellRect(
+  renderable: Pick<NativeSurfaceRenderableNode, "x" | "y" | "width" | "height">,
+): CellRect {
+  return {
+    x: renderable.x,
+    y: renderable.y,
+    width: renderable.width,
+    height: renderable.height,
+  };
+}
+
+export function resolveNativeSurfaceVisibleRect(
+  renderable: NativeSurfaceRenderableNode | null,
+  terminalWidth: number,
+  terminalHeight: number,
+): CellRect | null {
+  if (!renderable) return null;
+
+  let visible: CellRect = {
+    x: 0,
+    y: 0,
+    width: terminalWidth,
+    height: terminalHeight,
+  };
+  let current: NativeSurfaceRenderableNode | null = renderable;
+
+  while (current) {
+    if (current.visible === false) return null;
+
+    const nextVisible = intersectCellRects(visible, getRenderableCellRect(current));
+    if (!nextVisible) return null;
+    visible = nextVisible;
+    current = current.parent;
+  }
+
+  return visible;
+}

package/src/components/chart/static-chart-surface.tsx

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { Box, ChartSurface, Text, useUiCapabilities } from "../../ui";
+import { Box, ChartSurface, Text, useNativeRenderer, useUiCapabilities } from "../../ui";
 import type { ProjectedChartPoint } from "./chart-data";
 import {
   buildChartScene,
@@ -8,7 +8,7 @@ import {
   renderChart,
   type RenderChartOptions,
 } from "./chart-renderer";
-import { renderNativeChartBase, type NativeChartBitmap } from "./native/chart-rasterizer";
+import { computeBitmapSize, renderNativeChartBase, type NativeChartBitmap } from "./native/chart-rasterizer";
 
 export interface StaticChartSurfaceProps extends Omit<
   RenderChartOptions,
@@ -47,10 +47,12 @@ export function StaticChartSurface({
 }: StaticChartSurfaceProps) {
   const {
     canvasCharts,
+    nativeCharts,
     cellWidthPx = 8,
     cellHeightPx = 18,
     pixelRatio = 1,
   } = useUiCapabilities();
+  const nativeRenderer = useNativeRenderer();
   const timeAxisRows = showTimeAxis ? 1 : 0;
   const labelRows = yAxisLabel ? 1 : 0;
   const totalWidth = Math.max(1, Math.floor(width));
@@ -101,14 +103,36 @@ export function StaticChartSurface({
     : 0;
   const axisGap = axisWidth > 0 ? 1 : 0;
   const plotWidth = Math.max(1, totalWidth - axisWidth - axisGap);
+  const rendererResolution = nativeRenderer.resolution;
+  const rendererTerminalWidth = nativeRenderer.terminalWidth;
+  const rendererTerminalHeight = nativeRenderer.terminalHeight;
   const bitmapSize = useMemo(() => {
-    if (!canvasCharts) return null;
+    if (nativeCharts && rendererResolution && rendererTerminalWidth > 0 && rendererTerminalHeight > 0) {
+      return computeBitmapSize(
+        { x: 0, y: 0, width: plotWidth, height: plotHeight },
+        rendererResolution,
+        rendererTerminalWidth,
+        rendererTerminalHeight,
+      );
+    }
+    if (!canvasCharts && !nativeCharts) return null;
     const scale = Math.max(1, pixelRatio);
     return {
       pixelWidth: Math.max(1, Math.round(plotWidth * cellWidthPx * scale)),
       pixelHeight: Math.max(1, Math.round(plotHeight * cellHeightPx * scale)),
     };
-  }, [canvasCharts, cellHeightPx, cellWidthPx, pixelRatio, plotHeight, plotWidth]);
+  }, [
+    canvasCharts,
+    cellHeightPx,
+    cellWidthPx,
+    nativeCharts,
+    pixelRatio,
+    plotHeight,
+    plotWidth,
+    rendererResolution,
+    rendererTerminalHeight,
+    rendererTerminalWidth,
+  ]);
   const renderOptions = useMemo<RenderChartOptions>(() => ({
     width: plotWidth,
     height: plotHeight,

package/src/components/chart/stock-chart.test.ts

@@ -9,7 +9,6 @@ import {
   resolveAdjacentSelectionCursorX,
   resolveChartKeyboardKey,
   resolveIndicatorBufferRange,
-  resolveVisibleChartDateWindow,
   resolveSelectionDisplayCursorState,
 } from "./stock-chart";
 import { getPointTerminalColumn } from "./chart-renderer";
@@ -215,21 +214,6 @@ describe("stock chart auto helpers", () => {
     expect(nextState.window).toEqual(renderedAutoView.window);
   });
 
-  test("derives the visible label window from the actual visible chart points", () => {
-    const visibleWindow = resolveVisibleChartDateWindow([
-      { date: new Date("2026-01-03T00:00:00Z") },
-      { date: new Date("2026-01-06T00:00:00Z") },
-    ], {
-      start: new Date("2026-01-01T00:00:00Z"),
-      end: new Date("2026-01-08T00:00:00Z"),
-    });
-
-    expect(visibleWindow).toEqual({
-      start: new Date("2026-01-03T00:00:00Z"),
-      end: new Date("2026-01-06T00:00:00Z"),
-    });
-  });
-
   test("zooms in by at least one visible point on every auto step when more detail is available", () => {
     const history = makeDailyHistory(1, 10);