gloomberb 0.11.2 → 0.12.0

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

@@ -49,12 +49,31 @@ function pointTimestampForScale(
     : timestamp;
 }
 
-function normalizedSourcePoints(series: ResolvedSeries, timeScale?: CompositeTimeScale): Array<{
+interface NormalizedSourcePoint {
   point: TimeSeriesPoint;
   timestamp: number;
   value: number | null;
-}> {
-  const bySourceTimestamp = new Map<number, { point: TimeSeriesPoint; timestamp: number; value: number | null }>();
+}
+
+interface NormalizedPointsCache {
+  points: readonly TimeSeriesPoint[];
+  pointCount: number;
+  last: TimeSeriesPoint | undefined;
+  lastTimestamp: number | null;
+  lastValue: number | null;
+  byPlacement: Map<boolean, NormalizedSourcePoint[]>;
+}
+
+// Every scene build normalises each series several times over; a viewport
+// change must not re-sort thousands of unchanged points. Live ticks mutate
+// the last point in place, so the cache also keys on its time and value.
+const normalizedPointsCache = new WeakMap<ResolvedSeries, NormalizedPointsCache>();
+
+function computeNormalizedSourcePoints(
+  series: ResolvedSeries,
+  timeScale?: CompositeTimeScale,
+): NormalizedSourcePoint[] {
+  const bySourceTimestamp = new Map<number, NormalizedSourcePoint>();
   for (const point of series.points) {
     const sourceTimestamp = pointTime(point);
     const timestamp = pointTimestampForScale(series, point, timeScale);
@@ -71,6 +90,41 @@ function normalizedSourcePoints(series: ResolvedSeries, timeScale?: CompositeTim
   ));
 }
 
+function normalizedSourcePoints(
+  series: ResolvedSeries,
+  timeScale?: CompositeTimeScale,
+): NormalizedSourcePoint[] {
+  const effectiveTimes = timeScale?.kind === "market" && !series.timeBasis;
+  const last = series.points[series.points.length - 1];
+  const lastTimestamp = last ? pointTime(last) : null;
+  const lastValue = last ? resolveTimeSeriesPointValue(last) : null;
+  let cached = normalizedPointsCache.get(series);
+  if (
+    !cached
+    || cached.points !== series.points
+    || cached.pointCount !== series.points.length
+    || cached.last !== last
+    || cached.lastTimestamp !== lastTimestamp
+    || cached.lastValue !== lastValue
+  ) {
+    cached = {
+      points: series.points,
+      pointCount: series.points.length,
+      last,
+      lastTimestamp,
+      lastValue,
+      byPlacement: new Map(),
+    };
+    normalizedPointsCache.set(series, cached);
+  }
+  let normalized = cached.byPlacement.get(effectiveTimes);
+  if (!normalized) {
+    normalized = computeNormalizedSourcePoints(series, timeScale);
+    cached.byPlacement.set(effectiveTimes, normalized);
+  }
+  return normalized;
+}
+
 function normalizedPoints(series: ResolvedSeries): Array<{
   point: TimeSeriesPoint;
   timestamp: number;

package/src/components/chart/composite/text-renderer.ts

@@ -1,4 +1,4 @@
-import { compositeAxisTicks } from "./format";
+import { compositeAxisTicks, type CompositeAxisValueFormatter } from "./format";
 import type { CompositeViewportRange } from "./interactions";
 import { resolveCompositeObservationWidth } from "./rasterizer";
 import { buildCompositeColumnLayout, type CompositeColumnLayout } from "./column-layout";
@@ -274,10 +274,11 @@ export function renderCompositeAxisText(
   height: number,
   width: number,
   side: "left" | "right",
+  format?: CompositeAxisValueFormatter,
 ): string[] {
   const rows = Array.from({ length: Math.max(1, height) }, () => " ".repeat(Math.max(0, width)));
   if (!domain || width <= 0) return rows;
-  for (const tick of compositeAxisTicks(domain)) {
+  for (const tick of compositeAxisTicks(domain, 3, format)) {
     const row = clamp(Math.round(tick.ratio * Math.max(height - 1, 0)), 0, Math.max(height - 1, 0));
     const label = tick.label.length > width ? tick.label.slice(0, width) : tick.label;
     rows[row] = side === "left" ? label.padStart(width) : label.padEnd(width);

package/src/components/chart/composite/time-scale.ts

@@ -2,8 +2,27 @@ import type { ResolvedSeries } from "../../../time-series/types";
 import type { CompositeTimeScale } from "./types";
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
+const QUARTER_HOUR_MS = 15 * 60 * 1_000;
 const MINIMUM_SLOT_FRACTION = 0.25;
 const dateFormatters = new Map<string, Intl.DateTimeFormat>();
+// Session dates are looked up once per quarter hour, not once per bar: a day
+// of one-minute bars asks the same question hundreds of times.
+const sessionDateBuckets = new Map<string, Map<number, string>>();
+const SESSION_DATE_BUCKET_LIMIT = 200_000;
+
+type MarketAnchors = Extract<CompositeTimeScale, { kind: "market" }>["anchors"];
+
+interface CachedMarketAnchors {
+  points: readonly ResolvedSeries["points"][number][];
+  pointCount: number;
+  lastTimestamp: number | null;
+  timeZone: string;
+  configuredCadence: number | undefined;
+  cadenceMs: number;
+  anchors: MarketAnchors;
+}
+
+const anchorCache = new WeakMap<ResolvedSeries, CachedMarketAnchors>();
 
 function finiteTimestamp(value: Date): number | null {
   const timestamp = value.getTime();
@@ -31,7 +50,7 @@ function formatterFor(timeZone: string): Intl.DateTimeFormat {
   return formatter;
 }
 
-function sessionDate(timestamp: number, timeZone: string): string {
+function formatSessionDate(timestamp: number, timeZone: string): string {
   try {
     const parts = formatterFor(timeZone).formatToParts(new Date(timestamp));
     const year = parts.find((part) => part.type === "year")?.value;
@@ -44,6 +63,23 @@ function sessionDate(timestamp: number, timeZone: string): string {
   return new Date(timestamp).toISOString().slice(0, 10);
 }
 
+function sessionDate(timestamp: number, timeZone: string): string {
+  // Every IANA offset is a multiple of fifteen minutes, so local midnight
+  // always lands on a bucket edge and one bucket never spans two sessions.
+  let buckets = sessionDateBuckets.get(timeZone);
+  if (!buckets) {
+    buckets = new Map();
+    sessionDateBuckets.set(timeZone, buckets);
+  }
+  const bucket = Math.floor(timestamp / QUARTER_HOUR_MS);
+  const cached = buckets.get(bucket);
+  if (cached !== undefined) return cached;
+  const date = formatSessionDate(timestamp, timeZone);
+  if (buckets.size >= SESSION_DATE_BUCKET_LIMIT) buckets.clear();
+  buckets.set(bucket, date);
+  return date;
+}
+
 function median(values: readonly number[]): number | null {
   const sorted = values.filter((value) => Number.isFinite(value) && value > 0)
     .sort((left, right) => left - right);
@@ -55,7 +91,7 @@ function median(values: readonly number[]): number | null {
 }
 
 function lowerBoundAnchor(
-  anchors: Extract<CompositeTimeScale, { kind: "market" }>["anchors"],
+  anchors: MarketAnchors,
   timestamp: number,
 ): number {
   let low = 0;
@@ -69,7 +105,7 @@ function lowerBoundAnchor(
 }
 
 function positionForTimestamp(
-  scale: Extract<CompositeTimeScale, { kind: "market" }>,
+  scale: Pick<Extract<CompositeTimeScale, { kind: "market" }>, "anchors" | "cadenceMs">,
   timestamp: number,
 ): number {
   const { anchors, cadenceMs } = scale;
@@ -90,69 +126,134 @@ function positionForTimestamp(
     + (next.position - previous.position) * ((timestamp - previous.timestamp) / elapsed);
 }
 
-export function buildCompositeTimeScale(
-  timelineSeries: readonly ResolvedSeries[],
-  startTime: number,
-  endTime: number,
-): CompositeTimeScale {
-  const anchorSeries = timelineSeries.find((series) => series.timeBasis?.kind === "market");
-  const anchorTimestamps = anchorSeries ? uniqueSeriesTimestamps(anchorSeries) : [];
-  if (!anchorSeries?.timeBasis || anchorTimestamps.length === 0) {
-    return { kind: "calendar", startTime, endTime };
-  }
-
-  const { timeZone } = anchorSeries.timeBasis;
+function buildMarketAnchors(series: ResolvedSeries, timeZone: string): {
+  cadenceMs: number;
+  anchors: MarketAnchors;
+} {
+  const anchorTimestamps = uniqueSeriesTimestamps(series);
+  const sessionDates = anchorTimestamps.map((timestamp) => sessionDate(timestamp, timeZone));
   const sameSessionGaps: number[] = [];
   const allGaps: number[] = [];
   for (let index = 1; index < anchorTimestamps.length; index += 1) {
-    const previous = anchorTimestamps[index - 1]!;
-    const next = anchorTimestamps[index]!;
-    const gap = next - previous;
+    const gap = anchorTimestamps[index]! - anchorTimestamps[index - 1]!;
     if (gap <= 0) continue;
     allGaps.push(gap);
-    if (sessionDate(previous, timeZone) === sessionDate(next, timeZone)) {
-      sameSessionGaps.push(gap);
-    }
+    if (sessionDates[index - 1] === sessionDates[index]) sameSessionGaps.push(gap);
   }
-  const configuredCadence = anchorSeries.timeBasis.cadenceMs;
+  const configuredCadence = series.timeBasis?.cadenceMs;
   const cadenceMs = typeof configuredCadence === "number"
     && Number.isFinite(configuredCadence)
     && configuredCadence > 0
     ? configuredCadence
     : median(sameSessionGaps) ?? median(allGaps) ?? DAY_MS;
 
-  const anchors: Extract<CompositeTimeScale, { kind: "market" }>["anchors"] = [];
+  const anchors: MarketAnchors = [];
   let position = 0;
   anchorTimestamps.forEach((timestamp, index) => {
     if (index > 0) {
       const previous = anchorTimestamps[index - 1]!;
-      const sameSession = sessionDate(previous, timeZone) === sessionDate(timestamp, timeZone);
-      position += sameSession
+      position += sessionDates[index - 1] === sessionDates[index]
         ? Math.max((timestamp - previous) / cadenceMs, MINIMUM_SLOT_FRACTION)
         : 1;
     }
     anchors.push({ timestamp, position });
   });
+  return { cadenceMs, anchors };
+}
+
+/**
+ * Anchor slots for a market series, cached on the series object. Live ticks
+ * mutate the last point in place, so the cache also keys on the point count
+ * and the last timestamp.
+ */
+function resolveMarketAnchors(
+  series: ResolvedSeries,
+): { cadenceMs: number; anchors: MarketAnchors; timeZone: string } | null {
+  if (!series.timeBasis || series.timeBasis.kind !== "market") return null;
+  const { timeZone, cadenceMs: configuredCadence } = series.timeBasis;
+  const lastTimestamp = series.points.length > 0
+    ? finiteTimestamp(series.points[series.points.length - 1]!.date)
+    : null;
+  const cached = anchorCache.get(series);
+  if (
+    cached
+    && cached.points === series.points
+    && cached.pointCount === series.points.length
+    && cached.lastTimestamp === lastTimestamp
+    && cached.timeZone === timeZone
+    && cached.configuredCadence === configuredCadence
+  ) {
+    return { cadenceMs: cached.cadenceMs, anchors: cached.anchors, timeZone };
+  }
+  const built = buildMarketAnchors(series, timeZone);
+  anchorCache.set(series, {
+    points: series.points,
+    pointCount: series.points.length,
+    lastTimestamp,
+    timeZone,
+    configuredCadence,
+    cadenceMs: built.cadenceMs,
+    anchors: built.anchors,
+  });
+  return { ...built, timeZone };
+}
 
-  const provisional: Extract<CompositeTimeScale, { kind: "market" }> = {
+export function buildCompositeTimeScale(
+  timelineSeries: readonly ResolvedSeries[],
+  startTime: number,
+  endTime: number,
+): CompositeTimeScale {
+  const anchorSeries = timelineSeries.find((series) => series.timeBasis?.kind === "market");
+  const resolved = anchorSeries ? resolveMarketAnchors(anchorSeries) : null;
+  if (!anchorSeries || !resolved || resolved.anchors.length === 0) {
+    return { kind: "calendar", startTime, endTime };
+  }
+  const { cadenceMs, anchors } = resolved;
+  const startPosition = positionForTimestamp({ anchors, cadenceMs }, startTime);
+  const endPosition = positionForTimestamp({ anchors, cadenceMs }, endTime);
+  return {
     kind: "market",
     startTime,
     endTime,
     anchorSeriesId: anchorSeries.id,
     cadenceMs,
     anchors,
-    startPosition: 0,
-    endPosition: 1,
-  };
-  const startPosition = positionForTimestamp(provisional, startTime);
-  const endPosition = positionForTimestamp(provisional, endTime);
-  return {
-    ...provisional,
     startPosition,
     endPosition: endPosition > startPosition ? endPosition : startPosition + 1,
   };
 }
 
+/** Slot position of a timestamp on a market scale, or wall-clock time on a calendar scale. */
+export function compositeTimePosition(scale: CompositeTimeScale, timestamp: number): number {
+  return scale.kind === "calendar" ? timestamp : positionForTimestamp(scale, timestamp);
+}
+
+/** Inverse of `compositeTimePosition`. */
+export function compositeTimeAtPosition(scale: CompositeTimeScale, position: number): number {
+  if (scale.kind === "calendar") return position;
+  const anchors = scale.anchors;
+  let low = 0;
+  let high = anchors.length;
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2);
+    if (anchors[middle]!.position < position) low = middle + 1;
+    else high = middle;
+  }
+  const next = anchors[low];
+  const previous = anchors[low - 1];
+  if (!previous) {
+    return anchors[0]!.timestamp + (position - anchors[0]!.position) * scale.cadenceMs;
+  }
+  if (!next) {
+    const last = anchors.at(-1)!;
+    return last.timestamp + (position - last.position) * scale.cadenceMs;
+  }
+  const positionSpan = next.position - previous.position;
+  if (positionSpan <= 0) return previous.timestamp;
+  return previous.timestamp
+    + (next.timestamp - previous.timestamp) * ((position - previous.position) / positionSpan);
+}
+
 export function projectCompositeTimestamp(
   scale: CompositeTimeScale,
   timestamp: number,
@@ -190,28 +291,8 @@ export function unprojectCompositeTimestamp(
   if (scale.kind === "calendar") {
     return scale.startTime + (scale.endTime - scale.startTime) * safeRatio;
   }
-  const targetPosition = scale.startPosition
-    + (scale.endPosition - scale.startPosition) * safeRatio;
-  const anchors = scale.anchors;
-  let low = 0;
-  let high = anchors.length;
-  while (low < high) {
-    const middle = low + Math.floor((high - low) / 2);
-    if (anchors[middle]!.position < targetPosition) low = middle + 1;
-    else high = middle;
-  }
-  const next = anchors[low];
-  const previous = anchors[low - 1];
-  if (!previous) {
-    return anchors[0]!.timestamp + (targetPosition - anchors[0]!.position) * scale.cadenceMs;
-  }
-  if (!next) {
-    const last = anchors.at(-1)!;
-    return last.timestamp + (targetPosition - last.position) * scale.cadenceMs;
-  }
-  const positionSpan = next.position - previous.position;
-  if (positionSpan <= 0) return previous.timestamp;
-  return previous.timestamp
-    + (next.timestamp - previous.timestamp)
-      * ((targetPosition - previous.position) / positionSpan);
+  return compositeTimeAtPosition(
+    scale,
+    scale.startPosition + (scale.endPosition - scale.startPosition) * safeRatio,
+  );
 }

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

@@ -111,6 +111,23 @@ export interface BuildCompositeChartSceneOptions {
   timelineSeries?: ResolvedSeries[];
 }
 
+export interface CompositeChartXMarker {
+  id: string;
+  xRatio: number;
+  label?: string;
+  color?: string;
+  lineChar?: string;
+}
+
+/** Replaces the date axis for charts whose x is not time: a fraction, a tenor, a return. */
+export interface CompositeChartXAxis {
+  /** Evenly spread labels drawn instead of date ticks. */
+  labels?: readonly string[];
+  /** Vertical guide lines through the plot, captioned below the axis. */
+  markers?: readonly CompositeChartXMarker[];
+  formatCursor?: (xRatio: number) => string;
+}
+
 export interface CompositeChartProps {
   series: ResolvedSeries[];
   /** Optional legend model; can include hidden series that are not plotted. */
@@ -122,6 +139,13 @@ export interface CompositeChartProps {
   height: number;
   focused?: boolean;
   interactive?: boolean;
+  /** False keeps the hover cursor but removes pan, zoom, tools, and navigation keys. */
+  navigable?: boolean;
+  /** Overrides the unit-derived tick and cursor labels on both value axes. */
+  formatAxisValue?: (value: number, domain: CompositeAxisDomain) => string;
+  xAxis?: CompositeChartXAxis;
+  /** Tagged onto the plot's semantic node so remote clients can find this chart. */
+  remoteKind?: string;
   /** Permit panning into an older unloaded window so the owner can backfill it. */
   allowHistoricalBackfill?: boolean;
   cursorDate?: Date | null;
@@ -148,7 +172,7 @@ export interface CompositeChartProps {
   /** Reports a user-created viewport, or null when the user resets to the authored viewport. */
   onViewportChange?: (
     viewport: { start: Date; end: Date } | null,
-    interaction: "pan" | "reset" | "sync" | "zoom",
+    interaction: "pan" | "reset" | "zoom",
   ) => void;
   onActivate?: () => void;
   onToggleSeries?: (seriesId: string) => void;

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

@@ -1,13 +1,9 @@
-export { appendLiveQuotePoint } from "../../../time-series/chart-data";
-export type { AppendLiveQuotePointOptions } from "../../../time-series/chart-data";
-export {
-  bucketOhlcSeries,
-  projectChartData,
-  resolveRenderMode,
-  resolveStableOhlcProjectionOptions,
-} from "./projection";
-export type {
-  ChartProjection,
-  ProjectChartDataOptions,
-  ProjectedChartPoint,
-} from "./projection";
+/** One observation of a simple, non-navigable chart: a value with optional bar extremes. */
+export interface ProjectedChartPoint {
+  date: Date;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+  volume: number;
+}

package/src/components/chart/core/date-window.ts

@@ -1,5 +1,11 @@
 import type { PricePoint } from "../../../types/financials";
-import type { TimeRange, VisibleWindow } from "./types";
+import type { TimeRange } from "./types";
+
+export interface VisibleWindow {
+  points: PricePoint[];
+  startIdx: number;
+  endIdx: number;
+}
 import type { DateWindowRange } from "../../../time-series/date-window";
 import { subtractTimeRange } from "../../../time-series/date-window";
 

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

@@ -34,6 +34,9 @@ export interface ChartMouseEvent {
   scroll?: {
     direction: "up" | "down" | "left" | "right";
     delta: number;
+    /** Signed pixel travel on hosts that report it; terminals report notches only. */
+    deltaX?: number;
+    deltaY?: number;
   };
 }
 

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

@@ -1,26 +1,11 @@
-import type { PricePoint } from "../../../types/financials";
 export type { ChartResolution, TimeRange } from "../../../time-series/range";
 
 export type ChartRenderMode = "area" | "line" | "candles" | "ohlc" | "hlc";
-export type ChartAxisMode = "price" | "percent";
 export type ChartRendererPreference = "auto" | "kitty" | "braille";
 export type ResolvedChartRenderer = "kitty" | "braille";
-export type ChartSessionBackgroundKind = "pre" | "post";
 
 export const CHART_RENDERER_PREFERENCES: ChartRendererPreference[] = ["auto", "kitty", "braille"];
 
-export interface Pixel {
-  color: string;
-  layer: number;
-}
-
-export interface PixelBuffer {
-  width: number;
-  height: number; // virtual pixel rows (4x terminal rows for braille rendering)
-  pixels: (Pixel | null)[][]; // [y][x] = pixel with color and layer, or null
-  backgrounds: (string | null)[][];
-}
-
 export interface ChartColors {
   lineColor: string;
   fillColor: string;
@@ -35,33 +20,3 @@ export interface ChartColors {
   preMarketBgColor: string;
   postMarketBgColor: string;
 }
-
-export interface ChartMarketSession {
-  timeZone: string;
-  regularStartMinutes: number;
-  regularEndMinutes: number;
-  preMarketStartMinutes: number;
-  postMarketEndMinutes: number;
-}
-
-export interface ChartSessionBackgroundSpan {
-  kind: ChartSessionBackgroundKind;
-  startIndex: number;
-  endIndex: number;
-}
-
-export interface VisibleWindow {
-  points: PricePoint[];
-  startIdx: number;
-  endIdx: number;
-}
-
-import type { OverlayPoint, OscillatorPoint, MacdResult, BollingerResult } from "../indicators/types";
-
-export interface ChartIndicatorOverlays {
-  smaLines: { period: number; points: OverlayPoint[]; color: string }[];
-  emaLines: { period: number; points: OverlayPoint[]; color: string }[];
-  bollinger: (BollingerResult & { color: string }) | null;
-  rsi: OscillatorPoint[] | null;
-  macd: MacdResult | null;
-}

package/src/components/chart/native/chart-rasterizer.ts

@@ -1,5 +1,4 @@
 export { renderCrosshairStrips } from "./raster/crosshair";
-export { renderNativeChartBase } from "./raster/price-chart";
 
 export {
   computeBitmapSize,