gloomberb 0.9.9 → 0.10.0

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

@@ -1,155 +0,0 @@
-import type { ReactNode, RefObject } from "react";
-import { Box, ChartSurface, Text, type BoxRenderable, type ChartSurfaceProps } from "../../../ui";
-import { colors } from "../../../theme/colors";
-import type { ChartMouseEvent } from "../core/pointer";
-import type { StyledContent } from "../core/renderer";
-import { PriceAxisLabels } from "../price-axis-labels";
-import { TimeAxisLabel } from "../time-axis-label";
-
-interface ComparisonChartLayoutProps {
-  axisGap: number;
-  axisLabels: Map<number, string>;
-  axisSectionWidth: number;
-  axisWidth: number;
-  bodyMessage: string | null;
-  canvasCrosshair: ChartSurfaceProps["crosshair"];
-  chartHeight: number;
-  chartWidth: number;
-  cursorAxisLabel: string | null;
-  cursorColor: string;
-  cursorPixelX: number | null;
-  cursorPixelY: number | null;
-  cursorRow: number | null;
-  cursorTimeAxisColumn: number | null;
-  cursorTimeAxisDate: Date | null;
-  hasCanvasContent: boolean;
-  isBlockingBody: boolean;
-  legend: ReactNode;
-  plotBitmaps: ChartSurfaceProps["bitmaps"];
-  plotLines: StyledContent[];
-  plotRef: RefObject<BoxRenderable | null>;
-  pointerEnabled: boolean;
-  timeAxisDates: Array<Date | string | number>;
-  timeAxisLabel: string;
-  timeAxisRows: number;
-  toolbar: ReactNode;
-  onPlotDown: (event: ChartMouseEvent) => void;
-  onPlotDrag: (event: ChartMouseEvent) => void;
-  onPlotMove: (event: ChartMouseEvent) => void;
-  onPlotScroll: (event: ChartMouseEvent) => void;
-  onResetDrag: () => void;
-}
-
-export function ComparisonChartLayout({
-  axisGap,
-  axisLabels,
-  axisSectionWidth,
-  axisWidth,
-  bodyMessage,
-  canvasCrosshair,
-  chartHeight,
-  chartWidth,
-  cursorAxisLabel,
-  cursorColor,
-  cursorPixelX,
-  cursorPixelY,
-  cursorRow,
-  cursorTimeAxisColumn,
-  cursorTimeAxisDate,
-  hasCanvasContent,
-  isBlockingBody,
-  legend,
-  plotBitmaps,
-  plotLines,
-  plotRef,
-  pointerEnabled,
-  timeAxisDates,
-  timeAxisLabel,
-  timeAxisRows,
-  toolbar,
-  onPlotDown,
-  onPlotDrag,
-  onPlotMove,
-  onPlotScroll,
-  onResetDrag,
-}: ComparisonChartLayoutProps) {
-  const plotContent = hasCanvasContent
-    ? null
-    : plotLines.map((line, index) => (
-      <Text key={index} content={line as unknown as string} selectable={false} />
-    ));
-
-  const plotBox = (
-    <ChartSurface
-      ref={plotRef}
-      width={chartWidth}
-      height={chartHeight}
-      flexDirection="column"
-      bitmaps={plotBitmaps}
-      crosshair={canvasCrosshair}
-      onMouseMove={pointerEnabled ? onPlotMove : undefined}
-      onMouseDown={pointerEnabled ? onPlotDown : undefined}
-      onMouseUp={pointerEnabled ? onResetDrag : undefined}
-      onMouseDrag={pointerEnabled ? onPlotDrag : undefined}
-      onMouseDragEnd={pointerEnabled ? onResetDrag : undefined}
-      onMouseScroll={pointerEnabled ? onPlotScroll : undefined}
-    >
-      {isBlockingBody
-        ? (
-          <Box flexGrow={1} alignItems="center" justifyContent="center">
-            <Text fg={colors.textDim} selectable={false}>Loading chart...</Text>
-          </Box>
-        )
-        : bodyMessage
-          ? (
-            <Box flexGrow={1} alignItems="center" justifyContent="center">
-              <Text fg={colors.textDim} selectable={false}>{bodyMessage}</Text>
-            </Box>
-          )
-          : plotContent}
-    </ChartSurface>
-  );
-
-  return (
-    <Box
-      flexDirection="column"
-      flexGrow={1}
-      onMouseScroll={pointerEnabled ? onPlotScroll : undefined}
-    >
-      {toolbar}
-
-      <Box
-        flexDirection="row"
-        height={chartHeight}
-        gap={axisGap}
-        onMouseScroll={pointerEnabled ? onPlotScroll : undefined}
-      >
-        {plotBox}
-        <PriceAxisLabels
-          axisLabels={axisLabels}
-          axisWidth={axisWidth}
-          axisSectionWidth={axisSectionWidth}
-          height={chartHeight}
-          cursorRow={cursorRow}
-          cursorPixelY={cursorPixelY}
-          cursorLabel={cursorAxisLabel}
-          cursorColor={cursorColor}
-        />
-      </Box>
-
-      <Box height={timeAxisRows}>
-        <TimeAxisLabel
-          timeLabels={timeAxisLabel}
-          width={chartWidth}
-          cursorColumn={cursorTimeAxisColumn}
-          cursorPixelX={cursorPixelX}
-          cursorDate={cursorTimeAxisDate}
-          dates={timeAxisDates}
-          cursorColor={cursorColor}
-        />
-      </Box>
-
-      {legend}
-    </Box>
-  );
-}

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

@@ -1,74 +0,0 @@
-import type { ComparisonChartProjection } from "../comparison/data";
-import { PriceReturnTable, type PriceReturnTableRow } from "../../price-performance";
-import type { PriceReturnField } from "../../../market-data/performance";
-import type { MouseInteractionEvent } from "../core/pointer";
-
-interface ComparisonChartLegendProps {
-  legendActiveIndex: number | null;
-  legendItemWidth: number;
-  legendRows: number;
-  onFocusInteraction: (event: MouseInteractionEvent | null | undefined) => void;
-  onOpenSymbol: (symbol: string) => void;
-  onSelectSymbol: (symbol: string) => void;
-  performanceBySymbol: ReadonlyMap<string, PriceReturnField[]>;
-  projection: ComparisonChartProjection;
-  selectedSymbol: string | null;
-  symbols: string[];
-}
-
-function buildRangeReturnField(
-  item: ComparisonChartProjection["series"][number] | null,
-  legendActiveIndex: number | null,
-): PriceReturnField {
-  const activeRaw = legendActiveIndex !== null
-    ? item?.points[legendActiveIndex]?.rawValue ?? null
-    : item?.latestRawValue ?? null;
-  const baseValue = item?.baseValue ?? null;
-  const value = activeRaw != null && baseValue != null && baseValue !== 0
-    ? (activeRaw - baseValue) / baseValue
-    : null;
-  return {
-    id: "RNG",
-    label: "Rng",
-    value,
-  };
-}
-
-export function ComparisonChartLegend({
-  legendActiveIndex,
-  legendItemWidth,
-  legendRows,
-  onFocusInteraction,
-  onOpenSymbol,
-  onSelectSymbol,
-  performanceBySymbol,
-  projection,
-  selectedSymbol,
-  symbols,
-}: ComparisonChartLegendProps) {
-  if (legendRows <= 0) return null;
-
-  const rows: PriceReturnTableRow[] = symbols.map((symbol) => {
-    const item = projection.series.find((entry) => entry.symbol === symbol) ?? null;
-    return {
-      symbol,
-      color: item?.color ?? "#888888",
-      fields: [
-        buildRangeReturnField(item, legendActiveIndex),
-        ...(performanceBySymbol.get(symbol) ?? []),
-      ],
-      selected: selectedSymbol === symbol,
-    };
-  });
-
-  return (
-    <PriceReturnTable
-      height={legendRows}
-      onFocusInteraction={onFocusInteraction}
-      onOpenSymbol={onOpenSymbol}
-      onSelectSymbol={onSelectSymbol}
-      rows={rows}
-      width={legendItemWidth}
-    />
-  );
-}

package/src/components/chart/comparison-stock-chart/native-surfaces.ts

@@ -1,89 +0,0 @@
-import { useCallback, useMemo, type RefObject } from "react";
-import type { BoxRenderable, NativeRendererHost } from "../../../ui";
-import type { ComparisonChartProjection } from "../comparison/data";
-import type { ComparisonChartScene } from "../comparison/renderer";
-import type { ResolvedChartRenderer } from "../core/types";
-import {
-  renderNativeComparisonChartBase,
-  type NativeCrosshairOverlay,
-} from "../native/chart-rasterizer";
-import { useNativeChartSurfaces } from "../native/surface/rendering";
-import type { NativeSurfaceManager } from "../native/surface/manager";
-import { buildComparisonNativeBitmapKey } from "./helpers";
-import type { ComparisonChartColors } from "./types";
-
-interface UseComparisonChartNativeSurfacesOptions {
-  chartColors: ComparisonChartColors;
-  effectiveRenderer: ResolvedChartRenderer;
-  marketSessionKey: string;
-  nativeCrosshair: NativeCrosshairOverlay | null;
-  nativeReady: boolean;
-  nativeSurfaceManager: NativeSurfaceManager;
-  paneId: string;
-  plotRef: RefObject<BoxRenderable | null>;
-  projection: ComparisonChartProjection;
-  renderer: NativeRendererHost;
-  selectedSymbol: string | null;
-  staticScene: ComparisonChartScene | null;
-  symbolCount: number;
-}
-
-function buildChartColorKey(colors: ComparisonChartColors): string {
-  return [
-    colors.bgColor,
-    colors.gridColor,
-    colors.crosshairColor,
-    colors.preMarketBgColor,
-    colors.postMarketBgColor,
-  ].join(",");
-}
-
-export function useComparisonChartNativeSurfaces({
-  chartColors,
-  effectiveRenderer,
-  marketSessionKey,
-  nativeCrosshair,
-  nativeReady,
-  nativeSurfaceManager,
-  paneId,
-  plotRef,
-  projection,
-  renderer,
-  selectedSymbol,
-  staticScene,
-  symbolCount,
-}: UseComparisonChartNativeSurfacesOptions) {
-  const nativeBaseSurfaceId = useMemo(() => `comparison-chart-surface:${paneId}:base`, [paneId]);
-  const nativeCrosshairSurfaceId = useMemo(() => `comparison-chart-surface:${paneId}:crosshair`, [paneId]);
-
-  const buildBaseBitmapKey = useCallback((bitmapSize: { pixelWidth: number; pixelHeight: number }) => buildComparisonNativeBitmapKey(
-    symbolCount,
-    projection,
-    selectedSymbol,
-    bitmapSize.pixelWidth,
-    bitmapSize.pixelHeight,
-    buildChartColorKey(chartColors),
-    marketSessionKey,
-  ), [
-    chartColors,
-    marketSessionKey,
-    projection,
-    selectedSymbol,
-    symbolCount,
-  ]);
-
-  useNativeChartSurfaces({
-    baseScene: staticScene,
-    baseSurfaceId: nativeBaseSurfaceId,
-    buildBaseBitmapKey,
-    crosshair: nativeCrosshair,
-    crosshairSurfaceId: nativeCrosshairSurfaceId,
-    effectiveRenderer,
-    nativeReady,
-    nativeSurfaceManager,
-    paneId,
-    plotRef,
-    renderBase: renderNativeComparisonChartBase,
-    renderer,
-  });
-}

package/src/components/chart/comparison-stock-chart/render-data.ts

@@ -1,227 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import {
-  DEFAULT_LIVE_CHART_REFRESH_INTERVAL_MS,
-  useChartQueries,
-} from "../../../market-data/hooks";
-import type { ChartRequest, InstrumentRef } from "../../../market-data/request-types";
-import { buildChartKey, resolveEntryData } from "../../../market-data/selectors";
-import { getSharedMarketData } from "../../../plugins/registry";
-import { blendHex, colors, getComparisonSeriesColor } from "../../../theme/colors";
-import type { BrokerContractRef } from "../../../types/instrument";
-import type { PricePoint, Quote } from "../../../types/financials";
-import { appendLiveQuotePoint } from "../core/data";
-import { resolveChartBodyState } from "../core/controller";
-import {
-  buildChartResolutionSupportMap,
-  DEFAULT_VISIBLE_MANUAL_CHART_RESOLUTIONS,
-  intersectChartResolutionSupport,
-  normalizeChartResolutionSupport,
-  sortChartResolutions,
-  type ChartResolutionSupport,
-} from "../core/resolution";
-import type {
-  ChartResolution,
-  ComparisonChartSeries,
-  ComparisonChartViewState,
-} from "../core/types";
-
-const COMPARISON_PERFORMANCE_RANGE = "5Y" as const;
-
-export interface ComparisonChartSymbolSource {
-  symbol: string;
-  currency: string | undefined;
-  quote: Quote | undefined;
-  exchange: string;
-  brokerId: string | undefined;
-  brokerInstanceId: string | undefined;
-  instrument: BrokerContractRef | null;
-  priceHistory: PricePoint[];
-}
-
-interface UseComparisonChartRenderDataOptions {
-  symbolSources: ComparisonChartSymbolSource[];
-  viewState: ComparisonChartViewState;
-}
-
-function instrumentFromSymbolSource(source: ComparisonChartSymbolSource): InstrumentRef {
-  return {
-    symbol: source.symbol,
-    exchange: source.exchange,
-    brokerId: source.brokerId,
-    brokerInstanceId: source.brokerInstanceId,
-    instrument: source.instrument,
-  };
-}
-
-export function useComparisonChartRenderData({
-  symbolSources,
-  viewState,
-}: UseComparisonChartRenderDataOptions) {
-  const [resolutionSupport, setResolutionSupport] = useState<ChartResolutionSupport[] | null>(null);
-  const supportMap = useMemo(() => buildChartResolutionSupportMap(resolutionSupport ?? []), [resolutionSupport]);
-  const marketDataProvider = getSharedMarketData();
-  const capabilityDescriptor = useMemo(() => {
-    const sources = symbolSources.map((source) => ({
-      symbol: source.symbol,
-      exchange: source.exchange,
-      brokerId: source.brokerId,
-      brokerInstanceId: source.brokerInstanceId,
-      instrument: source.instrument,
-    }));
-    return {
-      key: sources.map((source) => [
-        source.symbol,
-        source.exchange,
-        source.brokerId ?? "",
-        source.brokerInstanceId ?? "",
-        source.instrument?.conId ?? "",
-        source.instrument?.localSymbol ?? "",
-        source.instrument?.symbol ?? "",
-      ].join(":")).join("|"),
-      sources,
-    };
-  }, [symbolSources]);
-  const effectiveResolutionSupport = useMemo<ChartResolutionSupport[]>(() => (
-    resolutionSupport ?? DEFAULT_VISIBLE_MANUAL_CHART_RESOLUTIONS.map((resolution) => ({ resolution, maxRange: "ALL" as const }))
-  ), [resolutionSupport]);
-  const selectionSupportMap = useMemo(
-    () => buildChartResolutionSupportMap(effectiveResolutionSupport),
-    [effectiveResolutionSupport],
-  );
-
-  useEffect(() => {
-    const provider = marketDataProvider;
-    if ((!provider?.getChartResolutionSupport && !provider?.getChartResolutionCapabilities) || capabilityDescriptor.sources.length === 0) {
-      setResolutionSupport(null);
-      return;
-    }
-
-    let cancelled = false;
-    setResolutionSupport(null);
-    Promise.all(capabilityDescriptor.sources.map(async (source) => {
-      try {
-        const support = provider.getChartResolutionSupport
-          ? await provider.getChartResolutionSupport(
-            source.symbol,
-            source.exchange,
-            {
-              brokerId: source.brokerId,
-              brokerInstanceId: source.brokerInstanceId,
-              instrument: source.instrument ?? null,
-            },
-          )
-          : normalizeChartResolutionSupport(
-            (await provider.getChartResolutionCapabilities?.(
-              source.symbol,
-              source.exchange,
-              {
-                brokerId: source.brokerId,
-                brokerInstanceId: source.brokerInstanceId,
-                instrument: source.instrument ?? null,
-              },
-            ) ?? []).map((resolution) => ({ resolution, maxRange: "ALL" })),
-          );
-        return support;
-      } catch {
-        return null;
-      }
-    })).then((supportSets) => {
-      if (!cancelled) {
-        setResolutionSupport(
-          supportSets.some((support) => support === null)
-            ? null
-            : intersectChartResolutionSupport(supportSets.filter((support): support is ChartResolutionSupport[] => support !== null)),
-        );
-      }
-    }).catch(() => {
-      if (!cancelled) {
-        setResolutionSupport(null);
-      }
-    });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [capabilityDescriptor.key, marketDataProvider]);
-
-  const availableManualResolutions = resolutionSupport?.map((entry) => entry.resolution) ?? DEFAULT_VISIBLE_MANUAL_CHART_RESOLUTIONS;
-  const effectiveResolution: ChartResolution = viewState.resolution !== "auto"
-    && resolutionSupport !== null
-    && !supportMap.has(viewState.resolution)
-    ? "auto"
-    : viewState.resolution;
-  const resolutionChips = useMemo(
-    () => sortChartResolutions(["auto", ...availableManualResolutions] as ChartResolution[]),
-    [availableManualResolutions],
-  );
-  const chartRequests = useMemo(() => (
-    symbolSources.map((source) => ({
-      instrument: instrumentFromSymbolSource(source),
-      bufferRange: viewState.bufferRange,
-      granularity: effectiveResolution === "auto" ? "range" as const : "resolution" as const,
-      resolution: effectiveResolution === "auto" ? undefined : effectiveResolution,
-    }))
-  ), [effectiveResolution, symbolSources, viewState.bufferRange]);
-  const performanceRequests = useMemo<ChartRequest[]>(() => (
-    symbolSources.map((source) => ({
-      instrument: instrumentFromSymbolSource(source),
-      bufferRange: COMPARISON_PERFORMANCE_RANGE,
-      granularity: "range",
-    }))
-  ), [symbolSources]);
-  const chartEntries = useChartQueries(chartRequests, {
-    refreshIntervalMs: DEFAULT_LIVE_CHART_REFRESH_INTERVAL_MS,
-  });
-  const performanceEntries = useChartQueries(performanceRequests, {
-    refreshIntervalMs: DEFAULT_LIVE_CHART_REFRESH_INTERVAL_MS,
-  });
-  const entryStates = useMemo(() => chartRequests.map((request) => (
-    resolveChartBodyState(chartEntries.get(buildChartKey(request)), (value) => Array.isArray(value) && value.length > 0, "No chart data yet.")
-  )), [chartEntries, chartRequests]);
-  const hasSeriesData = entryStates.some((state) => !!state.data?.length);
-  const isBlockingBody = entryStates.some((state) => state.blocking) || (chartRequests.length > 0 && entryStates.length !== chartRequests.length);
-  const bodyMessage = hasSeriesData
-    ? null
-    : entryStates.find((state) => state.errorMessage)?.errorMessage
-      ?? entryStates.find((state) => state.emptyMessage)?.emptyMessage
-      ?? null;
-  const isUpdating = !isBlockingBody && entryStates.some((state) => state.updating);
-  const series = useMemo<ComparisonChartSeries[]>(() => symbolSources.map((source, index) => {
-    const request = chartRequests[index];
-    const history = request ? (chartEntries.get(buildChartKey(request))?.data ?? []) : [];
-    const points = appendLiveQuotePoint(history, source.quote);
-    const color = getComparisonSeriesColor(index);
-    return {
-      symbol: source.symbol,
-      color,
-      fillColor: blendHex(colors.bg, color, 0.22),
-      currency: source.currency,
-      points,
-    };
-  }), [chartEntries, chartRequests, symbolSources]);
-  const performanceHistoryBySymbol = useMemo(() => {
-    const bySymbol = new Map<string, PricePoint[]>();
-    symbolSources.forEach((source, index) => {
-      const request = performanceRequests[index];
-      const history = request ? resolveEntryData(performanceEntries.get(buildChartKey(request))) : null;
-      if (history?.length) {
-        bySymbol.set(source.symbol, history);
-      }
-    });
-    return bySymbol;
-  }, [performanceEntries, performanceRequests, symbolSources]);
-
-  return {
-    availableManualResolutions,
-    bodyMessage,
-    effectiveResolution,
-    effectiveResolutionSupport,
-    isBlockingBody,
-    isUpdating,
-    resolutionChips,
-    selectionSupportMap,
-    performanceHistoryBySymbol,
-    series,
-    supportMap,
-  };
-}

package/src/components/chart/comparison-stock-chart/render-output.ts

@@ -1,140 +0,0 @@
-import { useMemo } from "react";
-import type { ComparisonChartProjection } from "../comparison/data";
-import {
-  buildComparisonChartScene,
-  formatComparisonCursorAxisValue,
-  renderComparisonChart,
-  type ComparisonChartScene,
-  type RenderComparisonChartResult,
-} from "../comparison/renderer";
-import type { ChartMarketSession, ResolvedChartRenderer } from "../core/types";
-
-type ComparisonChartColors = Parameters<typeof buildComparisonChartScene>[1]["colors"];
-
-interface UseComparisonChartRenderOutputOptions {
-  chartColors: ComparisonChartColors;
-  chartHeight: number;
-  chartWidth: number;
-  displayCursorX: number | null;
-  displayCursorY: number | null;
-  effectiveRenderer: ResolvedChartRenderer;
-  hasChartData: boolean;
-  marketSession: ChartMarketSession | null;
-  projection: ComparisonChartProjection;
-  selectedSymbol: string | null;
-  useCanvasChart: boolean;
-}
-
-interface UseComparisonChartRenderOutputResult {
-  axisLabels: Map<number, string>;
-  cursorAxisLabel: string | null;
-  cursorRow: number | null;
-  cursorTimeAxisColumn: number | null;
-  cursorTimeAxisDate: Date | null;
-  displayScene: ComparisonChartScene | null;
-  hasDisplayCursor: boolean;
-  legendActiveIndex: number | null;
-  result: RenderComparisonChartResult;
-  staticResult: RenderComparisonChartResult;
-  staticScene: ComparisonChartScene | null;
-  timeAxisLabel: string;
-  visiblePriceRange: number | undefined;
-}
-
-export function useComparisonChartRenderOutput({
-  chartColors,
-  chartHeight,
-  chartWidth,
-  displayCursorX,
-  displayCursorY,
-  effectiveRenderer,
-  hasChartData,
-  marketSession,
-  projection,
-  selectedSymbol,
-  useCanvasChart,
-}: UseComparisonChartRenderOutputOptions): UseComparisonChartRenderOutputResult {
-  const staticScene = useMemo(() => buildComparisonChartScene(projection, {
-    width: chartWidth,
-    height: chartHeight,
-    cursorX: null,
-    cursorY: null,
-    selectedSymbol,
-    colors: chartColors,
-    marketSession,
-  }), [chartColors, chartHeight, chartWidth, marketSession, projection, selectedSymbol]);
-
-  const displayScene = useMemo(() => buildComparisonChartScene(projection, {
-    width: chartWidth,
-    height: chartHeight,
-    cursorX: displayCursorX,
-    cursorY: displayCursorY,
-    selectedSymbol,
-    colors: chartColors,
-    marketSession,
-  }), [chartColors, chartHeight, chartWidth, displayCursorX, displayCursorY, marketSession, projection, selectedSymbol]);
-
-  const staticResult = useMemo(() => renderComparisonChart(projection, {
-    width: chartWidth,
-    height: chartHeight,
-    cursorX: null,
-    cursorY: null,
-    selectedSymbol,
-    colors: chartColors,
-    marketSession,
-  }), [chartColors, chartHeight, chartWidth, marketSession, projection, selectedSymbol]);
-
-  const interactiveResult = useMemo(() => (
-    effectiveRenderer === "kitty" || useCanvasChart
-      ? null
-      : renderComparisonChart(projection, {
-        width: chartWidth,
-        height: chartHeight,
-        cursorX: displayCursorX,
-        cursorY: displayCursorY,
-        selectedSymbol,
-        colors: chartColors,
-        marketSession,
-      })
-  ), [chartColors, chartHeight, chartWidth, displayCursorX, displayCursorY, effectiveRenderer, marketSession, projection, selectedSymbol, useCanvasChart]);
-
-  const result = effectiveRenderer === "kitty" || useCanvasChart ? staticResult : interactiveResult!;
-  const timeAxisLabel = result.timeLabels || staticResult.timeLabels;
-  const hasDisplayCursor = displayCursorX !== null && displayCursorY !== null;
-  const cursorScene = hasDisplayCursor ? displayScene : staticScene;
-  const legendActiveIndex = hasChartData
-    ? cursorScene?.activeIdx ?? staticScene?.activeIdx ?? null
-    : null;
-  const visiblePriceRange = result.priceRange ?? staticResult.priceRange ?? undefined;
-  const axisLabels = useMemo(
-    () => new Map(staticResult.axisLabels.map((entry) => [entry.row, entry.label])),
-    [staticResult.axisLabels],
-  );
-  const cursorRow = useCanvasChart ? cursorScene?.cursorRow ?? null : result.cursorRow;
-  const crosshairValue = useCanvasChart ? cursorScene?.crosshairValue ?? null : result.crosshairValue;
-  const cursorAxisLabel = cursorRow !== null && crosshairValue !== null
-    ? formatComparisonCursorAxisValue(
-      crosshairValue,
-      projection.effectiveAxisMode,
-      visiblePriceRange,
-    )
-    : null;
-  const cursorTimeAxisColumn = hasDisplayCursor ? displayScene?.cursorColumn ?? null : null;
-  const cursorTimeAxisDate = hasDisplayCursor ? displayScene?.activeDate ?? null : null;
-
-  return {
-    axisLabels,
-    cursorAxisLabel,
-    cursorRow,
-    cursorTimeAxisColumn,
-    cursorTimeAxisDate,
-    displayScene,
-    hasDisplayCursor,
-    legendActiveIndex,
-    result,
-    staticResult,
-    staticScene,
-    timeAxisLabel,
-    visiblePriceRange,
-  };
-}