gloomberb 0.7.4 → 0.8.0

package/src/components/chart/core/resolution.ts

@@ -0,0 +1,380 @@
+import type { ChartResolution, TimeRange } from "./types";
+import { TIME_RANGES } from "./types";
+import { isDateWindowWithinTimeRange } from "./date-window";
+
+export type ManualChartResolution = Exclude<ChartResolution, "auto">;
+
+export interface ChartResolutionSupport {
+  resolution: ManualChartResolution;
+  maxRange: TimeRange;
+}
+
+export const TIME_RANGE_ORDER: TimeRange[] = [...TIME_RANGES];
+
+const CHART_RESOLUTION_ORDER: ChartResolution[] = [
+  "auto",
+  "1m",
+  "5m",
+  "15m",
+  "30m",
+  "45m",
+  "1h",
+  "1d",
+  "1wk",
+  "1mo",
+];
+
+const CHART_RESOLUTION_LABELS: Record<ChartResolution, string> = {
+  auto: "AUTO",
+  "1m": "1M",
+  "5m": "5M",
+  "15m": "15M",
+  "30m": "30M",
+  "45m": "45M",
+  "1h": "1H",
+  "1d": "1D",
+  "1wk": "1W",
+  "1mo": "1MO",
+};
+
+const RANGE_PRESET_RESOLUTION: Record<TimeRange, ManualChartResolution> = {
+  "1D": "1m",
+  "1W": "5m",
+  "1M": "15m",
+  "3M": "1h",
+  "6M": "1d",
+  "1Y": "1d",
+  "5Y": "1wk",
+  "ALL": "1mo",
+};
+
+const RANGE_PRELOAD_BUFFER: Record<TimeRange, TimeRange> = {
+  "1D": "1W",
+  "1W": "1M",
+  "1M": "3M",
+  "3M": "6M",
+  "6M": "1Y",
+  "1Y": "5Y",
+  "5Y": "ALL",
+  "ALL": "ALL",
+};
+
+export const DEFAULT_TICKER_CHART_RANGE_PRESET: TimeRange = "5Y";
+export const DEFAULT_TICKER_CHART_RESOLUTION: ChartResolution = "auto";
+export const DEFAULT_COMPARISON_CHART_RANGE_PRESET: TimeRange = "1Y";
+export const DEFAULT_COMPARISON_CHART_RESOLUTION: ManualChartResolution = "1d";
+
+export const DEFAULT_VISIBLE_MANUAL_CHART_RESOLUTIONS: ManualChartResolution[] = ["1m", "5m", "15m", "1h", "1d", "1wk", "1mo"];
+export const CHART_RESOLUTION_STEP_MS: Record<ManualChartResolution, number> = {
+  "1m": 60_000,
+  "5m": 5 * 60_000,
+  "15m": 15 * 60_000,
+  "30m": 30 * 60_000,
+  "45m": 45 * 60_000,
+  "1h": 60 * 60_000,
+  "1d": 24 * 60 * 60_000,
+  "1wk": 7 * 24 * 60 * 60_000,
+  "1mo": 30 * 24 * 60 * 60_000,
+};
+
+export function getChartResolutionStepMs(resolution: ChartResolution): number | null {
+  return resolution === "auto" ? null : CHART_RESOLUTION_STEP_MS[resolution];
+}
+
+const CHART_RESOLUTION_POINTS_PER_DAY: Record<ManualChartResolution, number> = {
+  "1m": 390,
+  "5m": 78,
+  "15m": 26,
+  "30m": 13,
+  "45m": 9,
+  "1h": 7,
+  "1d": 1,
+  "1wk": 1 / 5,
+  "1mo": 1 / 21,
+};
+
+const TIME_RANGE_INDEX = new Map(TIME_RANGE_ORDER.map((range, index) => [range, index]));
+const RANGE_PRESETS_BY_RESOLUTION = TIME_RANGE_ORDER.reduce<Record<ManualChartResolution, TimeRange[]>>((acc, range) => {
+  const resolution = RANGE_PRESET_RESOLUTION[range];
+  acc[resolution] ??= [];
+  acc[resolution].push(range);
+  return acc;
+}, {
+  "1m": [],
+  "5m": [],
+  "15m": [],
+  "30m": [],
+  "45m": [],
+  "1h": [],
+  "1d": [],
+  "1wk": [],
+  "1mo": [],
+});
+
+function getTimeRangeIndex(range: TimeRange): number {
+  return TIME_RANGE_INDEX.get(range) ?? 0;
+}
+
+function compareTimeRange(left: TimeRange, right: TimeRange): number {
+  return getTimeRangeIndex(left) - getTimeRangeIndex(right);
+}
+
+function isChartResolution(value: unknown): value is ChartResolution {
+  return CHART_RESOLUTION_ORDER.includes(value as ChartResolution);
+}
+
+function isManualChartResolution(value: unknown): value is ManualChartResolution {
+  return value !== "auto" && CHART_RESOLUTION_ORDER.includes(value as ChartResolution);
+}
+
+export function normalizeChartResolution(value: unknown, fallback: ChartResolution = "auto"): ChartResolution {
+  return isChartResolution(value) ? value : fallback;
+}
+
+export function getChartResolutionLabel(resolution: ChartResolution): string {
+  return CHART_RESOLUTION_LABELS[resolution];
+}
+
+export function getPresetResolution(range: TimeRange): ManualChartResolution {
+  return RANGE_PRESET_RESOLUTION[range];
+}
+
+function getManualResolutionOrderIndex(resolution: ManualChartResolution): number {
+  return CHART_RESOLUTION_ORDER.indexOf(resolution);
+}
+
+function getPresetBufferRange(range: TimeRange): TimeRange {
+  return RANGE_PRELOAD_BUFFER[range];
+}
+
+export function getNextBufferRange(range: TimeRange): TimeRange {
+  return RANGE_PRELOAD_BUFFER[range];
+}
+
+export function getExpandedBufferRange(
+  bufferRange: TimeRange,
+  resolution: ChartResolution,
+  supportMap: ReadonlyMap<ManualChartResolution, TimeRange>,
+): TimeRange | null {
+  const nextCandidate = getNextBufferRange(bufferRange);
+  const nextBufferRange = resolution === "auto"
+    ? nextCandidate
+    : clampTimeRangeToMaxRange(nextCandidate, supportMap.get(resolution) ?? bufferRange);
+  return isTimeRangeAtOrBelow(nextBufferRange, bufferRange) ? null : nextBufferRange;
+}
+
+export function sortChartResolutions<T extends ChartResolution>(resolutions: readonly T[]): T[] {
+  return [...resolutions].sort((left, right) => (
+    CHART_RESOLUTION_ORDER.indexOf(left) - CHART_RESOLUTION_ORDER.indexOf(right)
+  ));
+}
+
+function sortChartResolutionSupport(support: readonly ChartResolutionSupport[]): ChartResolutionSupport[] {
+  return [...support].sort((left, right) => (
+    CHART_RESOLUTION_ORDER.indexOf(left.resolution) - CHART_RESOLUTION_ORDER.indexOf(right.resolution)
+  ));
+}
+
+export function normalizeChartResolutionSupport(support: readonly ChartResolutionSupport[]): ChartResolutionSupport[] {
+  const byResolution = new Map<ManualChartResolution, TimeRange>();
+  for (const entry of support) {
+    if (!isManualChartResolution(entry.resolution)) continue;
+    const current = byResolution.get(entry.resolution);
+    byResolution.set(
+      entry.resolution,
+      current ? (compareTimeRange(current, entry.maxRange) >= 0 ? current : entry.maxRange) : entry.maxRange,
+    );
+  }
+  return sortChartResolutionSupport(
+    [...byResolution.entries()].map(([resolution, maxRange]) => ({ resolution, maxRange })),
+  );
+}
+
+export function intersectChartResolutionSupport(
+  supportSets: Array<readonly ChartResolutionSupport[]>,
+): ChartResolutionSupport[] {
+  if (supportSets.length === 0) return [];
+  const normalized = supportSets.map((support) => normalizeChartResolutionSupport(support));
+  const first = normalized[0] ?? [];
+  return sortChartResolutionSupport(first.flatMap((entry) => {
+    let maxRange = entry.maxRange;
+    for (const set of normalized.slice(1)) {
+      const match = set.find((candidate) => candidate.resolution === entry.resolution);
+      if (!match) return [];
+      maxRange = minTimeRange(maxRange, match.maxRange);
+    }
+    return [{ resolution: entry.resolution, maxRange }];
+  }));
+}
+
+export function buildChartResolutionSupportMap(
+  support: readonly ChartResolutionSupport[],
+): ReadonlyMap<ManualChartResolution, TimeRange> {
+  return new Map(normalizeChartResolutionSupport(support).map((entry) => [entry.resolution, entry.maxRange] as const));
+}
+
+export function getSupportMaxRange(
+  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
+  resolution: ManualChartResolution,
+): TimeRange | null {
+  if (!Array.isArray(support)) {
+    return (support as ReadonlyMap<ManualChartResolution, TimeRange>).get(resolution) ?? null;
+  }
+  return normalizeChartResolutionSupport(support).find((entry) => entry.resolution === resolution)?.maxRange ?? null;
+}
+
+function minTimeRange(left: TimeRange, right: TimeRange): TimeRange {
+  return compareTimeRange(left, right) <= 0 ? left : right;
+}
+
+export function maxTimeRange(left: TimeRange, right: TimeRange): TimeRange {
+  return compareTimeRange(left, right) >= 0 ? left : right;
+}
+
+export function isTimeRangeAtOrBelow(candidate: TimeRange, maxRange: TimeRange): boolean {
+  return compareTimeRange(candidate, maxRange) <= 0;
+}
+
+export function clampTimeRangeToMaxRange(range: TimeRange, maxRange: TimeRange): TimeRange {
+  return isTimeRangeAtOrBelow(range, maxRange) ? range : maxRange;
+}
+
+export function clampTimeRangeForResolution(range: TimeRange, resolution: ChartResolution): TimeRange {
+  if (resolution === "auto") return range;
+  const maxRange = getSupportMaxRange(
+    normalizeChartResolutionSupport([{ resolution, maxRange: "ALL" }]),
+    resolution,
+  ) ?? "ALL";
+  const intrinsicMaxRange = resolution === "1m" || resolution === "5m"
+    ? "1W"
+    : resolution === "15m"
+      ? "1M"
+      : resolution === "30m" || resolution === "45m" || resolution === "1h"
+        ? "3M"
+        : "ALL";
+  return clampTimeRangeToMaxRange(range, minTimeRange(maxRange, intrinsicMaxRange));
+}
+
+export function isIntradayResolution(resolution: ManualChartResolution): boolean {
+  return resolution === "1m"
+    || resolution === "5m"
+    || resolution === "15m"
+    || resolution === "30m"
+    || resolution === "45m"
+    || resolution === "1h";
+}
+
+export function isRangePresetSupported(
+  range: TimeRange,
+  support: readonly ChartResolutionSupport[] | readonly ManualChartResolution[],
+): boolean {
+  const resolution = RANGE_PRESET_RESOLUTION[range];
+  if (support.length === 0) return false;
+  if (typeof support[0] === "string") {
+    return (support as readonly ManualChartResolution[]).includes(resolution);
+  }
+  const maxRange = getSupportMaxRange(support as readonly ChartResolutionSupport[], resolution);
+  return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
+}
+
+export function getActiveRangePreset(
+  range: TimeRange,
+  resolution: ChartResolution,
+  zoomLevel: number,
+  panOffset: number,
+): TimeRange | null {
+  if (zoomLevel !== 1 || panOffset !== 0) return null;
+  return RANGE_PRESET_RESOLUTION[range] === resolution ? range : null;
+}
+
+export function getWidestPresetForResolution(
+  resolution: ManualChartResolution,
+  maxRange: TimeRange,
+): TimeRange {
+  const presets = RANGE_PRESETS_BY_RESOLUTION[resolution] ?? [];
+  const supported = presets.filter((range) => isTimeRangeAtOrBelow(range, maxRange));
+  if (supported.length > 0) {
+    return supported[supported.length - 1]!;
+  }
+  const fallback = TIME_RANGE_ORDER.filter((range) => isTimeRangeAtOrBelow(range, maxRange));
+  return fallback[fallback.length - 1] ?? "1D";
+}
+
+export function getBestSupportedResolutionForPreset(
+  range: TimeRange,
+  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
+  preferredResolution = getPresetResolution(range),
+): ManualChartResolution | null {
+  const supportedResolutions = CHART_RESOLUTION_ORDER
+    .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
+    .filter((resolution) => {
+      const maxRange = getSupportMaxRange(support, resolution);
+      return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
+    });
+
+  if (supportedResolutions.length === 0) return null;
+  if (supportedResolutions.includes(preferredResolution)) return preferredResolution;
+
+  const preferredIndex = getManualResolutionOrderIndex(preferredResolution);
+  const coarserResolution = supportedResolutions.find((resolution) => (
+    getManualResolutionOrderIndex(resolution) > preferredIndex
+  ));
+  if (coarserResolution) return coarserResolution;
+
+  return supportedResolutions[supportedResolutions.length - 1] ?? null;
+}
+
+export function getBestSupportedResolutionForVisibleWindow(
+  window: { start: Date | null; end: Date | null } | null,
+  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
+  targetPointCount: number,
+): ManualChartResolution | null {
+  if (!window?.start || !window.end) return null;
+
+  const spanMs = Math.max(window.end.getTime() - window.start.getTime(), 0);
+  const dayCount = Math.max(spanMs / CHART_RESOLUTION_STEP_MS["1d"], 1 / 24);
+  const supportedResolutions = sortChartResolutions(
+    CHART_RESOLUTION_ORDER
+      .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
+      .filter((resolution) => {
+        const maxRange = getSupportMaxRange(support, resolution);
+        return maxRange !== null && isDateWindowWithinTimeRange(window.start!, window.end!, maxRange);
+      }),
+  );
+
+  if (supportedResolutions.length === 0) return null;
+
+  const minimumPointTarget = Math.max(targetPointCount, 1);
+  for (const resolution of [...supportedResolutions].reverse()) {
+    const estimatedPointCount = Math.max(dayCount * CHART_RESOLUTION_POINTS_PER_DAY[resolution], 1);
+    if (estimatedPointCount >= minimumPointTarget) {
+      return resolution;
+    }
+  }
+
+  return supportedResolutions[0] ?? null;
+}
+
+export function getNextFallbackResolution(
+  range: TimeRange,
+  currentResolution: ManualChartResolution,
+  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
+): ChartResolution | null {
+  const currentIndex = getManualResolutionOrderIndex(currentResolution);
+  const nextResolution = CHART_RESOLUTION_ORDER
+    .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
+    .find((resolution) => (
+      getManualResolutionOrderIndex(resolution) > currentIndex
+      && (() => {
+        const maxRange = getSupportMaxRange(support, resolution);
+        return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
+      })()
+    ));
+
+  return nextResolution ?? "auto";
+}
+
+export function getCompatibleBufferRange(presetRange: TimeRange, maxRange: TimeRange | null): TimeRange {
+  const preloadRange = getPresetBufferRange(presetRange);
+  return maxRange ? clampTimeRangeToMaxRange(preloadRange, maxRange) : preloadRange;
+}

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

@@ -0,0 +1,180 @@
+import type {
+  ChartAxisMode,
+  ChartIndicatorOverlays,
+  ChartMarketSession,
+  ChartRenderMode,
+  ChartSessionBackgroundSpan,
+} from "./types";
+import type { ProjectedChartPoint } from "./data";
+import { resolveExtendedHoursBackgroundSpans } from "../market-session";
+import { normalizeCount } from "./render-utils";
+import { buildTimeAxis } from "./time-axis";
+import { type ResolvedChartPalette } from "./palette";
+import {
+  getPointTerminalColumn,
+  isHighLowMode,
+} from "../rendering/geometry";
+
+function normalizeRenderDimensions(opts: RenderChartOptions) {
+  const width = normalizeCount(opts.width, 1);
+  const height = normalizeCount(opts.height, 1);
+  const volumeHeight = opts.showVolume
+    ? Math.min(normalizeCount(opts.volumeHeight, 0), Math.max(height - 1, 0))
+    : 0;
+  const showVolume = opts.showVolume && volumeHeight > 0;
+  return {
+    width,
+    height,
+    showVolume,
+    volumeHeight,
+    chartRows: Math.max(height - volumeHeight, 1),
+  };
+}
+
+export interface RenderChartOptions {
+  width: number;
+  height: number;
+  showVolume: boolean;
+  volumeHeight: number;
+  cursorX: number | null;
+  cursorY: number | null;
+  mode: ChartRenderMode;
+  axisMode?: ChartAxisMode;
+  currency?: string;
+  assetCategory?: string;
+  colors: ResolvedChartPalette;
+  timeAxisDates?: Array<Date | string | number>;
+  indicators?: ChartIndicatorOverlays | null;
+  marketSession?: ChartMarketSession | null;
+}
+
+export interface ChartScene {
+  points: ProjectedChartPoint[];
+  width: number;
+  height: number;
+  showVolume: boolean;
+  volumeHeight: number;
+  chartRows: number;
+  mode: ChartRenderMode;
+  colors: ResolvedChartPalette;
+  indicators: ChartIndicatorOverlays | null;
+  sessionBackgroundSpans: ChartSessionBackgroundSpan[];
+  min: number;
+  max: number;
+  activeIdx: number;
+  activePoint: ProjectedChartPoint;
+  priceAtCursor: number;
+  crosshairPrice: number | null;
+  dateAtCursor: Date;
+  changeAtCursor: number;
+  changePctAtCursor: number;
+  timeLabels: string;
+  cursorX: number | null;
+  cursorY: number | null;
+  cursorColumn: number | null;
+  cursorRow: number | null;
+  cursorDotX: number | null;
+}
+
+export function getActivePointIndex(
+  pointCount: number,
+  width: number,
+  cursorX: number | null,
+  mode: ChartRenderMode,
+): 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 = getPointTerminalColumn(index, pointCount, width, mode);
+    const distance = Math.abs(pointColumn - cursorX);
+    if (distance <= bestDistance) {
+      bestDistance = distance;
+      bestIndex = index;
+    }
+  }
+
+  return bestIndex;
+}
+
+export function buildChartScene(
+  points: ProjectedChartPoint[],
+  opts: RenderChartOptions,
+): ChartScene | null {
+  if (points.length === 0) return null;
+
+  const dimensions = normalizeRenderDimensions(opts);
+  const dataMin = isHighLowMode(opts.mode)
+    ? Math.min(...points.map((point) => point.low))
+    : Math.min(...points.map((point) => point.close));
+  const dataMax = isHighLowMode(opts.mode)
+    ? Math.max(...points.map((point) => point.high))
+    : Math.max(...points.map((point) => point.close));
+  const min = dataMin;
+  const max = dataMax;
+  const activeIdx = getActivePointIndex(points.length, dimensions.width, opts.cursorX, opts.mode);
+  const activePoint = points[activeIdx]!;
+  const range = max - min || 1;
+  const cursorX = opts.cursorX === null
+    ? null
+    : Math.min(Math.max(opts.cursorX, 0), Math.max(dimensions.width - 1, 0));
+  const cursorColumn = cursorX === null
+    ? null
+    : Math.round(cursorX);
+  const cursorDotX = cursorX === null
+    ? null
+    : Math.round((cursorX / Math.max(dimensions.width - 1, 1)) * Math.max(dimensions.width * 2 - 1, 0));
+  const cursorY = cursorX === null
+    ? null
+    : opts.cursorY !== null
+      ? Math.min(Math.max(opts.cursorY, 0), Math.max(dimensions.chartRows - 1, 0))
+      : Math.min(
+        Math.max(Math.round((1 - (activePoint.close - min) / range) * Math.max(dimensions.chartRows - 1, 0)), 0),
+        Math.max(dimensions.chartRows - 1, 0),
+      );
+  const cursorRow = cursorY === null
+    ? null
+    : Math.round(cursorY);
+  const crosshairPrice = cursorY === null
+    ? null
+    : max - (cursorY / Math.max(dimensions.chartRows - 1, 1)) * range;
+
+  const timeAxisDates = opts.timeAxisDates ?? points.map((point) => point.date);
+  const sessionBackgroundSpans = resolveExtendedHoursBackgroundSpans(
+    points.map((point) => point.date),
+    opts.marketSession,
+  );
+
+  return {
+    points,
+    width: dimensions.width,
+    height: dimensions.height,
+    showVolume: dimensions.showVolume,
+    volumeHeight: dimensions.volumeHeight,
+    chartRows: dimensions.chartRows,
+    mode: opts.mode,
+    colors: opts.colors,
+    indicators: opts.indicators ?? null,
+    sessionBackgroundSpans,
+    min,
+    max,
+    activeIdx,
+    activePoint,
+    priceAtCursor: activePoint.close,
+    crosshairPrice,
+    dateAtCursor: activePoint.date,
+    changeAtCursor: activePoint.close - points[0]!.close,
+    changePctAtCursor: points[0]!.close ? ((activePoint.close - points[0]!.close) / points[0]!.close) * 100 : 0,
+    timeLabels: buildTimeAxis(timeAxisDates, dimensions.width),
+    cursorX,
+    cursorY,
+    cursorColumn,
+    cursorRow,
+    cursorDotX,
+  };
+}

package/src/components/chart/core/scroll.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test";
+import {
+  applyBufferedPanExpansion,
+  consumeScrollPanCellDelta,
+  consumeScrollPanMovement,
+  getDragPanPointDelta,
+  getDragPanWindowRatio,
+  getKeyboardPanCellCount,
+  resolveDragPanOffset,
+  resolveHorizontalScrollPanDirection,
+} from "./scroll";
+
+describe("chart-scroll", () => {
+  test("maps every wheel direction onto horizontal panning", () => {
+    expect(resolveHorizontalScrollPanDirection("up")).toBe(1);
+    expect(resolveHorizontalScrollPanDirection("left")).toBe(1);
+    expect(resolveHorizontalScrollPanDirection("down")).toBe(-1);
+    expect(resolveHorizontalScrollPanDirection("right")).toBe(-1);
+  });
+
+  test("accumulates wheel input before panning a full cell", () => {
+    let result = consumeScrollPanCellDelta(100, 1, 1, 0);
+    expect(result.cells).toBe(0);
+    expect(result.remainder).toBeCloseTo(0.5);
+
+    result = consumeScrollPanCellDelta(100, 1, 1, result.remainder);
+    expect(result.cells).toBe(1);
+    expect(result.remainder).toBeCloseTo(0);
+
+    result = consumeScrollPanCellDelta(100, 0.4, -1, result.remainder);
+    expect(result.cells).toBe(0);
+    expect(result.remainder).toBeCloseTo(-0.2);
+  });
+
+  test("keeps keyboard pan small while matching drag to the visible window", () => {
+    expect(getKeyboardPanCellCount(100)).toBe(2);
+    expect(getDragPanPointDelta(10, 100, 200)).toBe(20);
+    expect(getDragPanWindowRatio(10, 100)).toBeCloseTo(0.1);
+    expect(resolveDragPanOffset(20, 10, 100, 200, 40)).toBe(40);
+    expect(resolveDragPanOffset(20, -10, 100, 200, 40)).toBe(0);
+    expect(resolveDragPanOffset(38, 10, 100, 200, 40)).toBe(40);
+  });
+
+  test("resolves wheel direction, cell delta, remainder, and ratio together", () => {
+    const first = consumeScrollPanMovement(100, 1, "up", 0);
+    expect(first).toEqual({ cells: 0, remainder: 0.5, ratio: 0 });
+
+    const second = consumeScrollPanMovement(100, 1, "up", first.remainder);
+    expect(second).toEqual({ cells: 1, remainder: 0, ratio: 0.01 });
+  });
+
+  test("preserves the active cursor when widening the buffered pan range", () => {
+    const next = applyBufferedPanExpansion({
+      presetRange: "1W" as const,
+      bufferRange: "1M" as const,
+      activePreset: "1W" as const,
+      panOffset: 12,
+      zoomLevel: 2,
+      cursorX: 18,
+      cursorY: 6,
+    }, "3M");
+
+    expect(next).toMatchObject({
+      activePreset: null,
+      bufferRange: "3M",
+      cursorX: 18,
+      cursorY: 6,
+    });
+  });
+});