gloomberb 0.4.1 → 0.5.0

package/src/components/chart/chart-control-hint.tsx

@@ -0,0 +1,39 @@
+import { TextAttributes } from "@opentui/core";
+import { colors } from "../../theme/colors";
+
+type HintMouseEvent = {
+  stopPropagation?: () => void;
+  preventDefault?: () => void;
+};
+
+interface ChartControlHintProps {
+  hotkey: string;
+  label: string;
+  disabled?: boolean;
+  onPress?: (event?: HintMouseEvent) => void;
+}
+
+function stopMouseEvent(event?: HintMouseEvent) {
+  event?.stopPropagation?.();
+  event?.preventDefault?.();
+}
+
+export function ChartControlHint({
+  hotkey,
+  label,
+  disabled = false,
+  onPress,
+}: ChartControlHintProps) {
+  const interactive = !!onPress && !disabled;
+
+  return (
+    <text
+      fg={disabled ? colors.textMuted : colors.textDim}
+      attributes={interactive ? TextAttributes.BOLD : 0}
+      onMouseDown={interactive ? stopMouseEvent : undefined}
+      onMouseUp={interactive ? onPress : undefined}
+    >
+      <span fg={disabled ? colors.textMuted : colors.textBright}>[{hotkey}]</span>{label}
+    </text>
+  );
+}

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

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import {
+  clampDateWindowToBounds,
+  getCanonicalZoomLevel,
+  needsCanonicalPresetViewportReset,
+  resolveCanonicalPresetViewport,
+  resolveVisibleActivePreset,
+  shiftDateWindow,
+} from "./chart-controller";
+
+const dayMs = 24 * 60 * 60_000;
+
+function utcDate(day: number): Date {
+  return new Date(Date.UTC(2026, 0, day));
+}
+
+function utcDates(count: number): Date[] {
+  return Array.from({ length: count }, (_, index) => utcDate(index + 1));
+}
+
+describe("chart-controller date windows", () => {
+  test("keeps the visible span when panning past the right edge", () => {
+    const current = {
+      start: utcDate(8),
+      end: utcDate(10),
+    };
+    const shifted = shiftDateWindow(current, -2);
+
+    const clamped = clampDateWindowToBounds(shifted, {
+      start: utcDate(1),
+      end: utcDate(11),
+    });
+
+    expect(clamped).toEqual({
+      start: utcDate(9),
+      end: utcDate(11),
+    });
+    expect(clamped!.end!.getTime() - clamped!.start!.getTime()).toBe(2 * dayMs);
+  });
+
+  test("keeps the visible span when panning past the left edge", () => {
+    const current = {
+      start: utcDate(2),
+      end: utcDate(4),
+    };
+    const shifted = shiftDateWindow(current, 2);
+
+    const clamped = clampDateWindowToBounds(shifted, {
+      start: utcDate(1),
+      end: utcDate(11),
+    });
+
+    expect(clamped).toEqual({
+      start: utcDate(1),
+      end: utcDate(3),
+    });
+    expect(clamped!.end!.getTime() - clamped!.start!.getTime()).toBe(2 * dayMs);
+  });
+
+  test("expands tiny windows around their center without crossing bounds", () => {
+    const clamped = clampDateWindowToBounds({
+      start: utcDate(11),
+      end: utcDate(11),
+    }, {
+      start: utcDate(1),
+      end: utcDate(11),
+    }, 2 * dayMs);
+
+    expect(clamped).toEqual({
+      start: utcDate(9),
+      end: utcDate(11),
+    });
+  });
+
+  test("keeps an active preset visible while loaded data still needs the canonical reset", () => {
+    const dates = utcDates(300);
+    const state = {
+      presetRange: "1M" as const,
+      activePreset: "1M" as const,
+      resolution: "15m" as const,
+      panOffset: 0,
+      zoomLevel: 1,
+      cursorX: 12,
+      cursorY: 3,
+    };
+
+    expect(needsCanonicalPresetViewportReset(dates, state)).toBe(true);
+    expect(resolveVisibleActivePreset(dates, state)).toBe("1M");
+
+    const resolved = resolveCanonicalPresetViewport(state, dates);
+    expect(resolved.zoomLevel).toBe(getCanonicalZoomLevel(dates, "1M"));
+    expect(resolved.panOffset).toBe(0);
+    expect(resolved.cursorX).toBeNull();
+    expect(resolved.cursorY).toBeNull();
+  });
+
+  test("does not keep a preset active after the viewport was panned", () => {
+    const dates = utcDates(300);
+    const state = {
+      presetRange: "1M" as const,
+      activePreset: "1M" as const,
+      resolution: "15m" as const,
+      panOffset: 2,
+      zoomLevel: 1,
+    };
+
+    expect(needsCanonicalPresetViewportReset(dates, state)).toBe(false);
+    expect(resolveVisibleActivePreset(dates, state)).toBeNull();
+  });
+});

package/src/components/chart/chart-controller.ts

@@ -1,7 +1,7 @@
 import type { QueryEntry } from "../../market-data/result-types";
 import type { PricePoint } from "../../types/financials";
 import { clampChartZoom, getVisiblePointCount } from "./chart-viewport";
-import type { ChartResolution, ChartViewState, ComparisonChartViewState, TimeRange } from "./chart-types";
+import type { ChartResolution, ChartViewState, ComparisonChartViewState, TimeRange, VisibleWindow } from "./chart-types";
 import {
   clampTimeRangeToMaxRange,
   getBestSupportedResolutionForPreset,
@@ -37,6 +37,11 @@ export interface ChartBodyState<T> {
   errorMessage: string | null;
 }
 
+export interface DateWindowRange {
+  start: Date | null;
+  end: Date | null;
+}
+
 function clamp(value: number, min: number, max: number): number {
   return Math.max(min, Math.min(max, value));
 }
@@ -45,10 +50,235 @@ function coerceDate(value: Date | string | number): Date {
   return value instanceof Date ? value : new Date(value);
 }
 
+function normalizeDateWindowRange(window: DateWindowRange | null | undefined): { startMs: number; endMs: number } | null {
+  if (!window?.start || !window.end) return null;
+  const rawStartMs = window.start.getTime();
+  const rawEndMs = window.end.getTime();
+  if (!Number.isFinite(rawStartMs) || !Number.isFinite(rawEndMs)) return null;
+  return rawStartMs <= rawEndMs
+    ? { startMs: rawStartMs, endMs: rawEndMs }
+    : { startMs: rawEndMs, endMs: rawStartMs };
+}
+
+function lowerBoundDate(dates: readonly Date[], targetMs: number): number {
+  let low = 0;
+  let high = dates.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (dates[mid]!.getTime() < targetMs) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low;
+}
+
+function upperBoundDate(dates: readonly Date[], targetMs: number): number {
+  let low = 0;
+  let high = dates.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (dates[mid]!.getTime() <= targetMs) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low;
+}
+
+function resolveMinimumPointWindow(
+  dates: readonly Date[],
+  startMs: number,
+  endMs: number,
+  minimumPoints: number,
+): { startIdx: number; endIdx: number } {
+  if (dates.length === 0) return { startIdx: 0, endIdx: 0 };
+
+  let startIdx = lowerBoundDate(dates, startMs);
+  let endIdx = upperBoundDate(dates, endMs);
+
+  if (minimumPoints <= 0) {
+    return {
+      startIdx: Math.min(startIdx, dates.length),
+      endIdx: Math.min(Math.max(endIdx, startIdx), dates.length),
+    };
+  }
+
+  if (endIdx - startIdx >= minimumPoints || dates.length <= minimumPoints) {
+    return {
+      startIdx: Math.min(startIdx, dates.length),
+      endIdx: Math.min(Math.max(endIdx, startIdx), dates.length),
+    };
+  }
+
+  const centerMs = startMs + ((endMs - startMs) / 2);
+  let anchorIdx = lowerBoundDate(dates, centerMs);
+  if (anchorIdx >= dates.length) anchorIdx = dates.length - 1;
+  if (anchorIdx > 0) {
+    const currentDistance = Math.abs(dates[anchorIdx]!.getTime() - centerMs);
+    const previousDistance = Math.abs(dates[anchorIdx - 1]!.getTime() - centerMs);
+    if (previousDistance <= currentDistance) {
+      anchorIdx -= 1;
+    }
+  }
+
+  startIdx = Math.max(Math.min(anchorIdx - Math.floor((minimumPoints - 1) / 2), dates.length - minimumPoints), 0);
+  endIdx = Math.min(startIdx + minimumPoints, dates.length);
+
+  return { startIdx, endIdx };
+}
+
 export function getPointDates(points: readonly Pick<PricePoint, "date">[]): Date[] {
   return points.map((point) => coerceDate(point.date as Date | string | number));
 }
 
+export function getDateWindowBounds(dates: readonly Date[]): DateWindowRange | null {
+  if (dates.length === 0) return null;
+  return {
+    start: dates[0] ?? null,
+    end: dates[dates.length - 1] ?? null,
+  };
+}
+
+export function getMinimumDateStepMs(dates: readonly Date[]): number {
+  let minimum = Number.POSITIVE_INFINITY;
+  for (let index = 1; index < dates.length; index += 1) {
+    const delta = dates[index]!.getTime() - dates[index - 1]!.getTime();
+    if (delta > 0 && delta < minimum) {
+      minimum = delta;
+    }
+  }
+  return Number.isFinite(minimum) ? minimum : 1;
+}
+
+export function buildPresetDateWindow(dates: readonly Date[], presetRange: TimeRange): DateWindowRange | null {
+  if (dates.length === 0) return null;
+  if (presetRange === "ALL") {
+    return {
+      start: dates[0] ?? null,
+      end: dates[dates.length - 1] ?? null,
+    };
+  }
+
+  const end = dates[dates.length - 1]!;
+  const threshold = subtractTimeRange(end, presetRange).getTime();
+  const startIdx = dates.findIndex((date) => date.getTime() >= threshold);
+
+  return {
+    start: dates[startIdx < 0 ? 0 : startIdx] ?? null,
+    end,
+  };
+}
+
+export function sameDateWindow(
+  left: DateWindowRange | null | undefined,
+  right: DateWindowRange | null | undefined,
+  toleranceMs = 1,
+): boolean {
+  if (!left?.start || !left.end || !right?.start || !right.end) {
+    return left?.start === right?.start && left?.end === right?.end;
+  }
+  return Math.abs(left.start.getTime() - right.start.getTime()) <= toleranceMs
+    && Math.abs(left.end.getTime() - right.end.getTime()) <= toleranceMs;
+}
+
+export function clampDateWindowToBounds(
+  window: DateWindowRange | null | undefined,
+  bounds: DateWindowRange | null | undefined,
+  minimumSpanMs = 1,
+): DateWindowRange | null {
+  const normalizedWindow = normalizeDateWindowRange(window);
+  const normalizedBounds = normalizeDateWindowRange(bounds);
+  if (!normalizedWindow || !normalizedBounds) return null;
+
+  const availableSpanMs = Math.max(normalizedBounds.endMs - normalizedBounds.startMs, 0);
+  const effectiveMinimumSpanMs = availableSpanMs === 0
+    ? 0
+    : Math.min(Math.max(minimumSpanMs, 1), availableSpanMs);
+  const requestedSpanMs = Math.max(normalizedWindow.endMs - normalizedWindow.startMs, 0);
+  const targetSpanMs = Math.min(
+    Math.max(requestedSpanMs, effectiveMinimumSpanMs),
+    availableSpanMs,
+  );
+
+  if (availableSpanMs === 0 || targetSpanMs === 0) {
+    return {
+      start: new Date(normalizedBounds.startMs),
+      end: new Date(normalizedBounds.endMs),
+    };
+  }
+
+  if (targetSpanMs >= availableSpanMs) {
+    return {
+      start: new Date(normalizedBounds.startMs),
+      end: new Date(normalizedBounds.endMs),
+    };
+  }
+
+  let startMs: number;
+  let endMs: number;
+
+  if (requestedSpanMs < targetSpanMs) {
+    const centerMs = normalizedWindow.startMs + (requestedSpanMs / 2);
+    startMs = centerMs - (targetSpanMs / 2);
+    endMs = centerMs + (targetSpanMs / 2);
+  } else {
+    startMs = normalizedWindow.startMs;
+    endMs = normalizedWindow.startMs + targetSpanMs;
+  }
+
+  if (startMs < normalizedBounds.startMs) {
+    startMs = normalizedBounds.startMs;
+    endMs = startMs + targetSpanMs;
+  } else if (endMs > normalizedBounds.endMs) {
+    endMs = normalizedBounds.endMs;
+    startMs = endMs - targetSpanMs;
+  }
+
+  return {
+    start: new Date(startMs),
+    end: new Date(endMs),
+  };
+}
+
+export function scaleDateWindow(
+  window: DateWindowRange | null | undefined,
+  spanScale: number,
+  anchorRatio: number,
+): DateWindowRange | null {
+  const normalizedWindow = normalizeDateWindowRange(window);
+  if (!normalizedWindow) return null;
+
+  const currentSpanMs = Math.max(normalizedWindow.endMs - normalizedWindow.startMs, 1);
+  const nextSpanMs = Math.max(currentSpanMs * spanScale, 1);
+  const ratio = clamp(anchorRatio, 0, 1);
+  const anchorMs = normalizedWindow.startMs + (currentSpanMs * ratio);
+  const nextStartMs = anchorMs - (nextSpanMs * ratio);
+
+  return {
+    start: new Date(nextStartMs),
+    end: new Date(nextStartMs + nextSpanMs),
+  };
+}
+
+export function shiftDateWindow(
+  window: DateWindowRange | null | undefined,
+  shiftRatio: number,
+): DateWindowRange | null {
+  const normalizedWindow = normalizeDateWindowRange(window);
+  if (!normalizedWindow) return null;
+
+  const spanMs = Math.max(normalizedWindow.endMs - normalizedWindow.startMs, 1);
+  const shiftMs = spanMs * shiftRatio;
+
+  return {
+    start: new Date(normalizedWindow.startMs - shiftMs),
+    end: new Date(normalizedWindow.endMs - shiftMs),
+  };
+}
+
 export function getCanonicalVisiblePointCount(dates: readonly Date[], presetRange: TimeRange): number {
   if (dates.length === 0) return 0;
   if (presetRange === "ALL") return dates.length;
@@ -89,10 +319,93 @@ export function buildVisibleDateWindow(
   };
 }
 
+export function buildVisibleDateWindowFromRange(
+  dates: readonly Date[],
+  window: DateWindowRange | null | undefined,
+  minimumPoints = 2,
+): VisibleDateWindow {
+  if (dates.length === 0) {
+    return { start: null, end: null, dates: [], startIdx: 0, endIdx: 0, totalDates: 0 };
+  }
+
+  const normalizedWindow = normalizeDateWindowRange(window);
+  if (!normalizedWindow) {
+    return {
+      start: dates[0] ?? null,
+      end: dates[dates.length - 1] ?? null,
+      dates: [...dates],
+      startIdx: 0,
+      endIdx: dates.length,
+      totalDates: dates.length,
+    };
+  }
+
+  const { startIdx, endIdx } = resolveMinimumPointWindow(dates, normalizedWindow.startMs, normalizedWindow.endMs, minimumPoints);
+  const visibleDates = dates.slice(startIdx, endIdx);
+
+  return {
+    start: visibleDates[0] ?? null,
+    end: visibleDates[visibleDates.length - 1] ?? null,
+    dates: visibleDates,
+    startIdx,
+    endIdx,
+    totalDates: dates.length,
+  };
+}
+
+export function getVisibleWindowForDateRange(
+  points: readonly PricePoint[],
+  window: DateWindowRange | null | undefined,
+  minimumPoints = 2,
+): VisibleWindow {
+  if (points.length === 0) {
+    return { points: [], startIdx: 0, endIdx: 0 };
+  }
+
+  const pointDates = getPointDates(points);
+  const visibleWindow = buildVisibleDateWindowFromRange(pointDates, window, minimumPoints);
+
+  return {
+    points: points.slice(visibleWindow.startIdx, visibleWindow.endIdx),
+    startIdx: visibleWindow.startIdx,
+    endIdx: visibleWindow.endIdx,
+  };
+}
+
 export function formatVisibleSpanLabel(window: Pick<VisibleDateWindow, "start" | "end">): string {
   if (!window.start || !window.end) return "view: --";
   const sameYear = window.start.getFullYear() === window.end.getFullYear();
   const sameMonth = sameYear && window.start.getMonth() === window.end.getMonth();
+  const sameDay = sameMonth && window.start.getDate() === window.end.getDate();
+  const spanMs = Math.max(window.end.getTime() - window.start.getTime(), 0);
+  const showTime = sameDay || spanMs <= 2 * 24 * 60 * 60_000;
+
+  if (showTime) {
+    const startLabel = window.start.toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+      ...(sameYear ? {} : { year: "numeric" }),
+    });
+    const startTime = window.start.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+    });
+    const endLabel = sameDay
+      ? window.end.toLocaleTimeString("en-US", {
+        hour: "numeric",
+        minute: "2-digit",
+      })
+      : `${window.end.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        year: sameYear ? undefined : "numeric",
+      })} ${window.end.toLocaleTimeString("en-US", {
+        hour: "numeric",
+        minute: "2-digit",
+      })}`;
+    return `view:${startLabel} ${startTime}-${endLabel}`;
+  }
+
   const startLabel = window.start.toLocaleDateString("en-US", {
     month: "short",
     day: "numeric",
@@ -116,6 +429,52 @@ export function isCanonicalPresetViewport(
   return Math.abs(state.zoomLevel - canonicalZoom) < 0.001;
 }
 
+type CanonicalPresetViewportState = Pick<ViewStateWithViewport, "presetRange" | "activePreset" | "panOffset" | "zoomLevel" | "cursorX" | "cursorY">;
+
+export function needsCanonicalPresetViewportReset(
+  dates: readonly Date[],
+  state: Pick<CanonicalPresetViewportState, "presetRange" | "activePreset" | "panOffset" | "zoomLevel">,
+): boolean {
+  if (dates.length === 0) return false;
+  if (state.activePreset !== state.presetRange) return false;
+  if (state.panOffset !== 0) return false;
+  const canonicalZoom = getCanonicalZoomLevel(dates, state.presetRange);
+  return Math.abs(state.zoomLevel - canonicalZoom) >= 0.001;
+}
+
+export function resolvePresetRangeViewport<S extends CanonicalPresetViewportState>(
+  state: S,
+  dates: readonly Date[],
+): S {
+  if (dates.length === 0) return state;
+  const canonicalZoom = getCanonicalZoomLevel(dates, state.presetRange);
+  if (state.zoomLevel === canonicalZoom && state.panOffset === 0) return state;
+  return {
+    ...state,
+    panOffset: 0,
+    zoomLevel: canonicalZoom,
+    cursorX: null,
+    cursorY: null,
+  };
+}
+
+export function resolveCanonicalPresetViewport<S extends CanonicalPresetViewportState>(
+  state: S,
+  dates: readonly Date[],
+): S {
+  if (!needsCanonicalPresetViewportReset(dates, state)) return state;
+  return resolvePresetRangeViewport(state, dates);
+}
+
+export function resolveVisibleActivePreset(
+  dates: readonly Date[],
+  state: Pick<ViewStateWithViewport, "presetRange" | "activePreset" | "panOffset" | "zoomLevel" | "resolution">,
+): TimeRange | null {
+  if (!state.activePreset) return null;
+  if (isCanonicalPresetViewport(dates, state)) return state.activePreset;
+  return needsCanonicalPresetViewportReset(dates, state) ? state.activePreset : null;
+}
+
 export function resolvePresetSelectionWithResolution<S extends ViewStateWithViewport>(
   state: S,
   presetRange: TimeRange,
@@ -245,9 +604,12 @@ export function resolveStoredChartSelection<S extends ViewStateWithViewport>(
     );
   }
 
+  const bestSupportedResolution = getBestSupportedResolutionForPreset(resolvedSelection.presetRange, support);
   return {
     ...resolvedSelection,
-    activePreset: resolvedSelection.resolution === getBestSupportedResolutionForPreset(resolvedSelection.presetRange, support)
+    activePreset: resolvedSelection.resolution !== "auto"
+      && bestSupportedResolution !== null
+      && resolvedSelection.resolution === bestSupportedResolution
       ? resolvedSelection.presetRange
       : null,
   };