gloomberb 0.10.3 → 0.10.4

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

@@ -11,11 +11,7 @@ import {
   zoomCompositeViewport,
   type CompositeViewportRange,
 } from "./interactions";
-import {
-  buildCompositeTimeScale,
-  projectCompositeTimestamp,
-} from "./time-scale";
-
+import { buildCompositeTimeScale, projectCompositeTimestamp } from "./time-scale";
 const DAY_MS = 24 * 60 * 60 * 1000;
 
 function point(day: number): TimeSeriesPoint {
@@ -69,6 +65,18 @@ function intradayMarketSeries(): ResolvedSeries {
   };
 }
 
+function marketSlotSpan(
+  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;
+}
+
 describe("composite chart interactions", () => {
   test("zooms around the right edge and clamps zoom-out to loaded bounds", () => {
     const bounds = viewport(1, 11);
@@ -91,27 +99,21 @@ describe("composite chart interactions", () => {
     expect(clampedNewer).toEqual(viewport(7, 11));
   });
 
-  test("keeps the same market-slot span while panning across a closed session", () => {
+  test("never changes the visible slot count while panning across a closed session", () => {
     const data = intradayMarketSeries();
     const bounds = resolveCompositeNavigationBounds([data])!;
-    const visible = {
+    let visible: CompositeViewportRange = {
       start: new Date("2025-01-03T13:30:00.000Z"),
       end: new Date("2025-01-03T17:00:00.000Z"),
     };
-    const panned = panCompositeViewport(visible, bounds, 0.5, [data]);
-    const scale = buildCompositeTimeScale(
-      [data],
-      bounds.start.getTime(),
-      bounds.end.getTime(),
-    );
-    const projectedSpan = (window: CompositeViewportRange) => (
-      projectCompositeTimestamp(scale, window.end.getTime())!.ratio
-      - projectCompositeTimestamp(scale, window.start.getTime())!.ratio
-    );
+    const slots = marketSlotSpan(data, bounds, visible);
 
-    expect(panned.end.getTime() - panned.start.getTime())
-      .not.toBe(visible.end.getTime() - visible.start.getTime());
-    expect(Math.abs(projectedSpan(panned) - projectedSpan(visible))).toBeLessThan(1e-12);
+    // 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);
+    }
   });
 
   test("uses representative cadence instead of a stray fine gap as the zoom floor", () => {
@@ -126,11 +128,49 @@ describe("composite chart interactions", () => {
     expect(resolveCompositeNavigationBounds([data], viewport(5, 9))).toEqual(viewport(1, 9));
   });
 
-  test("clamps overlapping requested bounds to real data but preserves disjoint requests", () => {
+  test("reserves an older unloaded window without extending into the future", () => {
+    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));
+  });
+
+  test("enters unloaded history from a full market-session viewport without changing span", () => {
+    const data = intradayMarketSeries();
+    const requested = {
+      start: data.points[0]!.date,
+      end: data.points.at(-1)!.date,
+    };
+    const bounds = resolveCompositeNavigationBounds(
+      [data],
+      requested,
+      { historicalPaddingRatio: 1 },
+    )!;
+
+    const older = panCompositeViewport(requested, bounds, 1, [data], true);
+    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));
-    expect(resolveCompositeNavigationBounds([data], viewport(20, 30))).toEqual(viewport(20, 30));
+    // 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));
   });
 
   test("requires distinct renderable observations inside a viewport", () => {
@@ -187,6 +227,22 @@ describe("composite chart interactions", () => {
     expect(resolveCompositeChartInteraction({ name: "-", targetEditable: true })).toBeNull();
   });
 
+  test("arms chart tools from either shifted key encoding", () => {
+    // Kitty keyboard protocol reports the modifier; legacy terminals only send
+    // the uppercase letter.
+    expect(resolveCompositeChartInteraction({ name: "m", shift: true })).toBe("arm-measure");
+    expect(resolveCompositeChartInteraction({ name: "M", sequence: "M" })).toBe("arm-measure");
+    expect(resolveCompositeChartInteraction({ name: "z", shift: true })).toBe("arm-zoom");
+    expect(resolveCompositeChartInteraction({ name: "Z", sequence: "Z" })).toBe("arm-zoom");
+    expect(resolveCompositeChartInteraction({ name: "d", shift: true })).toBe("arm-line");
+    expect(resolveCompositeChartInteraction({ name: "P", sequence: "P" })).toBe("arm-pencil");
+    expect(resolveCompositeChartInteraction({ name: "backspace" })).toBe("delete-drawing");
+    expect(resolveCompositeChartInteraction({ name: "c" })).toBe("cycle-colour");
+    // Unshifted m and z stay with the pane that already owns them.
+    expect(resolveCompositeChartInteraction({ name: "m" })).toBeNull();
+    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);

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

@@ -11,11 +11,17 @@ export interface CompositeViewportRange {
 }
 
 export type CompositeChartInteraction =
+  | "arm-line"
+  | "arm-measure"
+  | "arm-pencil"
+  | "arm-zoom"
+  | "cycle-colour"
   | "clear-cursor"
   | "cursor-left"
   | "cursor-right"
   | "pan-left"
   | "pan-right"
+  | "delete-drawing"
   | "reset"
   | "zoom-in"
   | "zoom-out";
@@ -100,6 +106,7 @@ export function compositeViewportHasObservations(
 export function resolveCompositeNavigationBounds(
   series: ResolvedSeries[],
   requestedViewport?: CompositeViewportRange | null,
+  options: { historicalPaddingRatio?: number } = {},
 ): CompositeViewportRange | null {
   const requested = normalizeViewport(requestedViewport);
   const timestamps = pointTimestamps(series);
@@ -113,9 +120,22 @@ export function resolveCompositeNavigationBounds(
   const overlapsData = requested.end.getTime() >= data.start.getTime()
     && requested.start.getTime() <= data.end.getTime();
   // Loaded series can include a buffer outside the authored viewport. Use the
-  // complete real-data extent when the two ranges overlap, but do not clamp a
-  // newly authored, disjoint request to stale observations.
-  return overlapsData ? data : requested;
+  // complete real-data extent when the two ranges overlap. A disjoint request
+  // keeps its own window, unioned with the data so navigation can always get
+  // back: bounds equal to an observation-free window strand pan and zoom.
+  if (!overlapsData) {
+    return {
+      start: new Date(Math.min(data.start.getTime(), requested.start.getTime())),
+      end: new Date(Math.max(data.end.getTime(), requested.end.getTime())),
+    };
+  }
+  const paddingRatio = Math.max(options.historicalPaddingRatio ?? 0, 0);
+  if (paddingRatio === 0) return data;
+  const requestedSpan = Math.max(requested.end.getTime() - requested.start.getTime(), 1);
+  return {
+    start: new Date(Math.min(data.start.getTime(), requested.start.getTime()) - requestedSpan * paddingRatio),
+    end: data.end,
+  };
 }
 
 export function resolveCompositeMinimumSpanMs(
@@ -305,34 +325,32 @@ export function panCompositeViewport(
   bounds: CompositeViewportRange,
   shiftRatio: number,
   series?: ResolvedSeries[],
+  allowEmpty = false,
 ): CompositeViewportRange {
   const current = clampCompositeViewport(viewport, bounds);
   if (!Number.isFinite(shiftRatio) || shiftRatio === 0) return current;
   const marketProjection = marketViewportProjection(current, bounds, series);
+  // Market scales collapse overnight and weekend gaps, so a wall-clock shift
+  // changes how many slots stay visible and the plot accordions instead of
+  // translating. Shift in slot space so the visible span is preserved.
   const candidate = marketProjection
     ? (() => {
-        const {
-          scale,
-          startRatio,
-          endRatio,
-        } = marketProjection;
-        const span = endRatio - startRatio;
-        const nextStart = clamp(
-          startRatio - span * shiftRatio,
-          0,
-          1 - span,
+        const { scale, startRatio, endRatio } = marketProjection;
+        const marketSpan = endRatio - startRatio;
+        const nextStart = clamp(startRatio - marketSpan * shiftRatio, 0, 1 - marketSpan);
+        return clampCompositeViewport(
+          viewportFromMarketRatios(scale, nextStart, nextStart + marketSpan),
+          bounds,
         );
-        return viewportFromMarketRatios(scale, nextStart, nextStart + span);
       })()
     : (() => {
-        const span = Math.max(current.end.getTime() - current.start.getTime(), 1);
-        const shift = span * shiftRatio;
+        const shift = Math.max(current.end.getTime() - current.start.getTime(), 1) * shiftRatio;
         return clampCompositeViewport({
           start: new Date(current.start.getTime() - shift),
           end: new Date(current.end.getTime() - shift),
         }, bounds);
       })();
-  if (!series) return candidate;
+  if (!series || allowEmpty) return candidate;
 
   const timestamps = pointTimestamps(series)
     .filter((timestamp) => timestamp >= bounds.start.getTime() && timestamp <= bounds.end.getTime());
@@ -403,6 +421,16 @@ export function resolveCompositeChartInteraction(event: {
   const key = (name || sequence).toLowerCase();
   if (key === "left") return event.shift ? "pan-left" : "cursor-left";
   if (key === "right") return event.shift ? "pan-right" : "cursor-right";
+  // Terminals reserve shift-drag and option-drag for their own selection, so the
+  // pointer tools also need a keyboard path that always reaches the app. Without
+  // the kitty keyboard protocol a shifted letter arrives uppercase and unflagged.
+  const shifted = event.shift || name === name.toUpperCase() && name !== key;
+  if (shifted && key === "m") return "arm-measure";
+  if (shifted && key === "z") return "arm-zoom";
+  if (shifted && key === "d") return "arm-line";
+  if (shifted && key === "p") return "arm-pencil";
+  if (key === "backspace") return "delete-drawing";
+  if (key === "c" && !event.shift) return "cycle-colour";
   if (event.shift) return null;
   if (key === "a") return "pan-left";
   if (key === "d") return "pan-right";

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

@@ -2,6 +2,7 @@ import type { NativeChartBitmap } from "../native/chart-rasterizer";
 import {
   drawCircle,
   drawLine,
+  fillOpaque,
   fillRect,
   parseHex,
   type RgbaColor,
@@ -250,7 +251,12 @@ function drawOhlc(
   const candleWidth = resolveCompositeOhlcWidth(series.points, width);
   for (const projected of series.points) {
     const source = projected.point;
-    const x = pixelPoint(projected, width, height).x;
+    const halfWidth = Math.min(candleWidth / 2, Math.max(width - 1, 0) / 2);
+    const x = clamp(
+      pixelPoint(projected, width, height).x,
+      halfWidth,
+      Math.max(width - 1 - halfWidth, halfWidth),
+    );
     const close = source.close ?? projected.value;
     const open = source.open ?? close;
     const high = source.high ?? Math.max(open, close);
@@ -292,7 +298,7 @@ export function renderCompositePanelBitmap(
   const background = parseHex(options.colors.background);
   const grid = parseHex(options.colors.grid);
   const negative = parseHex(options.colors.negative);
-  fillRect(data, width, height, 0, 0, width - 1, height - 1, background, 1);
+  fillOpaque(data, background);
 
   for (let index = 1; index <= 3; index += 1) {
     const y = (height - 1) * (index / 4);

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

@@ -7,7 +7,7 @@ import {
   resolveCompositeOhlcWidth,
 } from "./rasterizer";
 import { buildCompositeColumnLayout } from "./column-layout";
-import { buildCompositeChartScene } from "./scene";
+import { buildCompositeChartScene, projectCompositeValue } from "./scene";
 import {
   renderCompositePanelText,
   resolveCompositeTextOhlcWidth,
@@ -678,6 +678,66 @@ describe("composite chart renderers", () => {
     expect(zoomedText).toContain("█████");
   });
 
+  test("keeps the first and last candle bodies fully inside the bitmap", () => {
+    const candles = series("price", "candles", [], "left", "#00ff66");
+    candles.points = ["2025-01-01", "2025-01-02", "2025-01-03"].map((date) => ({
+      ...point(date, 10),
+      open: 8,
+      high: 13,
+      low: 7,
+      close: 10,
+    }));
+    const scene = buildCompositeChartScene(
+      [candles],
+      [{ id: "main" }],
+      {
+        width: 81,
+        height: 9,
+        viewport: {
+          start: new Date("2025-01-01T00:00:00.000Z"),
+          end: new Date("2025-01-03T00:00:00.000Z"),
+        },
+      },
+    )!;
+    const panel = scene.panels[0]!;
+    const bitmap = renderCompositePanelBitmap(panel, {
+      pixelWidth: 101,
+      pixelHeight: 51,
+      colors: {
+        background: "#000000",
+        grid: "#202020",
+        crosshair: "#ffffff",
+        text: "#eeeeee",
+        textDim: "#999999",
+        negative: "#ff0000",
+      },
+    });
+    const domain = panel.axes.left!;
+    const bodyYRatio = (
+      projectCompositeValue(8, domain)!
+      + projectCompositeValue(10, domain)!
+    ) / 2;
+    const bodyY = Math.round(bodyYRatio * (bitmap.height - 1));
+    const coloredColumns = Array.from({ length: bitmap.width }, (_, x) => x)
+      .filter((x) => {
+        const offset = (bodyY * bitmap.width + x) * 4;
+        return bitmap.pixels[offset]! < 20
+          && bitmap.pixels[offset + 1]! > 220
+          && bitmap.pixels[offset + 2]! > 70;
+      });
+    const runs: number[][] = [];
+    for (const x of coloredColumns) {
+      const last = runs.at(-1);
+      if (last?.at(-1) === x - 1) last.push(x);
+      else runs.push([x]);
+    }
+
+    expect(runs).toHaveLength(3);
+    expect(runs.map((run) => run.length)).toEqual([13, 13, 13]);
+    expect(runs[0]?.[0]).toBe(0);
+    expect(runs.at(-1)?.at(-1)).toBe(bitmap.width - 1);
+  });
+
   test("marks a standalone line observation without extending it through time", () => {
     const scene = buildCompositeChartScene(
       [series("estimate", "line", [42], "left")],

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

@@ -431,10 +431,15 @@ export function buildCompositeChartScene(
     startTime,
     endTime,
   );
-  const usableSeries = viewport
+  const scopedSeries = viewport
     ? dataSeries.flatMap((entry) => scopeSeriesToViewport(entry, startTime, endTime, timeScale) ?? [])
     : dataSeries;
-  if (usableSeries.length === 0) return null;
+  // A range without observations still has a chart: keep the panels, axes and
+  // grid and simply draw no points, instead of blanking the whole surface.
+  const emptyRange = scopedSeries.length === 0;
+  const usableSeries = emptyRange
+    ? dataSeries.map((entry) => ({ ...entry, points: [] }))
+    : scopedSeries;
   const visibleTimes = uniqueTimes.filter((time) => time >= startTime && time <= endTime);
   const marketTimes = timeScale.kind === "market"
     ? timeScale.anchors
@@ -463,8 +468,13 @@ export function buildCompositeChartScene(
     const panelSeries = usableSeries.filter((entry) => entry.panelId === panel.id);
     if (panelSeries.length === 0) return [];
     const scale = panel.scale ?? "linear";
-    const left = buildAxisDomain("left", panelSeries, scale);
-    const right = buildAxisDomain("right", panelSeries, scale);
+    // An empty range has no in-view values, so scale its axes to the loaded
+    // history rather than the meaningless 0..1 fallback.
+    const domainSeries = emptyRange
+      ? dataSeries.filter((entry) => entry.panelId === panel.id)
+      : panelSeries;
+    const left = buildAxisDomain("left", domainSeries, scale);
+    const right = buildAxisDomain("right", domainSeries, scale);
     const axes: Partial<Record<CompositeAxisSide, CompositeAxisDomain>> = { left, right };
     return [{
       id: panel.id,