gloomberb 0.9.9 → 0.10.0

package/src/components/chart/comparison/renderer.ts

@@ -1,282 +0,0 @@
-import type {
-  ComparisonChartProjection,
-  ComparisonProjectedPoint,
-  ComparisonProjectedSeries,
-} from "./data";
-import {
-  bufferToBrailleLines,
-  computeGridLines,
-  createPixelBuffer,
-  drawCrosshair,
-  drawGridLines,
-  drawLine,
-  formatPrice,
-  resolveAxisFractionDigits,
-  type StyledContent,
-} from "../core/renderer";
-import type { ChartAxisMode, ChartSessionBackgroundSpan } from "../core/types";
-import {
-  buildComparisonChartScene,
-  getComparisonDotX,
-  getComparisonPointBand,
-  getScaledComparisonY,
-  getSelectedComparisonSeries,
-  type ComparisonChartColors,
-  type RenderComparisonChartOptions,
-} from "./scene";
-
-const LAYER_FILL = 1;
-const LAYER_DATA = 2;
-export {
-  buildComparisonChartScene,
-  type ComparisonChartScene,
-  type RenderComparisonChartOptions,
-} from "./scene";
-
-export interface RenderComparisonChartResult {
-  lines: StyledContent[];
-  axisLabels: { row: number; label: string }[];
-  timeLabels: string;
-  activeDate: Date | null;
-  selectedSeries: ComparisonProjectedSeries | null;
-  selectedPoint: ComparisonProjectedPoint | null;
-  crosshairValue: number | null;
-  cursorColumn: number | null;
-  cursorRow: number | null;
-  axisFractionDigits: number | null;
-  priceRange: number | null;
-}
-
-function formatPercentAxisValue(value: number): string {
-  const abs = Math.abs(value);
-  const decimals = abs >= 100 ? 0 : abs >= 10 ? 1 : 2;
-  const prefix = value > 0 ? "+" : "";
-  return `${prefix}${value.toFixed(decimals)}%`;
-}
-
-function getComparisonAxisFractionDigitFloor(priceRange: number | undefined): number {
-  if (priceRange === undefined || !Number.isFinite(priceRange) || priceRange <= 0) return 0;
-  const visibleStep = priceRange / 3;
-  if (!Number.isFinite(visibleStep) || visibleStep <= 0) return 0;
-  return Math.max(0, Math.ceil(-Math.log10(visibleStep)) + 1);
-}
-
-export function formatComparisonAxisValue(
-  value: number,
-  axisMode: ChartAxisMode,
-  priceRange?: number,
-  fixedFractionDigits?: number,
-): string {
-  return axisMode === "percent"
-    ? formatPercentAxisValue(value)
-    : formatPrice(value, undefined, priceRange, 0, 0, fixedFractionDigits);
-}
-
-export function formatComparisonCursorAxisValue(
-  value: number,
-  axisMode: ChartAxisMode,
-  priceRange?: number,
-): string {
-  return axisMode === "percent"
-    ? formatPercentAxisValue(value)
-    : formatPrice(value, undefined, priceRange, 2, Math.abs(value) >= 1 ? 2 : 4);
-}
-
-function fillColumn(
-  buf: ReturnType<typeof createPixelBuffer>,
-  x: number,
-  y0: number,
-  y1: number,
-  color: string,
-  layer: number,
-) {
-  drawLine(buf, x, Math.min(y0, y1), x, Math.max(y0, y1), color, layer);
-}
-
-function drawComparisonLineSeries(
-  buf: ReturnType<typeof createPixelBuffer>,
-  points: ComparisonProjectedPoint[],
-  chartTop: number,
-  chartBottom: number,
-  color: string,
-  min: number,
-  max: number,
-) {
-  let previousIndex: number | null = null;
-  let previousY: number | null = null;
-  let previousX: number | null = null;
-
-  for (let index = 0; index < points.length; index += 1) {
-    const value = points[index]!.value;
-    if (value === null) {
-      previousIndex = null;
-      previousY = null;
-      previousX = null;
-      continue;
-    }
-
-    const x = getComparisonDotX(index, points.length, buf.width);
-    const y = getScaledComparisonY(value, min, max, chartTop, chartBottom);
-
-    if (previousIndex !== null && previousY !== null && previousX !== null) {
-      drawLine(buf, previousX, previousY, x, y, color, LAYER_DATA);
-    } else {
-      drawLine(buf, x, y, x, y, color, LAYER_DATA);
-    }
-
-    previousIndex = index;
-    previousY = y;
-    previousX = x;
-  }
-}
-
-function drawComparisonAreaSeries(
-  buf: ReturnType<typeof createPixelBuffer>,
-  points: ComparisonProjectedPoint[],
-  chartTop: number,
-  chartBottom: number,
-  lineColor: string,
-  fillColor: string,
-  min: number,
-  max: number,
-) {
-  let previousY: number | null = null;
-  let previousX: number | null = null;
-
-  for (let index = 0; index < points.length; index += 1) {
-    const value = points[index]!.value;
-    if (value === null) {
-      previousY = null;
-      previousX = null;
-      continue;
-    }
-
-    const x = getComparisonDotX(index, points.length, buf.width);
-    const y = getScaledComparisonY(value, min, max, chartTop, chartBottom);
-    fillColumn(buf, x, y + 1, chartBottom, fillColor, LAYER_FILL);
-
-    if (previousY !== null && previousX !== null) {
-      const left = Math.min(previousX, x);
-      const right = Math.max(previousX, x);
-      for (let column = left; column <= right; column += 1) {
-        if (column === previousX || column === x) continue;
-        const t = x === previousX ? 0 : (column - previousX) / (x - previousX);
-        const interpolatedY = Math.round(previousY + t * (y - previousY));
-        fillColumn(buf, column, interpolatedY + 1, chartBottom, fillColor, LAYER_FILL);
-      }
-      drawLine(buf, previousX, previousY, x, y, lineColor, LAYER_DATA);
-    } else {
-      drawLine(buf, x, y, x, y, lineColor, LAYER_DATA);
-    }
-
-    previousY = y;
-    previousX = x;
-  }
-}
-
-function drawSessionBackgrounds(
-  buf: ReturnType<typeof createPixelBuffer>,
-  spans: readonly ChartSessionBackgroundSpan[],
-  pointCount: number,
-  yTop: number,
-  yBottom: number,
-  colors: ComparisonChartColors,
-) {
-  if (spans.length === 0 || pointCount === 0) return;
-  for (const span of spans) {
-    const startIndex = Math.max(Math.min(span.startIndex, pointCount - 1), 0);
-    const endIndex = Math.max(Math.min(span.endIndex, pointCount - 1), startIndex);
-    const startBand = getComparisonPointBand(startIndex, pointCount, buf.width);
-    const endBand = getComparisonPointBand(endIndex, pointCount, buf.width);
-    const color = span.kind === "pre" ? colors.preMarketBgColor : colors.postMarketBgColor;
-    for (let y = Math.max(yTop, 0); y <= Math.min(yBottom, Math.max(buf.height - 1, 0)); y += 1) {
-      for (let x = Math.max(startBand.left, 0); x <= Math.min(endBand.right, Math.max(buf.width - 1, 0)); x += 1) {
-        buf.backgrounds[y]![x] = color;
-      }
-    }
-  }
-}
-
-export function renderComparisonChart(
-  projection: ComparisonChartProjection,
-  opts: RenderComparisonChartOptions,
-): RenderComparisonChartResult {
-  const scene = buildComparisonChartScene(projection, opts);
-  if (!scene) {
-    return {
-      lines: [],
-      axisLabels: [],
-      timeLabels: "",
-      activeDate: null,
-      selectedSeries: null,
-      selectedPoint: null,
-      crosshairValue: null,
-      cursorColumn: null,
-      cursorRow: null,
-      axisFractionDigits: null,
-      priceRange: null,
-    };
-  }
-
-  const dotWidth = scene.width * 2;
-  const chartDotBottom = scene.chartRows * 4 - 1;
-  const priceRange = scene.max - scene.min;
-  const buf = createPixelBuffer(dotWidth, scene.height * 4);
-  const gridLines = computeGridLines(scene.min, scene.max, 0, chartDotBottom, 3);
-  const axisFractionDigits = scene.axisMode === "price"
-    ? resolveAxisFractionDigits(
-      gridLines.map((line) => line.price),
-      (price, fixedFractionDigits) => formatComparisonAxisValue(price, scene.axisMode, priceRange, fixedFractionDigits),
-      getComparisonAxisFractionDigitFloor(priceRange),
-    )
-    : null;
-  drawSessionBackgrounds(
-    buf,
-    scene.sessionBackgroundSpans,
-    scene.dates.length,
-    0,
-    chartDotBottom,
-    scene.colors,
-  );
-  drawGridLines(buf, gridLines.map((line) => line.y), scene.colors.gridColor);
-
-  const selectedSeries = getSelectedComparisonSeries(scene.series, scene.selectedSymbol);
-  const orderedSeries = [
-    ...scene.series.filter((entry) => entry.symbol !== selectedSeries?.symbol),
-    ...(selectedSeries ? [selectedSeries] : []),
-  ];
-
-  for (const series of orderedSeries) {
-    if (scene.mode === "area") {
-      drawComparisonAreaSeries(buf, series.points, 0, chartDotBottom, series.color, series.fillColor, scene.min, scene.max);
-    } else {
-      drawComparisonLineSeries(buf, series.points, 0, chartDotBottom, series.color, scene.min, scene.max);
-    }
-  }
-
-  if (scene.cursorDotX !== null) {
-    drawCrosshair(buf, scene.cursorDotX, 0, chartDotBottom, scene.colors.crosshairColor);
-  }
-
-  const axisLabelsByRow = new Map<number, string>();
-  for (const line of gridLines) {
-    axisLabelsByRow.set(
-      Math.min(Math.floor(line.y / 4), Math.max(scene.chartRows - 1, 0)),
-      formatComparisonAxisValue(line.price, scene.axisMode, priceRange, axisFractionDigits ?? undefined),
-    );
-  }
-
-  return {
-    lines: bufferToBrailleLines(buf),
-    axisLabels: [...axisLabelsByRow.entries()].map(([row, label]) => ({ row, label })),
-    timeLabels: scene.timeLabels,
-    activeDate: scene.activeDate,
-    selectedSeries: scene.selectedSeries,
-    selectedPoint: scene.selectedPoint,
-    crosshairValue: scene.crosshairValue,
-    cursorColumn: scene.cursorColumn,
-    cursorRow: scene.cursorRow,
-    axisFractionDigits,
-    priceRange,
-  };
-}

package/src/components/chart/comparison/scene.ts

@@ -1,178 +0,0 @@
-import type {
-  ComparisonChartProjection,
-  ComparisonProjectedPoint,
-  ComparisonProjectedSeries,
-} from "./data";
-import { buildTimeAxis } from "../core/time-axis";
-import type {
-  ChartAxisMode,
-  ChartColors,
-  ChartMarketSession,
-  ChartSessionBackgroundSpan,
-  ComparisonChartRenderMode,
-} from "../core/types";
-import { normalizeCount } from "../core/render-utils";
-import { resolveExtendedHoursBackgroundSpans } from "../market-session";
-
-export type ComparisonChartColors = Pick<ChartColors, "bgColor" | "gridColor" | "crosshairColor" | "preMarketBgColor" | "postMarketBgColor">;
-
-export interface ComparisonChartScene {
-  dates: Date[];
-  series: ComparisonProjectedSeries[];
-  width: number;
-  height: number;
-  chartRows: number;
-  mode: ComparisonChartRenderMode;
-  axisMode: ChartAxisMode;
-  selectedSymbol: string | null;
-  colors: ComparisonChartColors;
-  sessionBackgroundSpans: ChartSessionBackgroundSpan[];
-  min: number;
-  max: number;
-  activeIdx: number;
-  activeDate: Date;
-  selectedSeries: ComparisonProjectedSeries | null;
-  selectedPoint: ComparisonProjectedPoint | null;
-  crosshairValue: number | null;
-  timeLabels: string;
-  cursorX: number | null;
-  cursorY: number | null;
-  cursorColumn: number | null;
-  cursorRow: number | null;
-  cursorDotX: number | null;
-}
-
-export interface RenderComparisonChartOptions {
-  width: number;
-  height: number;
-  cursorX: number | null;
-  cursorY: number | null;
-  selectedSymbol: string | null;
-  colors: ComparisonChartColors;
-  marketSession?: ChartMarketSession | null;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-export function getComparisonDotX(index: number, count: number, width: number): number {
-  if (count <= 1) return Math.round(Math.max(width - 1, 0) / 2);
-  return Math.round((index / (count - 1)) * Math.max(width - 1, 0));
-}
-
-export function getComparisonPointBand(index: number, pointCount: number, width: number): { left: number; right: number } {
-  const currentX = getComparisonDotX(index, pointCount, width);
-  const previousX = index > 0 ? getComparisonDotX(index - 1, pointCount, width) : currentX;
-  const nextX = index < pointCount - 1 ? getComparisonDotX(index + 1, pointCount, width) : currentX;
-  return {
-    left: index === 0 ? 0 : Math.floor((previousX + currentX) / 2) + 1,
-    right: index === pointCount - 1 ? Math.max(width - 1, 0) : Math.floor((currentX + nextX) / 2),
-  };
-}
-
-export function getScaledComparisonY(value: number, min: number, max: number, chartTop: number, chartBottom: number): number {
-  const range = max - min || 1;
-  const chartHeight = chartBottom - chartTop;
-  return chartTop + Math.round((1 - (value - min) / range) * chartHeight);
-}
-
-function getActiveIndex(pointCount: number, width: number, cursorX: number | null): number {
-  if (pointCount <= 0) return 0;
-  if (cursorX === null || cursorX < 0 || cursorX >= width) {
-    return pointCount - 1;
-  }
-
-  let bestIndex = pointCount - 1;
-  let bestDistance = Number.POSITIVE_INFINITY;
-
-  for (let index = 0; index < pointCount; index += 1) {
-    const pointColumn = Math.min(Math.max(Math.floor(getComparisonDotX(index, pointCount, width * 2) / 2), 0), width - 1);
-    const distance = Math.abs(pointColumn - cursorX);
-    if (distance <= bestDistance) {
-      bestDistance = distance;
-      bestIndex = index;
-    }
-  }
-
-  return bestIndex;
-}
-
-export function getSelectedComparisonSeries(series: ComparisonProjectedSeries[], selectedSymbol: string | null): ComparisonProjectedSeries | null {
-  if (series.length === 0) return null;
-  if (!selectedSymbol) return series[0] ?? null;
-  return series.find((entry) => entry.symbol === selectedSymbol) ?? series[0] ?? null;
-}
-
-export function buildComparisonChartScene(
-  projection: ComparisonChartProjection,
-  opts: RenderComparisonChartOptions,
-): ComparisonChartScene | null {
-  if (projection.dates.length === 0 || projection.series.length === 0) {
-    return null;
-  }
-
-  const values = projection.series.flatMap((entry) => entry.points.map((point) => point.value).filter((value): value is number => value !== null));
-  if (values.length === 0) {
-    return null;
-  }
-
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  const width = normalizeCount(opts.width, 1);
-  const height = normalizeCount(opts.height, 1);
-  const selectedSeries = getSelectedComparisonSeries(projection.series, opts.selectedSymbol);
-  const activeIdx = getActiveIndex(projection.dates.length, width, opts.cursorX);
-  const activeDate = projection.dates[activeIdx] ?? projection.dates[projection.dates.length - 1]!;
-  const selectedPoint = selectedSeries?.points[activeIdx] ?? null;
-  const chartRows = height;
-  const range = max - min || 1;
-  const cursorX = opts.cursorX === null
-    ? null
-    : clamp(opts.cursorX, 0, Math.max(width - 1, 0));
-  const fallbackValue = selectedPoint?.value ?? selectedSeries?.latestValue ?? min;
-  const cursorY = cursorX === null
-    ? null
-    : opts.cursorY !== null
-      ? clamp(opts.cursorY, 0, Math.max(chartRows - 1, 0))
-      : clamp(
-        Math.round((1 - ((fallbackValue ?? min) - min) / range) * Math.max(chartRows - 1, 0)),
-        0,
-        Math.max(chartRows - 1, 0),
-      );
-  const cursorColumn = cursorX === null ? null : Math.round(cursorX);
-  const cursorDotX = cursorX === null
-    ? null
-    : Math.round((cursorX / Math.max(width - 1, 1)) * Math.max(width * 2 - 1, 0));
-  const cursorRow = cursorY === null ? null : Math.round(cursorY);
-  const crosshairValue = cursorY === null
-    ? null
-    : max - (cursorY / Math.max(chartRows - 1, 1)) * range;
-  const sessionBackgroundSpans = resolveExtendedHoursBackgroundSpans(projection.dates, opts.marketSession);
-
-  return {
-    dates: projection.dates,
-    series: projection.series,
-    width,
-    height,
-    chartRows,
-    mode: projection.effectiveMode,
-    axisMode: projection.effectiveAxisMode,
-    selectedSymbol: selectedSeries?.symbol ?? null,
-    colors: opts.colors,
-    sessionBackgroundSpans,
-    min,
-    max,
-    activeIdx,
-    activeDate,
-    selectedSeries,
-    selectedPoint,
-    crosshairValue,
-    timeLabels: buildTimeAxis(projection.dates, opts.width),
-    cursorX,
-    cursorY,
-    cursorColumn,
-    cursorRow,
-    cursorDotX,
-  };
-}

package/src/components/chart/comparison-stock-chart/axis-width.ts

@@ -1,99 +0,0 @@
-import {
-  projectComparisonChartData,
-} from "../comparison/data";
-import {
-  buildComparisonChartScene,
-  formatComparisonCursorAxisValue,
-  renderComparisonChart,
-} from "../comparison/renderer";
-import { resolveIterativeChartAxisWidth } from "../core/axis-measure";
-import type {
-  ChartAxisMode,
-  ComparisonChartSeries,
-  ComparisonChartViewState,
-} from "../core/types";
-
-interface ComparisonChartColors {
-  bgColor: string;
-  gridColor: string;
-  crosshairColor: string;
-  preMarketBgColor: string;
-  postMarketBgColor: string;
-}
-
-export interface ResolveComparisonChartAxisWidthOptions {
-  axisGap: number;
-  axisMode: ChartAxisMode;
-  axisRightPadding: number;
-  axisSectionWidthBudget: number;
-  chartColors: ComparisonChartColors;
-  chartHeight: number;
-  measurementChartWidth: number;
-  minChartWidth: number;
-  minimumAxisWidth: number;
-  selectedSymbol: string | null;
-  series: ComparisonChartSeries[];
-  viewState: Pick<ComparisonChartViewState, "dateWindow" | "panOffset" | "renderMode" | "zoomLevel">;
-  width: number;
-}
-
-export function resolveComparisonChartAxisWidth({
-  axisGap,
-  axisMode,
-  axisRightPadding,
-  axisSectionWidthBudget,
-  chartColors,
-  chartHeight,
-  measurementChartWidth,
-  minChartWidth,
-  minimumAxisWidth,
-  selectedSymbol,
-  series,
-  viewState,
-  width,
-}: ResolveComparisonChartAxisWidthOptions): number {
-  return resolveIterativeChartAxisWidth({
-    axisGap,
-    axisRightPadding,
-    axisSectionWidthBudget,
-    measurementChartWidth,
-    minChartWidth,
-    minimumAxisWidth,
-    width,
-    measureLabels: (targetWidth) => {
-      const measuredProjection = projectComparisonChartData(series, targetWidth, viewState, axisMode);
-      const measuredResult = renderComparisonChart(measuredProjection, {
-        width: targetWidth,
-        height: chartHeight,
-        cursorX: null,
-        cursorY: null,
-        selectedSymbol,
-        colors: chartColors,
-      });
-      const measuredScene = buildComparisonChartScene(measuredProjection, {
-        width: targetWidth,
-        height: chartHeight,
-        cursorX: null,
-        cursorY: null,
-        selectedSymbol,
-        colors: chartColors,
-      });
-      const cursorSamples = measuredScene
-        ? [
-          formatComparisonCursorAxisValue(
-            measuredScene.min,
-            measuredProjection.effectiveAxisMode,
-            measuredResult.priceRange ?? undefined,
-          ),
-          formatComparisonCursorAxisValue(
-            measuredScene.max,
-            measuredProjection.effectiveAxisMode,
-            measuredResult.priceRange ?? undefined,
-          ),
-        ]
-        : [];
-
-      return [...measuredResult.axisLabels.map((entry) => entry.label), ...cursorSamples];
-    },
-  });
-}

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

@@ -1,148 +0,0 @@
-import { useMemo, type RefObject } from "react";
-import type { BoxRenderable, NativeRendererHost } from "../../../ui";
-import type {
-  ChartAxisMode,
-  ChartMarketSession,
-  ComparisonChartSeries,
-  ComparisonChartViewState,
-} from "../core/types";
-import {
-  renderNativeComparisonChartBase,
-  type NativeCrosshairOverlay,
-} from "../native/chart-rasterizer";
-import { resolveCanvasBitmapSize, useNativeCanvasBitmaps } from "../native/canvas-bitmaps";
-import {
-  buildComparisonChartScene,
-} from "../comparison/renderer";
-import {
-  projectComparisonChartData,
-} from "../comparison/data";
-import { buildComparisonNativeBitmapKey } from "./helpers";
-import type { ComparisonChartColors } from "./types";
-
-export function useComparisonChartCanvasBitmaps({
-  axisMode,
-  bodyMessage,
-  canvasCharts,
-  cellHeightPx,
-  cellWidthPx,
-  chartColors,
-  chartHeight,
-  chartWidth,
-  hasChartData,
-  isBlockingBody,
-  marketSession,
-  marketSessionKey,
-  nativeCrosshair,
-  pixelRatio,
-  plotRef,
-  projectionViewState,
-  renderer,
-  selectedSymbol,
-  series,
-  symbolCount,
-}: {
-  axisMode: ChartAxisMode;
-  bodyMessage: string | null;
-  canvasCharts: boolean;
-  cellHeightPx: number;
-  cellWidthPx: number;
-  chartColors: ComparisonChartColors;
-  chartHeight: number;
-  chartWidth: number;
-  hasChartData: boolean;
-  isBlockingBody: boolean;
-  marketSession: ChartMarketSession | null;
-  marketSessionKey: string;
-  nativeCrosshair: NativeCrosshairOverlay | null;
-  pixelRatio: number;
-  plotRef: RefObject<BoxRenderable | null>;
-  projectionViewState: Pick<ComparisonChartViewState, "dateWindow" | "panOffset" | "renderMode" | "zoomLevel">;
-  renderer: NativeRendererHost;
-  selectedSymbol: string | null;
-  series: ComparisonChartSeries[];
-  symbolCount: number;
-}) {
-  const canvasBitmapSize = useMemo(() => resolveCanvasBitmapSize({
-    enabled: canvasCharts,
-    cellHeightPx,
-    cellWidthPx,
-    chartHeight,
-    chartWidth,
-    pixelRatio,
-  }), [canvasCharts, cellHeightPx, cellWidthPx, chartHeight, chartWidth, pixelRatio]);
-
-  const canvasProjection = useMemo(() => (
-    canvasBitmapSize
-      ? projectComparisonChartData(
-        series,
-        Math.max(chartWidth, canvasBitmapSize.pixelWidth),
-        projectionViewState,
-        axisMode,
-      )
-      : null
-  ), [axisMode, canvasBitmapSize, chartWidth, projectionViewState, series]);
-
-  const canvasBaseScene = useMemo(() => (
-    canvasProjection
-      ? buildComparisonChartScene(canvasProjection, {
-        width: Math.max(chartWidth, canvasBitmapSize?.pixelWidth ?? chartWidth),
-        height: chartHeight,
-        cursorX: null,
-        cursorY: null,
-        selectedSymbol,
-        colors: chartColors,
-        marketSession,
-      })
-      : null
-  ), [canvasBitmapSize?.pixelWidth, canvasProjection, chartColors, chartHeight, chartWidth, marketSession, selectedSymbol]);
-
-  const canvasBaseBitmapKey = useMemo(() => {
-    if (!canvasBitmapSize || !canvasProjection || !hasChartData || isBlockingBody || bodyMessage) return null;
-    return buildComparisonNativeBitmapKey(
-      symbolCount,
-      canvasProjection,
-      selectedSymbol,
-      canvasBitmapSize.pixelWidth,
-      canvasBitmapSize.pixelHeight,
-      [
-        chartColors.bgColor,
-        chartColors.gridColor,
-        chartColors.crosshairColor,
-        chartColors.preMarketBgColor,
-        chartColors.postMarketBgColor,
-      ].join(","),
-      marketSessionKey,
-    );
-  }, [
-    bodyMessage,
-    canvasBitmapSize,
-    canvasProjection,
-    chartColors.bgColor,
-    chartColors.crosshairColor,
-    chartColors.gridColor,
-    chartColors.postMarketBgColor,
-    chartColors.preMarketBgColor,
-    hasChartData,
-    isBlockingBody,
-    marketSessionKey,
-    selectedSymbol,
-    symbolCount,
-  ]);
-
-  const { canvasCrosshair, plotBitmaps } = useNativeCanvasBitmaps({
-    bitmapKey: canvasBaseBitmapKey,
-    bitmapSize: canvasBitmapSize,
-    nativeCrosshair,
-    plotRef,
-    renderBase: renderNativeComparisonChartBase,
-    renderer,
-    scene: canvasBaseScene,
-  });
-
-  return {
-    canvasBaseBitmapKey,
-    canvasCrosshair,
-    plotBitmaps,
-  };
-}