gloomberb 0.9.10 → 0.10.0

package/src/components/chart/comparison-stock-chart/selection-runtime.ts

@@ -1,128 +0,0 @@
-import { useCallback, useEffect, useRef, type Dispatch, type MutableRefObject, type SetStateAction } from "react";
-import type { BoxRenderable, NativeRendererHost } from "../../../ui";
-import { useAppDispatch, usePaneInstanceId } from "../../../state/app/context";
-import { buildDisplayCursorState, type MouseInteractionEvent } from "../core/pointer";
-import type { ComparisonChartViewState } from "../core/types";
-import { useChartDisplayCursor, useChartDisplayCursorLayoutRemap } from "../display-cursor";
-import { clamp } from "./helpers";
-
-interface UseComparisonChartSelectionRuntimeOptions {
-  chartHeight: number;
-  chartWidth: number;
-  cursorX: number | null;
-  cursorY: number | null;
-  focused: boolean;
-  renderer: NativeRendererHost;
-  setViewState: Dispatch<SetStateAction<ComparisonChartViewState>>;
-  symbols: string[];
-}
-
-export function useComparisonChartSelectionRuntime({
-  chartHeight,
-  chartWidth,
-  cursorX: viewCursorX,
-  cursorY: viewCursorY,
-  focused,
-  renderer,
-  setViewState,
-  symbols,
-}: UseComparisonChartSelectionRuntimeOptions): {
-  commitSelectionCursor: (next: { cursorX: number | null; cursorY: number | null }) => void;
-  displayCursor: ReturnType<typeof useChartDisplayCursor>["displayCursor"];
-  displayCursorX: number | null;
-  displayCursorY: number | null;
-  focusPaneForMouseInteraction: (event: MouseInteractionEvent | null | undefined) => void;
-  mouseCrosshairDisabledRef: MutableRefObject<boolean>;
-  plotRef: MutableRefObject<BoxRenderable | null>;
-  scrollPanCellRemainderRef: MutableRefObject<number>;
-  selectSymbolByOffset: (offset: number) => void;
-  setSelectedSymbol: (symbol: string) => void;
-  updateDisplayCursorTarget: ReturnType<typeof useChartDisplayCursor>["updateDisplayCursorTarget"];
-} {
-  const dispatch = useAppDispatch();
-  const paneId = usePaneInstanceId();
-  const plotRef = useRef<BoxRenderable | null>(null);
-  const mouseCrosshairDisabledRef = useRef(false);
-  const scrollPanCellRemainderRef = useRef(0);
-  const {
-    commitDisplayCursor,
-    cursorMotionKindRef,
-    displayCursor,
-    displayCursorRef,
-    targetCursorRef,
-    updateDisplayCursorTarget,
-  } = useChartDisplayCursor();
-
-  const cursorX = viewCursorX !== null ? clamp(viewCursorX, 0, chartWidth - 1) : null;
-  const cursorY = viewCursorY !== null ? clamp(viewCursorY, 0, chartHeight - 1) : null;
-  const displayCursorX = displayCursor.cellX !== null ? clamp(displayCursor.cellX, 0, chartWidth - 1) : null;
-  const displayCursorY = displayCursor.cellY !== null ? clamp(displayCursor.cellY, 0, chartHeight - 1) : null;
-
-  const focusPaneForMouseInteraction = useCallback((
-    event: MouseInteractionEvent | null | undefined,
-  ) => {
-    event?.stopPropagation?.();
-    event?.preventDefault?.();
-    if (!focused) {
-      dispatch({ type: "FOCUS_PANE", paneId });
-    }
-  }, [dispatch, focused, paneId]);
-
-  const setSelectedSymbol = (symbol: string) => {
-    setViewState((current) => (
-      current.selectedSymbol === symbol
-        ? current
-        : { ...current, selectedSymbol: symbol }
-    ));
-  };
-
-  const commitSelectionCursor = (next: { cursorX: number | null; cursorY: number | null }) => {
-    setViewState((current) => (
-      current.cursorX === next.cursorX && current.cursorY === next.cursorY
-        ? current
-        : { ...current, cursorX: next.cursorX, cursorY: next.cursorY }
-    ));
-  };
-
-  const selectSymbolByOffset = (offset: number) => {
-    setViewState((current) => {
-      const currentIndex = Math.max(symbols.indexOf(current.selectedSymbol ?? symbols[0] ?? ""), 0);
-      return {
-        ...current,
-        selectedSymbol: symbols[clamp(currentIndex + offset, 0, symbols.length - 1)] ?? current.selectedSymbol,
-      };
-    });
-  };
-
-  useChartDisplayCursorLayoutRemap({
-    chartHeight,
-    chartWidth,
-    commitDisplayCursor,
-    displayCursorRef,
-    plotRef,
-    renderer,
-    targetCursorRef,
-  });
-
-  useEffect(() => {
-    if (cursorMotionKindRef.current === "pixel") return;
-    updateDisplayCursorTarget(
-      buildDisplayCursorState(cursorX, cursorY, plotRef.current, renderer),
-      cursorMotionKindRef.current,
-    );
-  }, [cursorMotionKindRef, cursorX, cursorY, renderer, updateDisplayCursorTarget]);
-
-  return {
-    commitSelectionCursor,
-    displayCursor,
-    displayCursorX,
-    displayCursorY,
-    focusPaneForMouseInteraction,
-    mouseCrosshairDisabledRef,
-    plotRef,
-    scrollPanCellRemainderRef,
-    selectSymbolByOffset,
-    setSelectedSymbol,
-    updateDisplayCursorTarget,
-  };
-}

package/src/components/chart/comparison-stock-chart/sources.ts

@@ -1,51 +0,0 @@
-import { useMemo } from "react";
-import { useTickerFinancialsMap } from "../../../market-data/hooks";
-import { useAppSelector } from "../../../state/app/context";
-import type { ChartRendererPreference } from "../core/types";
-import type { ComparisonChartSymbolSource } from "./render-data";
-
-export function useComparisonChartSymbolSources(symbols: string[]): {
-  defaultRenderMode: string | undefined;
-  preferredRenderer: ChartRendererPreference;
-  stableSymbols: string[];
-  symbolSources: ComparisonChartSymbolSource[];
-} {
-  const tickers = useAppSelector((state) => state.tickers);
-  const financials = useAppSelector((state) => state.financials);
-  const chartPreferences = useAppSelector((state) => state.config.chartPreferences);
-  const symbolsKey = symbols.join("|");
-  const stableSymbols = useMemo(() => symbols, [symbolsKey]);
-  const stableTickers = useMemo(() => (
-    stableSymbols.flatMap((symbol) => {
-      const ticker = tickers.get(symbol);
-      return ticker ? [ticker] : [];
-    })
-  ), [stableSymbols, tickers]);
-  const marketFinancials = useTickerFinancialsMap(stableTickers);
-  const symbolSources = useMemo<ComparisonChartSymbolSource[]>(() => stableSymbols.map((symbol) => {
-    const ticker = tickers.get(symbol) ?? null;
-    const marketFinancial = marketFinancials.get(symbol) ?? null;
-    const storedFinancial = financials.get(symbol) ?? null;
-    const instrument = ticker?.metadata.broker_contracts?.[0] ?? null;
-    const quote = marketFinancial?.quote ?? storedFinancial?.quote;
-    return {
-      symbol,
-      currency: quote?.currency ?? ticker?.metadata.currency,
-      quote,
-      exchange: ticker?.metadata.exchange ?? "",
-      brokerId: instrument?.brokerId,
-      brokerInstanceId: instrument?.brokerInstanceId,
-      instrument,
-      priceHistory: marketFinancial?.priceHistory?.length
-        ? marketFinancial.priceHistory
-        : storedFinancial?.priceHistory ?? [],
-    };
-  }), [financials, marketFinancials, stableSymbols, tickers]);
-
-  return {
-    defaultRenderMode: chartPreferences.defaultRenderMode,
-    preferredRenderer: chartPreferences.renderer,
-    stableSymbols,
-    symbolSources,
-  };
-}

package/src/components/chart/comparison-stock-chart/surface-runtime.ts

@@ -1,159 +0,0 @@
-import { useMemo, type RefObject } from "react";
-import type { BoxRenderable, ChartSurfaceProps, NativeRendererHost } from "../../../ui";
-import {
-  buildBlankPlotLines,
-  type DisplayCursorState,
-} from "../core/pointer";
-import type { StyledContent } from "../core/renderer";
-import type { ComparisonChartProjection } from "../comparison/data";
-import type { ComparisonChartScene } from "../comparison/renderer";
-import type {
-  ChartAxisMode,
-  ChartMarketSession,
-  ComparisonChartSeries,
-  ComparisonChartViewState,
-  ResolvedChartRenderer,
-} from "../core/types";
-import type { NativeSurfaceManager } from "../native/surface/manager";
-import { useComparisonChartCanvasBitmaps } from "./canvas";
-import { useComparisonChartNativeSurfaces } from "./native-surfaces";
-import type { ComparisonChartColors } from "./types";
-
-interface UseComparisonChartSurfaceRuntimeOptions {
-  axisMode: ChartAxisMode;
-  bodyMessage: string | null;
-  canvasCharts: boolean;
-  cellHeightPx: number;
-  cellWidthPx: number;
-  chartColors: ComparisonChartColors;
-  chartHeight: number;
-  chartWidth: number;
-  displayCursor: DisplayCursorState;
-  effectiveRenderer: ResolvedChartRenderer;
-  hasChartData: boolean;
-  isBlockingBody: boolean;
-  marketSession: ChartMarketSession | null;
-  marketSessionKey: string;
-  nativeReady: boolean;
-  nativeSurfaceManager: NativeSurfaceManager;
-  paneId: string;
-  pixelRatio: number;
-  plotRef: RefObject<BoxRenderable | null>;
-  projection: ComparisonChartProjection;
-  projectionViewState: Pick<ComparisonChartViewState, "dateWindow" | "panOffset" | "renderMode" | "zoomLevel">;
-  renderer: NativeRendererHost;
-  resultLines: StyledContent[];
-  selectedSymbol: string | null;
-  series: ComparisonChartSeries[];
-  staticScene: ComparisonChartScene | null;
-  symbolCount: number;
-  useCanvasChart: boolean;
-}
-
-export function useComparisonChartSurfaceRuntime({
-  axisMode,
-  bodyMessage,
-  canvasCharts,
-  cellHeightPx,
-  cellWidthPx,
-  chartColors,
-  chartHeight,
-  chartWidth,
-  displayCursor,
-  effectiveRenderer,
-  hasChartData,
-  isBlockingBody,
-  marketSession,
-  marketSessionKey,
-  nativeReady,
-  nativeSurfaceManager,
-  paneId,
-  pixelRatio,
-  plotRef,
-  projection,
-  projectionViewState,
-  renderer,
-  resultLines,
-  selectedSymbol,
-  series,
-  staticScene,
-  symbolCount,
-  useCanvasChart,
-}: UseComparisonChartSurfaceRuntimeOptions): {
-  canvasCrosshair: ChartSurfaceProps["crosshair"];
-  hasCanvasContent: boolean;
-  plotBitmaps: ChartSurfaceProps["bitmaps"];
-  plotLines: StyledContent[];
-  pointerEnabled: boolean;
-} {
-  const nativeCrosshair = useMemo(() => {
-    if (displayCursor.cellX === null || displayCursor.cellY === null) return null;
-    return {
-      width: chartWidth,
-      height: chartHeight,
-      chartRows: chartHeight,
-      pixelX: displayCursor.pixelX,
-      pixelY: displayCursor.pixelY,
-      colors: {
-        crosshairColor: chartColors.crosshairColor,
-      },
-    };
-  }, [chartColors.crosshairColor, chartHeight, chartWidth, displayCursor]);
-  const blankPlotLines = useMemo(() => buildBlankPlotLines(chartWidth, chartHeight), [chartHeight, chartWidth]);
-
-  useComparisonChartNativeSurfaces({
-    chartColors,
-    effectiveRenderer,
-    marketSessionKey,
-    nativeCrosshair,
-    nativeReady,
-    nativeSurfaceManager,
-    paneId,
-    plotRef,
-    projection,
-    renderer,
-    selectedSymbol,
-    staticScene,
-    symbolCount,
-  });
-
-  const {
-    canvasBaseBitmapKey,
-    canvasCrosshair,
-    plotBitmaps,
-  } = useComparisonChartCanvasBitmaps({
-    axisMode,
-    bodyMessage,
-    canvasCharts,
-    cellHeightPx,
-    cellWidthPx,
-    chartColors,
-    chartHeight,
-    chartWidth,
-    hasChartData,
-    isBlockingBody,
-    marketSession,
-    marketSessionKey,
-    nativeCrosshair,
-    pixelRatio,
-    plotRef,
-    projectionViewState,
-    renderer,
-    selectedSymbol,
-    series,
-    symbolCount,
-  });
-
-  const plotLines = effectiveRenderer === "kitty"
-    ? blankPlotLines
-    : resultLines;
-  const pointerEnabled = hasChartData && !isBlockingBody && !bodyMessage;
-
-  return {
-    canvasCrosshair,
-    hasCanvasContent: !!plotBitmaps || (useCanvasChart && !!canvasBaseBitmapKey),
-    plotBitmaps,
-    plotLines,
-    pointerEnabled,
-  };
-}

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

@@ -1,117 +0,0 @@
-import { Box, Text, TextAttributes } from "../../../ui";
-import { colors } from "../../../theme/colors";
-import {
-  getChartResolutionLabel,
-  isRangePresetSupported,
-  type ManualChartResolution,
-} from "../core/resolution";
-import {
-  COMPARISON_RENDER_MODES,
-  TIME_RANGES,
-  type ChartResolution,
-  type ComparisonChartRenderMode,
-  type TimeRange,
-} from "../core/types";
-import type { MouseInteractionEvent } from "../core/pointer";
-
-const MODE_CHIPS: Record<ComparisonChartRenderMode, string> = {
-  area: "A",
-  line: "L",
-};
-
-interface ComparisonChartToolbarProps {
-  activePreset: TimeRange | null;
-  availableManualResolutions: ManualChartResolution[];
-  effectiveResolution: ChartResolution;
-  focusPaneForMouseInteraction: (event: MouseInteractionEvent | null | undefined) => void;
-  isUpdating: boolean;
-  onRangeSelect: (range: TimeRange) => void;
-  onRenderModeSelect: (mode: ComparisonChartRenderMode) => void;
-  onResolutionSelect: (resolution: ChartResolution) => void;
-  projectionWarning: string | null;
-  renderMode: ComparisonChartRenderMode;
-  resolutionChips: ChartResolution[];
-  showNativeUnavailable: boolean;
-}
-
-export function ComparisonChartToolbar({
-  activePreset,
-  availableManualResolutions,
-  effectiveResolution,
-  focusPaneForMouseInteraction,
-  isUpdating,
-  onRangeSelect,
-  onRenderModeSelect,
-  onResolutionSelect,
-  projectionWarning,
-  renderMode,
-  resolutionChips,
-  showNativeUnavailable,
-}: ComparisonChartToolbarProps) {
-  return (
-    <>
-      <Box flexDirection="row" height={1}>
-        <Box flexDirection="row" gap={1}>
-          {TIME_RANGES.map((range, index) => (
-            <Text
-              key={range}
-              fg={activePreset === range ? colors.textBright : (isRangePresetSupported(range, availableManualResolutions) ? colors.textDim : colors.textMuted)}
-              attributes={activePreset === range ? TextAttributes.BOLD : 0}
-              onMouseDown={(event: any) => {
-                focusPaneForMouseInteraction(event);
-                if (isRangePresetSupported(range, availableManualResolutions)) {
-                  onRangeSelect(range);
-                }
-              }}
-            >
-              {`${index + 1}:${range}`}
-            </Text>
-          ))}
-        </Box>
-      </Box>
-
-      <Box flexDirection="row" height={1}>
-        <Box flexDirection="row" gap={1}>
-          {resolutionChips.map((resolution) => (
-            <Text
-              key={resolution}
-              fg={effectiveResolution === resolution ? colors.textBright : colors.textDim}
-              attributes={effectiveResolution === resolution ? TextAttributes.BOLD : 0}
-              onMouseDown={(event: any) => {
-                focusPaneForMouseInteraction(event);
-                onResolutionSelect(resolution);
-              }}
-            >
-              {getChartResolutionLabel(resolution)}
-            </Text>
-          ))}
-          {isUpdating && (
-            <Text fg={colors.textDim}>updating</Text>
-          )}
-        </Box>
-        <Box flexGrow={1} />
-        <Box flexDirection="row" gap={1}>
-          {COMPARISON_RENDER_MODES.map((mode) => (
-            <Text
-              key={mode}
-              fg={renderMode === mode ? colors.textBright : colors.textDim}
-              attributes={renderMode === mode ? TextAttributes.BOLD : 0}
-              onMouseDown={(event: any) => {
-                focusPaneForMouseInteraction(event);
-                onRenderModeSelect(mode);
-              }}
-            >
-              {MODE_CHIPS[mode]}
-            </Text>
-          ))}
-          {projectionWarning && (
-            <Text fg={colors.textDim}>{projectionWarning}</Text>
-          )}
-          {showNativeUnavailable && (
-            <Text fg={colors.textDim}>native unavailable</Text>
-          )}
-        </Box>
-      </Box>
-    </>
-  );
-}

package/src/components/chart/comparison-stock-chart/types.ts

@@ -1,22 +0,0 @@
-import type { ChartAxisMode, ChartColors } from "../core/types";
-
-export interface ComparisonStockChartProps {
-  paneId: string;
-  width: number;
-  height: number;
-  focused: boolean;
-  symbols: string[];
-  axisMode: ChartAxisMode;
-  onOpenSymbol: (symbol: string) => void;
-  onEditTickers?: () => void;
-}
-
-export type ComparisonChartColors = Pick<
-  ChartColors,
-  "bgColor" | "gridColor" | "crosshairColor" | "preMarketBgColor" | "postMarketBgColor"
->;
-
-export type PendingExpansionAction =
-  | { kind: "zoom-out"; targetVisibleCount: number; anchorRatio: number }
-  | { kind: "pan-left"; targetPanOffset: number }
-  | null;