gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/chart-composer/index.tsx

@@ -1,11 +1,14 @@
+import { chartHeadless } from "./headless";
 import type {
   PaneTemplateContext,
   PaneTemplateCreateOptions,
   PaneTemplateDef,
 } from "../../../types/plugin";
-import { CHART_COMPOSER_PANE_ID } from "../../../types/config";
+import { CHART_COMPOSER_PANE_ID, type PaneInstanceConfig } from "../../../types/config";
+import type { TickerRecord } from "../../../types/ticker";
 import { parseTickerListInput } from "../../../tickers/list";
-import { publicTickerKey } from "../../../utils/exchanges";
+import { canonicalExchange, parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
+import { tickerInstrumentLabel } from "../../../tickers/instrument-label";
 import type { ChartSpec } from "../../../time-series/types";
 import { ChartComposerPane, ChartComposerResearchTab } from "./pane";
 import { DataCatalogPane } from "./data-catalog-pane";
@@ -74,10 +77,29 @@ function primarySecuritySymbol(spec: ChartSpec): string | null {
     : null;
 }
 
+function bindSelectedContract(spec: ChartSpec, context: PaneTemplateContext, options?: PaneTemplateCreateOptions): ChartSpec {
+  const contract = options?.instrument !== undefined ? options.instrument : context.activeInstrument;
+  const listing = options?.listing ?? context.activeListing;
+  const selected = options?.symbol ?? context.activeTicker;
+  if (contract === undefined || !selected) return spec;
+  const selectedSymbol = parsePublicTickerKey(selected).symbol;
+  const selectedExchange = canonicalExchange(parsePublicTickerKey(selected).exchange
+    || listing?.exchange || (contract?.exchange === "SMART" ? contract.primaryExchange : contract?.exchange));
+  return { ...spec, series: spec.series.map((series) => (
+    series.source.kind === "security" && !series.source.instrument.instrument
+      && parsePublicTickerKey(series.source.instrument.symbol).symbol === selectedSymbol
+      && (!series.source.instrument.exchange || canonicalExchange(series.source.instrument.exchange) === selectedExchange)
+      ? { ...series, source: { ...series.source, instrument: {
+        ...series.source.instrument, exchange: listing?.exchange || contract?.exchange || series.source.instrument.exchange,
+        brokerId: contract?.brokerId, brokerInstanceId: contract?.brokerInstanceId, instrument: contract,
+      } } } : series
+  )) };
+}
+
 function chartTitle(spec: ChartSpec, prefix = "G"): string {
   const labels = spec.series.slice(0, 3).map((series) => (
     series.source.kind === "security"
-      ? publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange)
+      ? tickerInstrumentLabel(publicTickerKey(series.source.instrument.symbol, series.source.instrument.exchange), series.source.instrument.instrument)
       : series.source.kind === "economic"
         ? `FRED:${series.source.seriesId}`
         : series.label?.trim() || series.source.seriesId
@@ -91,6 +113,43 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
+/**
+ * A series authored as a bare symbol resolves its venue through the sender's
+ * ticker records at render time. Those records do not travel, so the venue is
+ * written into the spec before the pane leaves the device. Broker contract
+ * details stay local; only the public exchange is pinned.
+ */
+function pinChartSpecListings(spec: ChartSpec, tickers: ReadonlyMap<string, TickerRecord>): ChartSpec {
+  let changed = false;
+  const series = spec.series.map((entry) => {
+    if (entry.source.kind !== "security" || entry.source.instrument.exchange?.trim()) return entry;
+    const symbol = entry.source.instrument.symbol.trim().toUpperCase();
+    const exchange = tickers.get(symbol)?.metadata.exchange?.trim();
+    if (!exchange) return entry;
+    changed = true;
+    return {
+      ...entry,
+      source: {
+        ...entry.source,
+        instrument: { ...entry.source.instrument, exchange },
+      },
+    };
+  });
+  return changed ? { ...spec, series } : spec;
+}
+
+function prepareChartPaneForShare(
+  pane: PaneInstanceConfig,
+  { tickers }: { tickers: ReadonlyMap<string, TickerRecord> },
+): PaneInstanceConfig {
+  const spec = parseChartSpec(pane.settings?.[CHART_SPEC_SETTING_KEY]);
+  if (!spec) return pane;
+  const pinned = pinChartSpecListings(spec, tickers);
+  return pinned === spec
+    ? pane
+    : { ...pane, settings: { ...pane.settings, [CHART_SPEC_SETTING_KEY]: pinned } };
+}
+
 interface SharedChartState {
   drawings?: ChartDrawing[];
   viewport?: ChartInteractionViewport;
@@ -98,10 +157,12 @@ interface SharedChartState {
 
 function instanceFor(spec: ChartSpec, prefix: string, shared: SharedChartState = {}) {
   const symbol = primarySecuritySymbol(spec);
+  const primary = spec.series.find((series) => series.source.kind === "security")?.source;
+  const instrument = primary?.kind === "security" ? primary.instrument.instrument : null;
   return {
     title: chartTitle(spec, prefix),
     placement: "floating" as const,
-    ...(symbol ? { binding: { kind: "fixed" as const, symbol } } : {}),
+    ...(symbol ? { binding: { kind: "fixed" as const, symbol, ...(instrument !== undefined ? { instrument } : {}) } } : {}),
     settings: {
       [CHART_SPEC_SETTING_KEY]: spec,
       ...(shared.drawings?.length
@@ -114,6 +175,22 @@ function instanceFor(spec: ChartSpec, prefix: string, shared: SharedChartState =
   };
 }
 
+function selectedInstanceFor(spec: ChartSpec, prefix: string, context: PaneTemplateContext, options?: PaneTemplateCreateOptions) {
+  const bound = bindSelectedContract(spec, context, options);
+  const instance = instanceFor(bound, prefix);
+  const primaryIndex = spec.series.findIndex(series => series.source.kind === "security");
+  const primary = bound.series[primaryIndex]?.source;
+  const symbol = options?.symbol ?? context.activeTicker;
+  // Keep the saved ticker key for followers; the series and listing retain its venue.
+  if (symbol && primary?.kind === "security" && primary !== spec.series[primaryIndex]?.source) {
+    const listing = options?.listing ?? context.activeListing;
+    return { ...instance, binding: { kind: "fixed" as const, symbol,
+      instrument: primary.instrument.instrument, ...(listing ? { listing } : {}),
+    } };
+  }
+  return instance;
+}
+
 function securityTemplate({
   id,
   prefix,
@@ -123,7 +200,7 @@ function securityTemplate({
   minimumSymbols,
   build,
 }: {
-  id: string;
+  id: Parameters<typeof chartHeadless>[0];
   prefix: "GP" | "GIP" | "CMP" | "GF" | "GE";
   label: string;
   description: string;
@@ -134,6 +211,7 @@ function securityTemplate({
   return {
     id,
     paneId: CHART_COMPOSER_PANE_ID,
+    headless: chartHeadless(id),
     label,
     description,
     keywords: ["chart", "graph", prefix.toLowerCase(), ...label.toLowerCase().split(" ")],
@@ -152,7 +230,7 @@ function securityTemplate({
     canCreate: (context, options) => templateSymbols(context, options).length >= minimumSymbols,
     createInstance: (context, options) => {
       const symbols = templateSymbols(context, options);
-      return symbols.length >= minimumSymbols ? instanceFor(build(symbols), prefix) : null;
+      return symbols.length >= minimumSymbols ? selectedInstanceFor(build(symbols), prefix, context, options) : null;
     },
   };
 }
@@ -160,6 +238,7 @@ function securityTemplate({
 const chartComposerTemplates: PaneTemplateDef[] = [
   {
     id: CHART_COMPOSER_TEMPLATE_ID,
+    headless: chartHeadless("chart-composer-pane"),
     paneId: CHART_COMPOSER_PANE_ID,
     label: "Custom Chart",
     description: "Chart arbitrary market, fundamental, valuation, and FRED series together.",
@@ -185,12 +264,14 @@ const chartComposerTemplates: PaneTemplateDef[] = [
         });
       }
       const expression = options?.arg?.trim() || options?.values?.series?.trim() || context.activeTicker || "";
-      return instanceFor(buildCustomChartPreset(expression, context.activeTicker), "G");
+      return selectedInstanceFor(buildCustomChartPreset(expression, context.activeTicker), "G", context, options);
     },
     publicShare: {
       serialize: ({ pane }) => {
         const spec = parseChartSpec(pane.settings?.[CHART_SPEC_SETTING_KEY]);
         if (!spec) return null;
+        if (spec.series.some((series) => series.source.kind === "security"
+          && (series.source.instrument.instrument || series.source.instrument.brokerId || series.source.instrument.brokerInstanceId))) return null;
         const drawings = parseChartDrawings(pane.settings?.[CHART_DRAWINGS_SETTING_KEY]);
         const viewport = parseChartInteractionViewport(
           pane.settings?.[CHART_INTERACTION_VIEWPORT_SETTING_KEY],
@@ -288,7 +369,7 @@ const chartComposerTemplates: PaneTemplateDef[] = [
     id: "comparison-chart-pane",
     prefix: "CMP",
     label: "Comparison Chart",
-    description: "Compare percentage performance for two or more tickers.",
+    description: "Compare price returns over shared observation dates for two or more tickers.",
     argKind: "ticker-list",
     minimumSymbols: 2,
     build: buildComparisonChartPreset,
@@ -322,6 +403,7 @@ export const chartComposerModule: PluginModule = {
     defaultPosition: "right",
     defaultMode: "floating",
     defaultFloatingSize: { width: 100, height: 32 },
+    portableShare: { prepare: prepareChartPaneForShare },
     quickSettings: [LIVE_STREAMING_QUICK_SETTING],
     settings: (context) => withLiveStreamingSetting(
       buildChartComposerPaneSettingsDef(

package/src/plugins/builtin/chart-composer/loading.test.tsx

@@ -0,0 +1,134 @@
+import { afterEach, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { createInitialState } from "../../../state/app/context";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createTestPaneConfig, TestPaneProvider } from "../../../test-support/pane";
+import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
+import { ChartSnapshotContext } from "../../../time-series/hooks";
+import { parsedPriceHistoryKey, rememberParsedPriceHistory } from "../../../time-series/parsed-history-cache";
+import { useChartResolution, type UseChartResolutionResult } from "../../../time-series/use-chart-resolution";
+import type { PricePoint } from "../../../types/financials";
+import { ChartComposerPane } from "./pane";
+import { buildComparisonChartPreset } from "./presets";
+
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+afterEach(async () => {
+  if (setup) await act(async () => setup!.renderer.destroy());
+  setup = undefined;
+});
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: Error) => void;
+  const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+  return { promise, resolve, reject };
+}
+
+const history: PricePoint[] = [
+  { date: new Date("2025-01-02"), open: 100, high: 100, low: 100, close: 100, volume: 100 },
+  { date: new Date("2025-01-03"), open: 110, high: 110, low: 110, close: 110, volume: 100 },
+];
+
+async function waitFor(predicate: () => boolean) {
+  for (let i = 0; i < 100; i++) {
+    await act(async () => { await Bun.sleep(1); await setup!.renderOnce(); });
+    if (predicate()) {
+      await act(async () => setup!.renderOnce());
+      return;
+    }
+  }
+  throw new Error("Comparison did not reach the expected state");
+}
+
+for (const outcome of ["success", "disjoint", "empty", "failed"] as const) {
+  test(`comparison waits for both histories before showing ${outcome}`, async () => {
+    const firstSymbol = `CMPLA${outcome.toUpperCase()}`;
+    const secondSymbol = `CMPLB${outcome.toUpperCase()}`;
+    const spec = buildComparisonChartPreset([`${firstSymbol}:NASDAQ`, `${secondSymbol}:NASDAQ`]);
+    spec.viewport.dateWindow = { start: "2025-01-01", end: "2025-01-10" };
+    const secondHistory = outcome === "empty" ? [] : outcome === "disjoint"
+      ? history.map((point) => ({ ...point, date: new Date(point.date.getTime() + 4 * 86_400_000) }))
+      : history;
+    // Reproduce the live range switch: a cached first leg seeds an unusable
+    // shared window while the required histories are still in flight.
+    rememberParsedPriceHistory(parsedPriceHistoryKey(firstSymbol, "NASDAQ", "1Y", "1d"), history);
+    let first = deferred<PricePoint[]>();
+    let second = deferred<PricePoint[]>();
+    const requested = new Set<string>();
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => ({ annualStatements: [], quarterlyStatements: [], priceHistory: [] }),
+      getPriceHistoryForResolution: async (symbol) => {
+        requested.add(symbol);
+        return symbol === firstSymbol ? first.promise : second.promise;
+      },
+    });
+    const sources = {
+      dataProvider: provider,
+      now: new Date("2025-01-10"),
+      loadFredSeries: async () => { throw new Error("Unexpected FRED request"); },
+    };
+    const paneId = `comparison-loading-${outcome}`;
+    const state = createInitialState(createTestPaneConfig("/tmp/comparison-loading-unused", {
+      instanceId: paneId, paneId: "chart-composer", settings: { chartSpec: spec },
+    }));
+    const runtime = createTestPluginRuntime({ getMarketData: () => provider });
+    let latest: UseChartResolutionResult | undefined;
+    function Harness() {
+      latest = useChartResolution(spec, sources, { liveRefreshIntervalMs: 0 });
+      return <TestPaneProvider state={state} paneId={paneId} pluginId="charts" runtime={runtime}>
+        <ChartSnapshotContext value={latest}>
+          <ChartComposerPane paneId={paneId} focused width={120} height={24} />
+        </ChartSnapshotContext>
+      </TestPaneProvider>;
+    }
+    setup = await testRender(<Harness />, { width: 120, height: 24 });
+    await waitFor(() => requested.size === 2);
+    expect(latest?.loading).toBe(true);
+    expect(latest?.priceComparison?.start).toBeNull();
+    expect(setup.captureCharFrame()).toContain("Loading chart data");
+    expect(setup.captureCharFrame()).not.toContain("Comparison unavailable");
+
+    await act(async () => { first.resolve(history); await Bun.sleep(2); });
+    expect(latest?.loading).toBe(true);
+    expect(setup.captureCharFrame()).not.toContain("Comparison unavailable");
+
+    await act(async () => {
+      if (outcome === "failed") second.reject(new Error("Controlled history failure"));
+      else second.resolve(secondHistory);
+    });
+    await waitFor(() => latest?.loading === false);
+    const settled = setup.captureCharFrame();
+    expect(settled).not.toContain("Loading chart data");
+    if (outcome === "success") {
+      expect(latest?.series.map((series) => series.points.length)).toEqual([2, 2]);
+      expect(settled).not.toContain("Comparison unavailable");
+    } else {
+      expect(latest?.priceComparison?.start).toBeNull();
+      if (outcome === "disjoint") expect(settled).toContain("Comparison unavailable");
+      else {
+        expect(latest?.errors.length).toBeGreaterThan(0);
+        expect(settled).toContain("price history is unavailable");
+      }
+      expect(settled).not.toContain("no observations in the selected date range");
+    }
+
+    if (outcome === "disjoint") {
+      // Refreshing a settled empty result must not reveal the old per-leg
+      // empty warnings when its composite failure notice is deferred.
+      first = deferred<PricePoint[]>();
+      second = deferred<PricePoint[]>();
+      requested.clear();
+      await act(async () => latest!.reload());
+      await waitFor(() => requested.size === 2);
+      expect(latest?.loading).toBe(true);
+      const refreshing = setup.captureCharFrame();
+      expect(refreshing).toContain("Loading chart data");
+      expect(refreshing).not.toContain("Comparison unavailable");
+      expect(refreshing).not.toContain("no observations in the selected date range");
+      await act(async () => { first.resolve(history); second.resolve(secondHistory); });
+      await waitFor(() => latest?.loading === false);
+      expect(setup.captureCharFrame()).toContain("Comparison unavailable");
+    }
+  });
+}

package/src/plugins/builtin/chart-composer/pane-share.test.ts

@@ -11,7 +11,11 @@ import {
   CHART_DRAWINGS_SETTING_KEY,
   parseChartDrawings,
 } from "../../../components/chart/composite/tools";
-import { buildPriceChartPreset } from "./presets";
+import { buildCustomChartPreset, buildPriceChartPreset, setPairStudies } from "./presets";
+import { applyChartComposerPaneSetting, CHART_SETTING_KEYS } from "./settings";
+import { buildPaneSharePayload } from "../../../shares/pane";
+import type { PluginRegistry } from "../../registry";
+import type { TickerRecord } from "../../../types/ticker";
 
 const context: PaneTemplateContext = {
   config: {} as PaneTemplateContext["config"],
@@ -22,6 +26,75 @@ const context: PaneTemplateContext = {
 };
 
 describe("chart pane sharing", () => {
+  test("a live pane share carries drawings and viewport, pins the listing venue, and survives a listing binding", () => {
+    const registry = {
+      panes: new Map(chartComposerModule.panes!.map((pane) => [pane.id, pane])),
+      paneTemplates: new Map(),
+    } as unknown as PluginRegistry;
+    const drawings = [{
+      id: "line-1",
+      panelId: "main",
+      color: "#f5a524",
+      points: [{ time: 1_779_000_000_000, value: 182.4 }, { time: 1_780_000_000_000, value: 205.8 }],
+    }];
+    const viewport = {
+      authoredViewportKey: "SHEL:1Y:1d",
+      start: "2026-04-01T00:00:00.000Z",
+      end: "2026-07-01T00:00:00.000Z",
+      adaptive: false,
+    };
+    const payload = buildPaneSharePayload(registry, {
+      instanceId: "chart-composer:1",
+      paneId: "chart-composer",
+      title: "G SHEL",
+      // A chart opened from the command bar keeps the picked listing on its binding.
+      binding: { kind: "fixed", symbol: "SHEL", listing: { exchange: "LSE", name: "Shell", currency: "GBp", type: "Common Stock" } },
+      settings: {
+        [CHART_SPEC_SETTING_KEY]: buildPriceChartPreset("SHEL"),
+        [CHART_DRAWINGS_SETTING_KEY]: drawings,
+        [CHART_INTERACTION_VIEWPORT_SETTING_KEY]: viewport,
+      },
+    }, {}, "SHEL", new Map<string, TickerRecord>([["SHEL", { metadata: { ticker: "SHEL", exchange: "LSE" } } as TickerRecord]]));
+    expect(payload?.kind).toBe("pane");
+    if (payload?.data.version !== 2) throw new Error("expected a portable pane share");
+    const instance = payload.data.layout.layout.instances[0]!;
+    expect(instance.binding).toEqual({ kind: "fixed", symbol: "SHEL:XLON" });
+    const spec = parseChartSpec(instance.settings?.[CHART_SPEC_SETTING_KEY]);
+    const security = spec?.series.find((series) => series.source.kind === "security")?.source;
+    expect(security?.kind === "security" ? security.instrument.exchange : null).toBe("LSE");
+    expect(parseChartDrawings(instance.settings?.[CHART_DRAWINGS_SETTING_KEY])).toEqual(drawings);
+    expect(parseChartInteractionViewport(instance.settings?.[CHART_INTERACTION_VIEWPORT_SETTING_KEY])).toEqual(viewport);
+  });
+
+  test("persisted and shared authored formulas survive toggling another formula", async () => {
+    const template = chartComposerModule.paneTemplates?.find((entry) => entry.id === "chart-composer-pane");
+    const spec = setPairStudies(buildCustomChartPreset("TARGET:NASDAQ:market.close,ACQUIRER:NASDAQ:market.close"), ["spread", "correlation"]);
+    spec.studies = spec.studies.map((study) => ({ ...study,
+      parameters: study.kind === "spread" ? { multiplier: 0.5 } : { period: 13, returns: 0 },
+      color: "#f5a524", axis: "right", panelId: `authored-${study.kind}`, visible: study.kind !== "correlation",
+    }));
+    const authoredPanels = spec.studies.map((study) => ({ id: study.panelId, label: `Controlled ${study.kind}`, height: 0.3 }));
+    spec.panels.push(...authoredPanels);
+    const shared = template?.publicShare?.serialize({
+      pane: { instanceId: "controlled-chart", paneId: "chart-composer", settings: { chartSpec: spec } }, paneState: {},
+    });
+    const options = template?.publicShare?.restore(shared!.data);
+    const instance = await template?.createInstance?.(context, options ?? undefined);
+    for (const initial of [JSON.parse(JSON.stringify({ chartSpec: spec })), instance!.settings!]) {
+      expect(parseChartSpec(initial.chartSpec)?.studies).toEqual(parseChartSpec(spec)?.studies);
+      let settings = initial;
+      for (const selected of [["spread", "correlation", "ratio"], ["spread", "correlation"]]) {
+        settings = applyChartComposerPaneSetting(settings, { key: CHART_SETTING_KEYS.formulas, label: "Formulas", type: "multi-select", options: [] }, selected);
+        const updated = parseChartSpec(settings.chartSpec)!;
+        expect(updated.studies.filter(({ kind }) => kind !== "ratio")).toEqual(parseChartSpec(spec)?.studies);
+        expect(updated.panels.filter(({ id }) => id.startsWith("authored-")))
+          .toEqual(parseChartSpec(spec)?.panels.filter(({ id }) => id.startsWith("authored-")));
+        expect(updated.studies.some(({ kind }) => kind === "ratio")).toBe(selected.includes("ratio"));
+      }
+      expect(parseChartSpec(initial.chartSpec)?.studies).toEqual(parseChartSpec(spec)?.studies);
+    }
+  });
+
   test("round-trips chart setup, drawings, and the panned viewport", async () => {
     const template = chartComposerModule.paneTemplates?.find((entry) => entry.id === "chart-composer-pane");
     const spec = buildPriceChartPreset("AAPL");