gloomberb 0.10.2 → 0.10.4

package/src/time-series/spec-studies.test.ts

@@ -168,6 +168,10 @@ describe("chart spec normalization and validation", () => {
     expect(result.valid).toBe(false);
     expect(result.errors.map(({ code }) => code)).toContain("qoq-annual");
     expect(result.errors.map(({ code }) => code)).toContain("multiple-ohlc");
+    // The blocking series is usually hidden or drawn as a line for lack of OHLC
+    // data, so the message has to name it or it reads as a phantom conflict.
+    expect(result.errors.find(({ code }) => code === "multiple-ohlc")?.message)
+      .toBe("A already uses a candle or OHLC style on main. Give it another style first.");
     expect(result.errors.map(({ code }) => code)).toContain("missing-input");
   });
 

package/src/time-series/spec.ts

@@ -359,6 +359,7 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
 
   const seriesIds = new Set<string>();
   const candleCountByPanel = new Map<string, number>();
+  const firstCandleByPanel = new Map<string, string>();
   const unitGroupsByPanel = new Map<string, Set<string>>();
   const panelScaleById = new Map(spec.panels.map((panel) => [panel.id, panel.scale ?? "linear"] as const));
   spec.series.forEach((entry, index) => {
@@ -435,6 +436,13 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
     if (isOhlcSeriesStyle(entry.style)) {
       const count = (candleCountByPanel.get(entry.panelId) ?? 0) + 1;
       candleCountByPanel.set(entry.panelId, count);
+      if (count === 1) {
+        firstCandleByPanel.set(
+          entry.panelId,
+          entry.label?.trim()
+            || (entry.source.kind === "economic" ? entry.source.seriesId : entry.source.instrument.symbol),
+        );
+      }
       if (entry.transform !== "raw") {
         errors.push(issue(`${path}.transform`, "transformed-ohlc", "OHLC styles require raw values."));
       }
@@ -442,7 +450,13 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
   });
   for (const [panelId, count] of candleCountByPanel) {
     if (count > 1) {
-      errors.push(issue("series", "multiple-ohlc", `Panel ${panelId} may contain only one candle or OHLC series.`));
+      // Name the series holding the slot: it is often hidden or drawn as a line
+      // for lack of OHLC data, so "this panel already has one" reads as a ghost.
+      const panelLabel = spec.panels.find((panel) => panel.id === panelId)?.label ?? panelId;
+      const holder = firstCandleByPanel.get(panelId);
+      errors.push(issue("series", "multiple-ohlc", holder
+        ? `${holder} already uses a candle or OHLC style on ${panelLabel}. Give it another style first.`
+        : `Panel ${panelLabel} may contain only one candle or OHLC series.`));
     }
   }
   for (const [panelId, groups] of unitGroupsByPanel) {

package/src/time-series/types.ts

@@ -1,4 +1,5 @@
 import type { ChartResolution, TimeRange } from "./range";
+import type { ChartResolutionSupport } from "./resolution";
 import type { InstrumentRef } from "../market-data/request-types";
 
 export const CHART_SPEC_VERSION = 1 as const;
@@ -129,8 +130,12 @@ export interface ResolvedSeries {
   interpolation: SeriesInterpolation;
   /** Present only for exchange-traded market observations. */
   timeBasis?: ResolvedSeriesMarketTimeBasis;
+  /** Regular-session move supplied with the latest market quote. */
+  latestChangePercent?: number;
   points: TimeSeriesPoint[];
   warning?: string;
+  /** Listed in the legend so it can be restored, but not drawn. */
+  hidden?: boolean;
 }
 
 export interface TimeSeriesFieldDefinition {
@@ -150,6 +155,8 @@ export interface TimeSeriesFieldDefinition {
 
 export interface ChartResolutionResult {
   series: ResolvedSeries[];
+  /** Provider capabilities shared by every active market series. */
+  resolutionSupport?: ChartResolutionSupport[];
   /** Series available to the legend, including hidden base series that can be restored. */
   legendSeries?: ResolvedSeries[];
   /** Loaded observations retained outside the visible window for interactive navigation. */

package/src/time-series/use-chart-resolution.test.tsx

@@ -103,6 +103,14 @@ function ResolutionHarness({
   return <text>{`${latestResult.loading ? "loading" : "settled"}:${pointCount}`}</text>;
 }
 
+function PollingResolutionHarness({ sources }: { sources: ChartResolveSources }) {
+  latestResult = useChartResolution(SPEC, sources, {
+    liveStreaming: false,
+    quotePollingIntervalMs: 30,
+  });
+  return <text>{latestResult.loading ? "loading" : "settled"}</text>;
+}
+
 async function flushEffects(iterations = 1): Promise<void> {
   for (let iteration = 0; iteration < iterations; iteration += 1) {
     await act(async () => {
@@ -134,6 +142,35 @@ afterEach(async () => {
 });
 
 describe("useChartResolution", () => {
+  test("polls chart data without opening a quote subscription when live streaming is disabled", async () => {
+    let historyCalls = 0;
+    let subscribeCalls = 0;
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => EMPTY_FINANCIALS,
+      getPriceHistoryForResolution: async () => {
+        historyCalls += 1;
+        return INITIAL_HISTORY;
+      },
+      subscribeQuotes: () => {
+        subscribeCalls += 1;
+        return () => {};
+      },
+    });
+    testSetup = await testRender(<PollingResolutionHarness sources={sourcesFor(provider)} />, {
+      width: 24,
+      height: 1,
+    });
+
+    await waitFor(() => historyCalls >= 2 && latestResult?.loading === false);
+    expect(subscribeCalls).toBe(0);
+
+    const callsAfterImmediatePoll = historyCalls;
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 45));
+    });
+    await waitFor(() => historyCalls > callsAfterImmediatePoll);
+  });
+
   test("keeps renderable data settled through empty adaptive and live refreshes", async () => {
     const adaptiveHistory = deferred<PricePoint[]>();
     let detailedCalls = 0;

package/src/time-series/use-chart-resolution.ts

@@ -19,11 +19,15 @@ export interface UseChartResolutionResult extends ChartResolutionResult {
 
 export interface UseChartResolutionOptions {
   liveRefreshIntervalMs?: number;
+  liveStreaming?: boolean;
+  quotePollingIntervalMs?: number;
   autoViewport?: ChartResolveOptions["autoViewport"];
   requestViewport?: ChartResolveOptions["requestViewport"];
   targetPointCount?: number;
 }
 
+const DEFAULT_QUOTE_POLL_INTERVAL_MS = 60_000;
+
 const EMPTY_RESULT: ChartResolutionResult = {
   series: [],
   loading: false,
@@ -150,9 +154,11 @@ export function useChartResolution(
 
   const liveTargetSignature = liveChartQuoteTargetSignature(spec);
   const liveRefreshIntervalMs = options.liveRefreshIntervalMs ?? LIVE_CHART_REFRESH_INTERVAL_MS;
+  const liveStreaming = options.liveStreaming !== false;
   useEffect(() => {
     const subscriptionGeneration = ++liveSubscriptionGenerationRef.current;
     liveQuoteOverridesRef.current = new Map();
+    if (!liveStreaming) return;
     const dispose = subscribeToLiveChartQuotes({
       spec,
       dataProvider: sources.dataProvider,
@@ -202,7 +208,17 @@ export function useChartResolution(
         liveQuoteOverridesRef.current = new Map();
       }
     };
-  }, [liveRefreshIntervalMs, liveTargetSignature, sources.dataProvider]);
+  }, [liveRefreshIntervalMs, liveStreaming, liveTargetSignature, sources.dataProvider]);
+
+  const quotePollingIntervalMs = options.quotePollingIntervalMs ?? DEFAULT_QUOTE_POLL_INTERVAL_MS;
+  useEffect(() => {
+    if (liveStreaming || !liveTargetSignature) return;
+    setRevision((current) => current + 1);
+    const intervalId = setInterval(() => {
+      setRevision((current) => current + 1);
+    }, quotePollingIntervalMs);
+    return () => clearInterval(intervalId);
+  }, [liveStreaming, liveTargetSignature, quotePollingIntervalMs]);
 
   return { ...result, reload };
 }

package/src/types/plugin.ts

@@ -53,6 +53,15 @@ export interface PaneDef {
   defaultFloatingSize?: { width: number; height: number };
   defaultMode?: "docked" | "floating";
   settings?: PaneSettingsDef | ((context: PaneSettingsContext) => PaneSettingsDef | null);
+  /** Compact controls surfaced next to the pane title. Toggle keys reference toggle fields in settings. */
+  quickSettings?: readonly PaneQuickSettingDef[];
+}
+
+export interface PaneQuickSettingDef {
+  type: "toggle";
+  key: string;
+  icon: "zap";
+  label?: string;
 }
 
 export interface PaneSettingsContext {

package/src/ui/host.tsx

@@ -61,6 +61,21 @@ export interface ChartCrosshairOverlay {
   markers?: readonly { pixelY: number; color: string }[];
 }
 
+/**
+ * Overlay shapes in plot ratios, drawn without touching the plot raster. The
+ * desktop composites them as vectors; the terminal paints them into the bitmap.
+ */
+export interface ChartVectorShape {
+  id: string;
+  points: readonly { x: number; y: number }[];
+  color: string;
+  /** Closes the shape into a filled box, for range and area selections. */
+  box?: boolean;
+  fillOpacity?: number;
+  strokeWidth?: number;
+  handles?: boolean;
+}
+
 interface TextEditBuffer {
   getText(): string;
   setText?(text: string): void;
@@ -210,8 +225,10 @@ interface InputProps extends BoxProps {}
 interface TextareaProps extends BoxProps {}
 export interface ChartSurfaceProps extends BoxProps {
   bitmap?: BitmapSurface | null;
+  /** Desktop stacks every layer; the terminal renders only the first. */
   bitmaps?: readonly BitmapSurface[] | null;
   crosshair?: ChartCrosshairOverlay | null;
+  vectors?: readonly ChartVectorShape[] | null;
   nativeBitmapsEnabled?: boolean;
 }
 export interface ImageSurfaceProps extends BoxProps {