gloomberb 0.9.9 → 0.10.0

package/src/components/chart/stock-chart/viewport/index.ts

@@ -1,144 +0,0 @@
-import type { PricePoint } from "../../../../types/financials";
-import {
-  applyDateWindowViewport,
-  applyPresetDateWindowViewport,
-  clearActivePreset,
-  resolvePresetSelection,
-  resolveResolutionSelection,
-  resolveStoredChartSelection,
-  zoomDateWindow,
-  type DateWindowRange,
-} from "../../core/controller";
-import type { ManualChartResolution } from "../../core/resolution";
-import { getVisiblePointCount } from "../../core/viewport";
-import type {
-  ChartResolution,
-  ChartViewState,
-  TimeRange,
-} from "../../core/types";
-
-export type StockChartViewportState = Omit<ChartViewState, "resolution">;
-type ResolutionAwareViewportState = StockChartViewportState & { resolution: ChartResolution };
-
-export type PendingExpansionAction =
-  | { kind: "zoom-out"; targetVisibleCount: number; anchorRatio: number }
-  | { kind: "pan-left"; targetPanOffset: number }
-  | null;
-
-export function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-export function getMaxPanOffset(history: PricePoint[], zoomLevel: number): number {
-  const visibleCount = getVisiblePointCount(history.length, zoomLevel);
-  return Math.max(history.length - visibleCount, 0);
-}
-
-function attachViewportResolution(
-  view: StockChartViewportState,
-  resolution: ChartResolution,
-): ResolutionAwareViewportState {
-  return {
-    ...view,
-    resolution,
-  };
-}
-
-function stripViewportResolution(view: ResolutionAwareViewportState): StockChartViewportState {
-  const { resolution: _resolution, ...viewport } = view;
-  return viewport;
-}
-
-export function resolveViewportPresetSelection(
-  view: StockChartViewportState,
-  presetRange: TimeRange,
-  supportMaxRange: TimeRange | null = null,
-  dates: readonly Date[] = [],
-): StockChartViewportState {
-  return stripViewportResolution(
-    applyPresetDateWindowViewport(
-      resolvePresetSelection(attachViewportResolution(view, "auto"), presetRange, supportMaxRange),
-      dates,
-      presetRange,
-      { clearCursor: true },
-    ),
-  );
-}
-
-export function resolveViewportResolutionSelection(
-  view: StockChartViewportState,
-  resolution: ChartResolution,
-  support: ReadonlyMap<ManualChartResolution, TimeRange>,
-  visibleWindow: DateWindowRange | null,
-  dates: readonly Date[] = [],
-): StockChartViewportState | null {
-  const nextView = resolveResolutionSelection(
-    attachViewportResolution(view, resolution),
-    resolution,
-    support,
-    visibleWindow,
-  );
-  if (!nextView) return null;
-  if (resolution === "auto") return stripViewportResolution(nextView);
-  const nextWindow = nextView.activePreset
-    ? applyPresetDateWindowViewport(nextView, dates, nextView.presetRange, { clearCursor: true })
-    : applyDateWindowViewport(nextView, dates, nextView.dateWindow ?? visibleWindow, {
-      activePreset: null,
-      clearCursor: true,
-    });
-  return stripViewportResolution(nextWindow);
-}
-
-export function resolveViewportStoredSelection(
-  view: StockChartViewportState,
-  presetRange: TimeRange,
-  resolution: ChartResolution,
-  support: ReadonlyMap<ManualChartResolution, TimeRange>,
-  dates: readonly Date[] = [],
-): StockChartViewportState {
-  const nextView = resolveStoredChartSelection(attachViewportResolution(view, resolution), presetRange, resolution, support);
-  if (nextView.resolution === "auto" || !nextView.activePreset) {
-    return stripViewportResolution(nextView);
-  }
-  return stripViewportResolution(
-    applyPresetDateWindowViewport(nextView, dates, nextView.presetRange, { clearCursor: true }),
-  );
-}
-
-export function clearAutoViewportState(view: StockChartViewportState): StockChartViewportState {
-  const clearedPreset = clearActivePreset(view);
-  if (clearedPreset.dateWindow === null && clearedPreset.panOffset === 0 && clearedPreset.zoomLevel === 1) {
-    return clearedPreset;
-  }
-  return {
-    ...clearedPreset,
-    dateWindow: null,
-    panOffset: 0,
-    zoomLevel: 1,
-  };
-}
-
-export function applyZoomStepAroundAnchor(
-  view: StockChartViewportState,
-  zoomFactor: number,
-  anchorRatio: number,
-  dates: readonly Date[],
-  displayedDateWindow?: DateWindowRange | null,
-  bounds?: DateWindowRange | null,
-  minimumSpanMs?: number,
-): StockChartViewportState {
-  if (!Number.isFinite(zoomFactor) || zoomFactor <= 0) return view;
-  const currentWindow = displayedDateWindow?.start && displayedDateWindow.end
-    ? displayedDateWindow
-    : view.dateWindow;
-  return applyDateWindowViewport(
-    clearActivePreset(view),
-    dates,
-    zoomDateWindow(currentWindow, zoomFactor, anchorRatio),
-    {
-      activePreset: null,
-      bounds,
-      minimumSpanMs,
-    },
-  );
-}

package/src/components/chart/stock-chart/viewport/runtime.ts

@@ -1,375 +0,0 @@
-import { useCallback, useRef, type Dispatch, type MutableRefObject, type SetStateAction } from "react";
-import { applyBufferedPanExpansion } from "../../core/scroll";
-import {
-  createStoredChartSelectionSyncState,
-  markStoredChartSelectionLocallyApplied,
-} from "../../core/pane-settings";
-import {
-  clampDateWindowToBounds,
-  resolveVisibleActivePreset,
-  sameDateWindow,
-  type DateWindowRange,
-} from "../../core/controller";
-import {
-  getExpandedBufferRange,
-  getNextBufferRange,
-  getPresetResolution,
-  getSupportMaxRange,
-  isRangePresetSupported,
-  type ChartResolutionSupport,
-  type ManualChartResolution,
-} from "../../core/resolution";
-import {
-  EMPTY_DISPLAY_CURSOR,
-  type DisplayCursorState,
-} from "../../core/pointer";
-import type {
-  ChartRenderMode,
-  ChartResolution,
-  TimeRange,
-} from "../../core/types";
-import type { ChartCursorMotionKind } from "../../cursor-motion";
-import type { AutoRenderedView } from "../auto";
-import {
-  clearAutoViewportState,
-  resolveViewportPresetSelection,
-  resolveViewportResolutionSelection,
-  type PendingExpansionAction,
-  type StockChartViewportState,
-} from "./index";
-import {
-  useAutoWindowOverrideSync,
-  useInteractiveCursorSync,
-  useManualViewportReconcile,
-  useStoredRenderModeSync,
-  useStoredViewportSelectionSync,
-} from "./effects";
-
-interface UseStockChartViewportRuntimeOptions {
-  availableManualResolutions: readonly ChartResolution[];
-  autoMinimumSpanMs: number;
-  baseDateBounds: DateWindowRange | null;
-  boundsHistoryDates: Date[];
-  canonicalAutoWindow: DateWindowRange | null;
-  chartWidth: number;
-  compact?: boolean;
-  cursorMotionKindRef: MutableRefObject<ChartCursorMotionKind>;
-  displayedDateWindow: DateWindowRange | null;
-  effectiveResolution: ChartResolution;
-  effectiveResolutionSupport: readonly ChartResolutionSupport[];
-  interactive?: boolean;
-  manualVisibleDateWindow: DateWindowRange;
-  navigableDateWindow: DateWindowRange | null;
-  pendingAutoWindowOverride: DateWindowRange | null;
-  pendingAutoWindowRef: MutableRefObject<DateWindowRange | null>;
-  pendingCanonicalResetRef: MutableRefObject<number>;
-  pendingExpansionRef: MutableRefObject<PendingExpansionAction>;
-  persistChartControls: (range: TimeRange, resolution: ChartResolution) => void;
-  renderedResolution: ChartResolution;
-  selectionSupportMap: ReadonlyMap<ManualChartResolution, TimeRange>;
-  persistChartRenderMode: (mode: ChartRenderMode) => void;
-  setPendingAutoWindowOverride: Dispatch<SetStateAction<DateWindowRange | null>>;
-  setRenderedAutoView: Dispatch<SetStateAction<AutoRenderedView | null>>;
-  setRequestedResolution: Dispatch<SetStateAction<ChartResolution>>;
-  setViewState: Dispatch<SetStateAction<StockChartViewportState>>;
-  storedRangePreset: TimeRange;
-  storedRenderMode: ChartRenderMode;
-  storedResolution: ChartResolution;
-  supportMap: ReadonlyMap<ManualChartResolution, TimeRange>;
-  updateDisplayCursorTarget: (next: DisplayCursorState, motionKind: ChartCursorMotionKind) => void;
-  viewState: StockChartViewportState;
-  visibleDateWindow: DateWindowRange | null;
-}
-
-export function useStockChartViewportRuntime({
-  availableManualResolutions,
-  autoMinimumSpanMs,
-  baseDateBounds,
-  boundsHistoryDates,
-  canonicalAutoWindow,
-  chartWidth,
-  compact,
-  cursorMotionKindRef,
-  displayedDateWindow,
-  effectiveResolution,
-  effectiveResolutionSupport,
-  interactive,
-  manualVisibleDateWindow,
-  navigableDateWindow,
-  pendingAutoWindowOverride,
-  pendingAutoWindowRef,
-  pendingCanonicalResetRef,
-  pendingExpansionRef,
-  persistChartControls,
-  persistChartRenderMode,
-  renderedResolution,
-  selectionSupportMap,
-  setPendingAutoWindowOverride,
-  setRenderedAutoView,
-  setRequestedResolution,
-  setViewState,
-  storedRangePreset,
-  storedRenderMode,
-  storedResolution,
-  supportMap,
-  updateDisplayCursorTarget,
-  viewState,
-  visibleDateWindow,
-}: UseStockChartViewportRuntimeOptions) {
-  const storedSelectionSyncStateRef = useRef(
-    createStoredChartSelectionSyncState(storedRangePreset, storedResolution),
-  );
-
-  useStoredViewportSelectionSync({
-    boundsHistoryDates,
-    compact,
-    pendingAutoWindowRef,
-    pendingCanonicalResetRef,
-    selectionSupportMap,
-    setPendingAutoWindowOverride,
-    setRenderedAutoView,
-    setRequestedResolution,
-    setViewState,
-    storedRangePreset,
-    storedResolution,
-    storedSelectionSyncStateRef,
-    updateDisplayCursorTarget,
-  });
-
-  useStoredRenderModeSync({
-    compact,
-    setViewState,
-    storedRenderMode,
-  });
-
-  useManualViewportReconcile({
-    boundsHistoryDates,
-    compact,
-    effectiveResolution,
-    pendingCanonicalResetRef,
-    pendingExpansionRef,
-    setViewState,
-    viewState,
-  });
-
-  useAutoWindowOverrideSync({
-    autoMinimumSpanMs,
-    baseDateBounds,
-    canonicalAutoWindow,
-    compact,
-    effectiveResolution,
-    pendingAutoWindowOverride,
-    pendingAutoWindowRef,
-    setPendingAutoWindowOverride,
-  });
-
-  useInteractiveCursorSync({
-    chartWidth,
-    cursorMotionKindRef,
-    interactive,
-    setViewState,
-    updateDisplayCursorTarget,
-  });
-
-  const persistRenderMode = useCallback((nextMode: ChartRenderMode) => {
-    if (!compact) {
-      persistChartRenderMode(nextMode);
-    }
-  }, [compact, persistChartRenderMode]);
-
-  const expandBufferRange = useCallback((action: PendingExpansionAction): boolean => {
-    if (compact) return false;
-    const expansionResolution = effectiveResolution === "auto" ? "auto" : renderedResolution;
-    const nextBufferRange = getExpandedBufferRange(viewState.bufferRange, expansionResolution, supportMap);
-    if (!nextBufferRange) return false;
-    pendingExpansionRef.current = action;
-    setViewState((current) => applyBufferedPanExpansion(current, nextBufferRange));
-    return true;
-  }, [
-    compact,
-    effectiveResolution,
-    pendingExpansionRef,
-    renderedResolution,
-    setViewState,
-    supportMap,
-    viewState.bufferRange,
-  ]);
-
-  const requestAutoWindow = useCallback((nextWindow: DateWindowRange | null | undefined): boolean => {
-    if (compact || effectiveResolution !== "auto" || !nextWindow?.start || !nextWindow.end || !baseDateBounds?.start || !baseDateBounds.end) {
-      return false;
-    }
-
-    if (nextWindow.start.getTime() < baseDateBounds.start.getTime()) {
-      const nextBufferRange = getNextBufferRange(viewState.bufferRange);
-      if (nextBufferRange !== viewState.bufferRange) {
-        pendingAutoWindowRef.current = nextWindow;
-        setViewState((current) => {
-          const nextState = clearAutoViewportState(current);
-          return nextState.bufferRange === nextBufferRange
-            ? nextState
-            : { ...nextState, bufferRange: nextBufferRange };
-        });
-        return true;
-      }
-    }
-
-    const clampedWindow = clampDateWindowToBounds(nextWindow, baseDateBounds, autoMinimumSpanMs);
-    if (!clampedWindow) {
-      return false;
-    }
-    const normalizedWindow = canonicalAutoWindow && sameDateWindow(clampedWindow, canonicalAutoWindow)
-      ? null
-      : clampedWindow;
-    if (sameDateWindow(navigableDateWindow, normalizedWindow)) {
-      return false;
-    }
-    pendingAutoWindowRef.current = null;
-    setPendingAutoWindowOverride((current) => (sameDateWindow(current, normalizedWindow) ? current : normalizedWindow));
-    setViewState((current) => clearAutoViewportState(current));
-    return true;
-  }, [
-    autoMinimumSpanMs,
-    baseDateBounds,
-    canonicalAutoWindow,
-    compact,
-    effectiveResolution,
-    navigableDateWindow,
-    pendingAutoWindowRef,
-    setPendingAutoWindowOverride,
-    setViewState,
-    viewState.bufferRange,
-  ]);
-
-  const setRange = useCallback((range: TimeRange) => {
-    if (!compact && !isRangePresetSupported(range, effectiveResolutionSupport)) return;
-    const supportMaxRange = getSupportMaxRange(effectiveResolutionSupport, getPresetResolution(range));
-    const nextResolution = getPresetResolution(range);
-    setRequestedResolution(nextResolution);
-    if (!compact) {
-      markStoredChartSelectionLocallyApplied(storedSelectionSyncStateRef.current, range, nextResolution);
-      persistChartControls(range, nextResolution);
-    }
-    pendingCanonicalResetRef.current += 1;
-    pendingAutoWindowRef.current = null;
-    setPendingAutoWindowOverride(null);
-    updateDisplayCursorTarget(EMPTY_DISPLAY_CURSOR, "discrete");
-    setViewState((current) => resolveViewportPresetSelection(current, range, supportMaxRange, boundsHistoryDates));
-  }, [
-    boundsHistoryDates,
-    compact,
-    effectiveResolutionSupport,
-    pendingAutoWindowRef,
-    pendingCanonicalResetRef,
-    persistChartControls,
-    setPendingAutoWindowOverride,
-    setRequestedResolution,
-    setViewState,
-    updateDisplayCursorTarget,
-  ]);
-
-  const setResolution = useCallback((resolution: ChartResolution) => {
-    if (compact) return;
-    if (resolution !== "auto" && !availableManualResolutions.includes(resolution)) return;
-
-    if (resolution === "auto") {
-      const preservedWindow = effectiveResolution === "auto" ? navigableDateWindow : manualVisibleDateWindow;
-      const nextAutoWindow = clampDateWindowToBounds(preservedWindow, baseDateBounds, autoMinimumSpanMs);
-      pendingAutoWindowRef.current = null;
-      setPendingAutoWindowOverride(
-        canonicalAutoWindow && nextAutoWindow && sameDateWindow(nextAutoWindow, canonicalAutoWindow)
-          ? null
-          : nextAutoWindow,
-      );
-      if (effectiveResolution !== "auto") {
-        setRenderedAutoView(null);
-      }
-      setRequestedResolution(resolution);
-      markStoredChartSelectionLocallyApplied(storedSelectionSyncStateRef.current, viewState.presetRange, resolution);
-      persistChartControls(viewState.presetRange, resolution);
-      updateDisplayCursorTarget(EMPTY_DISPLAY_CURSOR, "discrete");
-      setViewState((current) => ({
-        ...clearAutoViewportState(current),
-        bufferRange: getNextBufferRange(current.presetRange),
-      }));
-      return;
-    }
-
-    const nextState = resolveViewportResolutionSelection(
-      viewState,
-      resolution,
-      selectionSupportMap,
-      visibleDateWindow,
-      boundsHistoryDates,
-    );
-    if (!nextState) return;
-    setRequestedResolution(resolution);
-    pendingAutoWindowRef.current = null;
-    setPendingAutoWindowOverride(null);
-    pendingCanonicalResetRef.current += 1;
-    markStoredChartSelectionLocallyApplied(storedSelectionSyncStateRef.current, nextState.presetRange, resolution);
-    persistChartControls(nextState.presetRange, resolution);
-    updateDisplayCursorTarget(EMPTY_DISPLAY_CURSOR, "discrete");
-    setViewState(nextState);
-  }, [
-    autoMinimumSpanMs,
-    availableManualResolutions,
-    baseDateBounds,
-    canonicalAutoWindow,
-    compact,
-    effectiveResolution,
-    manualVisibleDateWindow,
-    navigableDateWindow,
-    pendingAutoWindowRef,
-    pendingCanonicalResetRef,
-    persistChartControls,
-    selectionSupportMap,
-    setPendingAutoWindowOverride,
-    setRenderedAutoView,
-    setRequestedResolution,
-    setViewState,
-    updateDisplayCursorTarget,
-    viewState,
-    visibleDateWindow,
-    boundsHistoryDates,
-  ]);
-
-  const setRenderMode = useCallback((mode: ChartRenderMode) => {
-    persistRenderMode(mode);
-    setViewState((current) => ({ ...current, renderMode: mode }));
-  }, [persistRenderMode, setViewState]);
-
-  const commitSelectionCursor = useCallback((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 }
-    ));
-  }, [setViewState]);
-
-  const activePreset = compact
-    ? null
-      : effectiveResolution === "auto"
-      ? (canonicalAutoWindow && displayedDateWindow && sameDateWindow(displayedDateWindow, canonicalAutoWindow)
-        ? viewState.presetRange
-        : null)
-      : resolveVisibleActivePreset(boundsHistoryDates, {
-        presetRange: viewState.presetRange,
-        activePreset: viewState.activePreset,
-        dateWindow: viewState.dateWindow,
-        panOffset: viewState.panOffset,
-        zoomLevel: viewState.zoomLevel,
-        resolution: effectiveResolution,
-      });
-
-  return {
-    activePreset,
-    commitSelectionCursor,
-    expandBufferRange,
-    persistRenderMode,
-    requestAutoWindow,
-    setRange,
-    setRenderMode,
-    setResolution,
-  };
-}

package/src/components/chart/time-axis-label.tsx

@@ -1,175 +0,0 @@
-import { useMemo } from "react";
-import { Box, Span, Text, useUiCapabilities } from "../../ui";
-import { colors } from "../../theme/colors";
-import { buildCursorTimeAxisSegments } from "./core/renderer";
-
-interface TimeAxisLabelProps {
-  timeLabels: string;
-  width: number;
-  cursorColumn: number | null;
-  cursorPixelX?: number | null;
-  cursorDate: Date | string | number | null;
-  dates: Array<Date | string | number>;
-  cursorColor: string;
-}
-
-interface CursorTimeAxisOverlay {
-  baseText: string;
-  label: string | null;
-  leftPercent: number | null;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-function normalizeDate(value: Date | string | number): Date | null {
-  const date = value instanceof Date ? value : new Date(value);
-  return Number.isFinite(date.getTime()) ? date : null;
-}
-
-export function resolveCursorDateFromAxis({
-  dates,
-  width,
-  cursorColumn,
-  cursorPixelX,
-  cellWidthPx,
-}: {
-  dates: Array<Date | string | number>;
-  width: number;
-  cursorColumn: number | null;
-  cursorPixelX?: number | null;
-  cellWidthPx?: number | null;
-}): Date | null {
-  const normalizedDates = dates
-    .map(normalizeDate)
-    .filter((date): date is Date => date !== null);
-  if (normalizedDates.length === 0) return null;
-  if (normalizedDates.length === 1) return normalizedDates[0]!;
-
-  let ratio: number | null = null;
-  if (
-    cursorPixelX !== null
-    && cursorPixelX !== undefined
-    && Number.isFinite(cursorPixelX)
-    && cellWidthPx !== null
-    && cellWidthPx !== undefined
-    && Number.isFinite(cellWidthPx)
-    && cellWidthPx > 0
-  ) {
-    const pixelWidth = Math.max(width * cellWidthPx, 1);
-    ratio = clamp(cursorPixelX / Math.max(pixelWidth - 1, 1), 0, 1);
-  } else if (cursorColumn !== null && Number.isFinite(cursorColumn) && width > 1) {
-    ratio = clamp(cursorColumn / Math.max(width - 1, 1), 0, 1);
-  }
-
-  if (ratio === null) return null;
-  const index = Math.round(ratio * (normalizedDates.length - 1));
-  return normalizedDates[clamp(index, 0, normalizedDates.length - 1)] ?? null;
-}
-
-export function buildCursorTimeAxisOverlay({
-  segments,
-  width,
-  cursorPixelX,
-  cellWidthPx,
-}: {
-  segments: ReturnType<typeof buildCursorTimeAxisSegments>;
-  width: number;
-  cursorPixelX: number | null | undefined;
-  cellWidthPx: number;
-}): CursorTimeAxisOverlay {
-  const baseText = segments
-    .map((segment) => (segment.highlighted ? " ".repeat(segment.text.length) : segment.text))
-    .join("")
-    .padEnd(width)
-    .slice(0, width);
-  const label = segments.find((segment) => segment.highlighted)?.text ?? null;
-  const pixelWidth = Math.max(width * cellWidthPx, 1);
-  let leftPercent: number | null = null;
-  if (label && cursorPixelX !== null && cursorPixelX !== undefined && Number.isFinite(cursorPixelX) && pixelWidth > 1) {
-    const halfLabelWidth = Math.min((label.length * cellWidthPx) / 2, (pixelWidth - 1) / 2);
-    const leftPx = clamp(cursorPixelX, halfLabelWidth, Math.max(pixelWidth - halfLabelWidth, halfLabelWidth));
-    leftPercent = (leftPx / Math.max(pixelWidth - 1, 1)) * 100;
-  }
-
-  return { baseText, label, leftPercent };
-}
-
-export function TimeAxisLabel({
-  timeLabels,
-  width,
-  cursorColumn,
-  cursorPixelX = null,
-  cursorDate,
-  dates,
-  cursorColor,
-}: TimeAxisLabelProps) {
-  const { cellWidthPx = 8, fractionalViewport = false } = useUiCapabilities();
-  const resolvedCursorDate = useMemo(() => {
-    return resolveCursorDateFromAxis({
-      dates,
-      width,
-      cursorColumn,
-      cursorPixelX: fractionalViewport ? cursorPixelX : null,
-      cellWidthPx,
-    }) ?? cursorDate;
-  }, [cellWidthPx, cursorColumn, cursorDate, cursorPixelX, dates, fractionalViewport, width]);
-  const segments = useMemo(() => buildCursorTimeAxisSegments({
-    timeLabels,
-    width,
-    cursorColumn,
-    cursorDate: resolvedCursorDate,
-    dates,
-  }), [cursorColumn, dates, resolvedCursorDate, timeLabels, width]);
-  const overlay = useMemo(() => buildCursorTimeAxisOverlay({
-    segments,
-    width,
-    cursorPixelX,
-    cellWidthPx,
-  }), [cellWidthPx, cursorPixelX, segments, width]);
-
-  if (fractionalViewport && overlay.label && overlay.leftPercent !== null) {
-    return (
-      <Box
-        width={width}
-        height={1}
-        overflow="hidden"
-        style={{ position: "relative" }}
-      >
-        <Text fg={colors.textDim} selectable={false} style={{ whiteSpace: "pre" }}>
-          {overlay.baseText}
-        </Text>
-        <Text
-          fg={cursorColor}
-          bg={colors.bg}
-          selectable={false}
-          style={{
-            position: "absolute",
-            left: `${overlay.leftPercent}%`,
-            top: 0,
-            transform: "translateX(-50%)",
-            whiteSpace: "pre",
-            pointerEvents: "none",
-            zIndex: 1,
-          }}
-        >
-          {overlay.label}
-        </Text>
-      </Box>
-    );
-  }
-
-  return (
-    <Text selectable={false} style={{ whiteSpace: "pre" }}>
-      {segments.map((segment, index) => (
-        <Span
-          key={index}
-          fg={segment.highlighted ? cursorColor : colors.textDim}
-        >
-          {segment.text}
-        </Span>
-      ))}
-    </Text>
-  );
-}