gloomberb 0.11.2 → 0.12.0

package/src/components/chart/composite/format.ts

@@ -78,14 +78,20 @@ export function formatCompositeCursorValue(value: number, domain: CompositeAxisD
   return formatCompositeAxisValue(value, domain);
 }
 
-export function compositeAxisTicks(domain: CompositeAxisDomain, count = 3): Array<{ ratio: number; value: number; label: string }> {
+export type CompositeAxisValueFormatter = (value: number, domain: CompositeAxisDomain) => string;
+
+export function compositeAxisTicks(
+  domain: CompositeAxisDomain,
+  count = 3,
+  format: CompositeAxisValueFormatter = formatCompositeAxisValue,
+): Array<{ ratio: number; value: number; label: string }> {
   const tickCount = Math.max(2, Math.floor(count));
   return Array.from({ length: tickCount }, (_, index) => {
     const ratio = index / (tickCount - 1);
     const value = domain.scale === "log"
       ? Math.exp(Math.log(domain.max) + (Math.log(domain.min) - Math.log(domain.max)) * ratio)
       : domain.max + (domain.min - domain.max) * ratio;
-    return { ratio, value, label: formatCompositeAxisValue(value, domain) };
+    return { ratio, value, label: format(value, domain) };
   });
 }
 

package/src/components/chart/composite/interactions.test.ts

@@ -1,17 +1,19 @@
 import { describe, expect, test } from "bun:test";
 import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
 import {
-  compositeViewportHasObservations,
+  buildCompositeNavigationFrame,
+  clampCompositeViewport,
+  compositeViewportPositions,
+  fitCompositeViewport,
   panCompositeViewport,
   resolveCompositeChartInteraction,
-  resolveCompositeMinimumSpanMs,
-  resolveCompositeNavigationBounds,
-  resolveCompositeWheelPanRatio,
+  resolveCompositeWheelPan,
+  resolveCompositeWheelZoom,
   shouldResetCompositeViewport,
   zoomCompositeViewport,
+  type CompositeNavigationFrame,
   type CompositeViewportRange,
 } from "./interactions";
-import { buildCompositeTimeScale, projectCompositeTimestamp } from "./time-scale";
 const DAY_MS = 24 * 60 * 60 * 1000;
 
 function point(day: number): TimeSeriesPoint {
@@ -65,83 +67,71 @@ function intradayMarketSeries(): ResolvedSeries {
   };
 }
 
-function marketSlotSpan(
+function slotSpan(frame: CompositeNavigationFrame, view: CompositeViewportRange): number {
+  const positions = compositeViewportPositions(frame, view)!;
+  return positions.end - positions.start;
+}
+
+function frameFor(
   data: ResolvedSeries,
-  bounds: CompositeViewportRange,
-  view: CompositeViewportRange,
-): number {
-  const scale = buildCompositeTimeScale([data], bounds.start.getTime(), bounds.end.getTime());
-  const start = projectCompositeTimestamp(scale, view.start.getTime())!.ratio;
-  const end = projectCompositeTimestamp(scale, view.end.getTime())!.ratio;
-  const positions = scale.kind === "market" ? scale.endPosition - scale.startPosition : 1;
-  return (end - start) * positions;
+  options?: { historicalPaddingRatio?: number },
+): CompositeNavigationFrame {
+  return buildCompositeNavigationFrame([data], [data], options)!;
 }
 
 describe("composite chart interactions", () => {
-  test("zooms around the right edge and clamps zoom-out to loaded bounds", () => {
-    const bounds = viewport(1, 11);
-    const zoomed = zoomCompositeViewport(bounds, bounds, 2, 1, DAY_MS);
+  test("zooms around the right edge and clamps zoom-out to the loaded data", () => {
+    const frame = frameFor(series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]));
+    const full = viewport(1, 11);
+    const zoomed = zoomCompositeViewport(frame, full, 2, 1);
 
-    expect(zoomed.start.toISOString()).toBe("2025-01-06T00:00:00.000Z");
-    expect(zoomed.end.toISOString()).toBe("2025-01-11T00:00:00.000Z");
-    expect(zoomCompositeViewport(zoomed, bounds, 0.1, 1, DAY_MS)).toEqual(bounds);
+    expect(zoomed).toEqual(viewport(6, 11));
+    expect(zoomCompositeViewport(frame, zoomed, 0.1, 1)).toEqual(full);
   });
 
-  test("pans relative to the drag-start window without changing its span", () => {
-    const bounds = viewport(1, 11);
+  test("pans by positions and stops at the newest observation", () => {
+    const frame = frameFor(series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]));
     const visible = viewport(4, 8);
 
-    const older = panCompositeViewport(visible, bounds, 0.5);
+    const older = panCompositeViewport(frame, visible, 2 * DAY_MS);
     expect(older).toEqual(viewport(2, 6));
-    expect(older.end.getTime() - older.start.getTime()).toBe(visible.end.getTime() - visible.start.getTime());
 
-    const clampedNewer = panCompositeViewport(visible, bounds, -10);
-    expect(clampedNewer).toEqual(viewport(7, 11));
+    expect(panCompositeViewport(frame, visible, -40 * DAY_MS)).toEqual(viewport(7, 11));
   });
 
   test("never changes the visible slot count while panning across a closed session", () => {
     const data = intradayMarketSeries();
-    const bounds = resolveCompositeNavigationBounds([data])!;
+    const frame = frameFor(data);
     let visible: CompositeViewportRange = {
       start: new Date("2025-01-03T13:30:00.000Z"),
       end: new Date("2025-01-03T17:00:00.000Z"),
     };
-    const slots = marketSlotSpan(data, bounds, visible);
+    const slots = slotSpan(frame, visible);
 
     // A wall-clock shift changes how many market slots stay in view, which
     // renders as the plot squeezing shut instead of scrolling sideways.
     for (let step = 0; step < 4; step += 1) {
-      visible = panCompositeViewport(visible, bounds, 0.5, [data]);
-      expect(marketSlotSpan(data, bounds, visible)).toBeCloseTo(slots, 6);
+      visible = panCompositeViewport(frame, visible, slots / 2);
+      expect(slotSpan(frame, visible)).toBeCloseTo(slots, 6);
     }
   });
 
-  test("uses representative cadence instead of a stray fine gap as the zoom floor", () => {
-    const data = series([1, 2, 5, 8, 11]);
-    const bounds = resolveCompositeNavigationBounds([data]);
-    expect(bounds).toEqual(viewport(1, 11));
-    expect(resolveCompositeMinimumSpanMs([data], bounds!)).toBe(3 * DAY_MS);
-  });
+  test("uses the representative cadence, not a stray fine gap, as the zoom floor", () => {
+    const frame = frameFor(series([1, 2, 5, 8, 11]));
+    expect(frame.minimumSpanMs).toBe(2 * 3 * DAY_MS);
 
-  test("keeps the selected window separate from wider loaded navigation bounds", () => {
-    const data = series([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-    expect(resolveCompositeNavigationBounds([data], viewport(5, 9))).toEqual(viewport(1, 9));
+    const tight = zoomCompositeViewport(frame, viewport(1, 11), 1_000, 0.5);
+    expect(tight.end.getTime() - tight.start.getTime()).toBe(frame.minimumSpanMs);
   });
 
-  test("reserves an older unloaded window without extending into the future", () => {
+  test("lets a backfilling chart pan half a screen before the first observation, never after the last", () => {
     const data = series([1, 2, 3, 4, 5, 6, 7, 8, 9]);
     const requested = viewport(5, 9);
-    const bounds = resolveCompositeNavigationBounds(
-      [data],
-      requested,
-      { historicalPaddingRatio: 1 },
-    );
-
-    expect(bounds).toEqual(viewport(-3, 9));
-    expect(panCompositeViewport(requested, bounds!, 1, [data], true))
-      .toEqual(viewport(1, 5));
-    expect(panCompositeViewport(requested, bounds!, -10, [data], true))
-      .toEqual(viewport(5, 9));
+    const frame = frameFor(data, { historicalPaddingRatio: 0.5 });
+
+    expect(panCompositeViewport(frame, requested, 100 * DAY_MS)).toEqual(viewport(-1, 3));
+    expect(panCompositeViewport(frame, requested, -100 * DAY_MS)).toEqual(viewport(5, 9));
+    expect(panCompositeViewport(frameFor(data), requested, 100 * DAY_MS)).toEqual(viewport(1, 5));
   });
 
   test("enters unloaded history from a full market-session viewport without changing span", () => {
@@ -150,58 +140,25 @@ describe("composite chart interactions", () => {
       start: data.points[0]!.date,
       end: data.points.at(-1)!.date,
     };
-    const bounds = resolveCompositeNavigationBounds(
-      [data],
-      requested,
-      { historicalPaddingRatio: 1 },
-    )!;
+    const frame = frameFor(data, { historicalPaddingRatio: 1 });
+    const slots = slotSpan(frame, requested);
 
-    const older = panCompositeViewport(requested, bounds, 1, [data], true);
+    const older = panCompositeViewport(frame, requested, slots);
     expect(older).not.toEqual(requested);
     expect(older.end.getTime()).toBe(requested.start.getTime());
-    expect(marketSlotSpan(data, bounds, older))
-      .toBeCloseTo(marketSlotSpan(data, bounds, requested), 6);
-    expect(panCompositeViewport(older, bounds, -1, [data], true)).toEqual(requested);
-  });
-
-  test("clamps overlapping requested bounds to real data and keeps disjoint ones reachable", () => {
-    const data = series([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-
-    expect(resolveCompositeNavigationBounds([data], viewport(5, 12))).toEqual(viewport(1, 9));
-    // Bounds equal to an observation-free window would strand pan and zoom
-    // inside it, so a disjoint request stays unioned with the loaded data.
-    expect(resolveCompositeNavigationBounds([data], viewport(20, 30))).toEqual(viewport(1, 30));
+    expect(slotSpan(frame, older)).toBeCloseTo(slots, 6);
+    expect(panCompositeViewport(frame, older, -slots)).toEqual(requested);
   });
 
-  test("requires distinct renderable observations inside a viewport", () => {
-    const data = series([1, 2, 3]);
-    const emptyPoint = point(4);
-    emptyPoint.value = null;
-    data.points.push(emptyPoint);
+  test("fits an authored window onto the data it overlaps and leaves a disjoint one alone", () => {
+    const frame = frameFor(series([1, 2, 3, 4, 5, 6, 7, 8, 9]));
 
-    expect(compositeViewportHasObservations([data], viewport(1, 2))).toBe(true);
-    expect(compositeViewportHasObservations([data], viewport(2, 2))).toBe(false);
-    expect(compositeViewportHasObservations([data], viewport(3, 4))).toBe(false);
-  });
-
-  test("does not zoom or pan a populated viewport into fewer than two observations", () => {
-    const data = series([1, 5, 10, 11]);
-    const bounds = viewport(1, 11);
-    const populated = viewport(1, 5);
-
-    expect(zoomCompositeViewport(populated, bounds, 2, 0.5, 1, [data])).toEqual(populated);
-    expect(panCompositeViewport(populated, bounds, -1, [data])).toEqual(populated);
-    expect(panCompositeViewport(populated, bounds, -1.5, [data])).toEqual(viewport(7, 11));
-  });
-
-  test("allows zoom-out to recover when refreshed data has already emptied the viewport", () => {
-    const data = series([1, 2, 10, 11]);
-    const bounds = viewport(1, 11);
-    const empty = viewport(5, 6);
-    const expanded = zoomCompositeViewport(empty, bounds, 0.5, 0.5, 1, [data]);
-
-    expect(expanded.end.getTime() - expanded.start.getTime()).toBe(2 * DAY_MS);
-    expect(compositeViewportHasObservations([data], expanded)).toBe(false);
+    expect(clampCompositeViewport(frame, viewport(5, 12))).toEqual(viewport(2, 9));
+    expect(clampCompositeViewport(frame, viewport(0, 30))).toEqual(viewport(1, 9));
+    // An observation-free window keeps its date axis so navigation can bring
+    // it back; fitting it to the data would silently teleport the chart.
+    expect(clampCompositeViewport(frame, viewport(20, 30))).toEqual(viewport(20, 30));
+    expect(fitCompositeViewport(frame, viewport(20, 30))).toEqual(viewport(1, 9));
   });
 
   test("keeps live viewport drift but resets deliberate range/window changes", () => {
@@ -243,10 +200,19 @@ describe("composite chart interactions", () => {
     expect(resolveCompositeChartInteraction({ name: "z" })).toBeNull();
   });
 
-  test("maps wheel directions to bounded horizontal pan increments", () => {
-    expect(resolveCompositeWheelPanRatio("up", 1)).toBe(0.005);
-    expect(resolveCompositeWheelPanRatio("left", 100)).toBe(0.04);
-    expect(resolveCompositeWheelPanRatio("down", 100)).toBe(-0.04);
-    expect(resolveCompositeWheelPanRatio("right", 0)).toBe(-0.005);
+  test("pans by the pixels travelled on pixel hosts and by bounded notches elsewhere", () => {
+    // A diagonal swipe sums both axes instead of flickering between them.
+    expect(resolveCompositeWheelPan({ direction: "right", delta: 30, deltaX: 30, deltaY: 10 }, 400)).toBe(-0.1);
+    expect(resolveCompositeWheelPan({ direction: "up", delta: 20, deltaX: 0, deltaY: -20 }, 400)).toBe(0.05);
+    expect(resolveCompositeWheelPan({ direction: "up", delta: 1 }, 400)).toBe(0.005);
+    expect(resolveCompositeWheelPan({ direction: "left", delta: 100 }, 400)).toBe(0.04);
+    expect(resolveCompositeWheelPan({ direction: "right", delta: 0 }, 400)).toBe(-0.005);
+  });
+
+  test("zooms continuously from pinch deltas and by fixed steps from notches", () => {
+    expect(resolveCompositeWheelZoom({ direction: "up", delta: 16, deltaX: 0, deltaY: -16 })).toBeCloseTo(Math.exp(0.1), 6);
+    expect(resolveCompositeWheelZoom({ direction: "down", delta: 1_000, deltaX: 0, deltaY: 1_000 })).toBeCloseTo(1 / 1.5, 6);
+    expect(resolveCompositeWheelZoom({ direction: "up", delta: 4 })).toBeCloseTo(1.16, 6);
+    expect(resolveCompositeWheelZoom({ direction: "down", delta: 100 })).toBeCloseTo(1 / 1.32, 6);
   });
 });