gloomberb 0.11.2 → 0.11.3

package/src/layout-marketplace/gallery.test.tsx

@@ -4,6 +4,8 @@ import { testRender } from "../renderers/opentui/test-utils";
 import { AppContext, createInitialState, type AppAction } from "../state/app/context";
 import { cloneLayout, createDefaultConfig } from "../types/config";
 import type { PaneDef } from "../types/plugin";
+import { Box } from "../ui";
+import { PaneFooterBar, PaneFooterProvider } from "../components/layout/pane/footer";
 import type { PluginRegistry } from "../plugins/registry";
 import { LayoutMarketplaceGallery } from "./gallery";
 
@@ -43,7 +45,21 @@ async function renderGallery() {
 
   testSetup = await testRender(
     <AppContext value={{ state, dispatch: (action) => actions.push(action) }}>
-      <LayoutMarketplaceGallery pluginRegistry={registry} onClose={() => { closed = true; }} />
+      <PaneFooterProvider>
+        {(footer) => (
+          <Box width={100} height={24} flexDirection="column">
+            <Box width={100} height={23}>
+              <LayoutMarketplaceGallery
+                pluginRegistry={registry}
+                width={100}
+                height={23}
+                onClose={() => { closed = true; }}
+              />
+            </Box>
+            <PaneFooterBar footer={footer} focused width={100} />
+          </Box>
+        )}
+      </PaneFooterProvider>
     </AppContext>,
     { width: 100, height: 24 },
   );
@@ -65,6 +81,54 @@ test("lists owned layouts before Discover and details the selected layout", asyn
   expect(frame).toContain("Portfolio");
   expect(frame).toContain("Ticker Research");
   expect(frame).toContain("3 docked");
+
+  const searchLine = frame.split("\n").find((line) => line.includes("Search layouts and panes"));
+  expect(searchLine?.startsWith("/ Search layouts and panes")).toBe(true);
+  expect(frame).toContain("[/]search");
+  expect(frame).toContain("[n]ew");
+  expect(frame).toContain("[o]pen");
+  expect(frame).toContain("[r]ename");
+  expect(frame).toContain("[c]opy");
+  expect(frame).toContain("[d]elete");
+  expect(frame).toContain("[p]ublish");
+});
+
+test("search Enter returns to the list before activating the filtered layout", async () => {
+  const { actions, isClosed } = await renderGallery();
+
+  await act(async () => {
+    testSetup!.mockInput.pressKey("/");
+    await testSetup!.renderOnce();
+  });
+  await act(async () => {
+    await testSetup!.mockInput.typeText("Research");
+    testSetup!.mockInput.pressEnter();
+    await testSetup!.renderOnce();
+  });
+
+  expect(isClosed()).toBe(false);
+  expect(actions.some((action) => action.type === "SWITCH_LAYOUT")).toBe(false);
+  expect(testSetup!.captureCharFrame()).toContain("/ Research");
+
+  await act(async () => {
+    testSetup!.mockInput.pressEnter();
+    await testSetup!.renderOnce();
+  });
+
+  expect(actions).toContainEqual({ type: "SWITCH_LAYOUT", index: 1 });
+  expect(isClosed()).toBe(true);
+});
+
+test("n opens the new layout workflow", async () => {
+  const { isClosed } = await renderGallery();
+
+  await act(async () => {
+    testSetup!.mockInput.pressKey("n");
+    await testSetup!.renderOnce();
+  });
+
+  expect(isClosed()).toBe(false);
+  expect(testSetup!.captureCharFrame()).toContain("Create Layout");
 });
 
 test("j/k move the selection and Enter switches to the layout and closes", async () => {

package/src/plugins/builtin/chart-composer/cli-options.ts

@@ -1,4 +1,10 @@
 import type { NormalizedPaneFunctionOptions } from "../../../cli/pane-functions/capabilities";
+import {
+  CHART_RESOLUTIONS,
+  TIME_RANGES,
+  type ChartResolution,
+  type TimeRange,
+} from "../../../time-series/range";
 import {
   coerceSeriesTransformForStyle,
   normalizeChartSpec,
@@ -7,20 +13,17 @@ import type { ChartSeriesSpec, ChartSpec, SeriesPeriod } from "../../../time-ser
 
 const PRICE_CAPABILITIES = new Set(["price-chart", "intraday-price-chart", "price-comparison"]);
 
-function chartRange(options: NormalizedPaneFunctionOptions): ChartSpec["viewport"]["range"] | null {
+function chartRange(options: NormalizedPaneFunctionOptions): TimeRange | null {
   const value = options.rangePreset ?? options.range;
-  return value === "1D" || value === "1W" || value === "1M" || value === "3M"
-    || value === "6M" || value === "1Y" || value === "5Y" || value === "ALL"
-    ? value
+  return typeof value === "string" && (TIME_RANGES as readonly string[]).includes(value)
+    ? value as TimeRange
     : null;
 }
 
-function chartResolution(options: NormalizedPaneFunctionOptions): ChartSpec["viewport"]["resolution"] | null {
+function chartResolution(options: NormalizedPaneFunctionOptions): ChartResolution | null {
   const value = options.chartResolution ?? options.resolution;
-  return value === "auto" || value === "1m" || value === "5m" || value === "15m"
-    || value === "30m" || value === "45m" || value === "1h" || value === "1d"
-    || value === "1wk" || value === "1mo"
-    ? value
+  return typeof value === "string" && (CHART_RESOLUTIONS as readonly string[]).includes(value)
+    ? value as ChartResolution
     : null;
 }
 

package/src/plugins/builtin/chart-composer/settings.ts

@@ -1,4 +1,5 @@
 import type { ChartResolution, TimeRange } from "../../../components/chart/core/types";
+import { CHART_RESOLUTIONS, TIME_RANGES as CHART_RANGES } from "../../../time-series/range";
 import type {
   PaneSettingField,
   PaneSettingOption,
@@ -33,19 +34,7 @@ import {
   parseChartSpecOr,
 } from "./chart-spec";
 
-export const CHART_RANGES: TimeRange[] = ["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"];
-export const CHART_RESOLUTIONS: ChartResolution[] = [
-  "auto",
-  "1m",
-  "5m",
-  "15m",
-  "30m",
-  "45m",
-  "1h",
-  "1d",
-  "1wk",
-  "1mo",
-];
+export { CHART_RANGES, CHART_RESOLUTIONS };
 
 export const CHART_STUDY_OPTIONS: Array<PaneSettingOption & { value: BuiltinStudySelection }> = [
   { value: "volume", label: "Volume", description: "Volume columns in a lower panel." },

package/src/plugins/builtin/composite-plugins.ts

@@ -29,6 +29,7 @@ import { scannerModule } from "./scanner";
 import { sectorsModule } from "./sectors";
 import { treasuryAuctionsModule } from "./treasury-auctions";
 import { worldIndicesModule } from "./world-indices";
+import { worldVenueMapModule } from "./world-venue-map";
 import { yieldCurveModule } from "./yield-curve";
 
 const macroSharedResourcesModule = {
@@ -75,6 +76,7 @@ export const marketOverviewPlugin = composeBuiltinPlugin({
   modules: [
     correlationModule,
     worldIndicesModule,
+    worldVenueMapModule,
     marketHeatmapModule,
     marketMoversModule,
     marketHaltsModule,

package/src/plugins/builtin/earnings/index.tsx

@@ -253,6 +253,7 @@ export const earningsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 85, height: 25 },
+      tableExport: true,
       settings: earningsSettings,
     },
   ],

package/src/plugins/builtin/econ/index.tsx

@@ -399,6 +399,7 @@ export const economicCalendarModule: PluginModule = {
     defaultPosition: "right",
     defaultMode: "floating",
     defaultFloatingSize: { width: 100, height: 30 },
+    tableExport: true,
   }],
   paneTemplates: [{
     id: "econ-calendar-pane",

package/src/plugins/builtin/futures/index.tsx

@@ -250,6 +250,7 @@ export const futuresModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 76, height: 34 },
+      tableExport: true,
       // Resolved per open so the dialog shows the full default set until the
       // user saves a narrower selection.
       settings: (context) => ({

package/src/plugins/builtin/fx-matrix/index.tsx

@@ -169,6 +169,7 @@ export const fxMatrixModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 105, height: 14 },
+      tableExport: true,
       settings: (context) => ({
         title: "FX Cross Rates Settings",
         values: {

package/src/plugins/builtin/ipo-calendar/index.tsx

@@ -40,6 +40,7 @@ export const ipoCalendarModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 110, height: 28 },
+      tableExport: true,
     },
   ],
 

package/src/plugins/builtin/market-halts/index.tsx

@@ -12,6 +12,7 @@ export const marketHaltsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 124, height: 26 },
+      tableExport: true,
     },
   ],
 

package/src/plugins/builtin/market-movers/index.tsx

@@ -324,6 +324,7 @@ export const marketMoversModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 100, height: 36 },
+      tableExport: true,
       quickSettings: [LIVE_STREAMING_QUICK_SETTING],
       settings: (context) => withLiveStreamingSetting({
         title: "Market Movers Settings",

package/src/plugins/builtin/options/analytics.test.ts

@@ -0,0 +1,83 @@
+import { expect, test } from "bun:test";
+import type { OptionContract, OptionsChain, PricePoint } from "../../../types/financials";
+import {
+  calculateOptionGreeks,
+  calculateOptionsSummary,
+  historicalVolatility30d,
+} from "./analytics";
+
+function contract(
+  strike: number,
+  impliedVolatility: number,
+  volume: number,
+  openInterest: number,
+): OptionContract {
+  return {
+    contractSymbol: String(strike),
+    strike,
+    currency: "USD",
+    lastPrice: 1,
+    change: 0,
+    percentChange: 0,
+    volume,
+    openInterest,
+    bid: 0.95,
+    ask: 1.05,
+    impliedVolatility,
+    inTheMoney: false,
+    expiration: Date.UTC(2027, 0, 15) / 1000,
+    lastTradeDate: 0,
+  };
+}
+
+function priceHistory(): PricePoint[] {
+  const points: PricePoint[] = [{ date: new Date(Date.UTC(2026, 0, 1)), close: 100 }];
+  for (let index = 0; index < 30; index += 1) {
+    points.push({
+      date: new Date(Date.UTC(2026, 0, index + 2)),
+      close: points.at(-1)!.close * Math.exp(index % 2 === 0 ? 0.01 : -0.01),
+    });
+  }
+  return points;
+}
+
+test("annualizes the latest 30 daily log returns, including persisted dates", () => {
+  const expected = Math.sqrt((30 * 0.01 ** 2 / 29) * 252);
+  expect(historicalVolatility30d(priceHistory())).toBeCloseTo(expected, 10);
+  expect(historicalVolatility30d(priceHistory().map((point) => ({
+    ...point,
+    date: point.date.toISOString() as unknown as Date,
+  })))).toBeCloseTo(expected, 10);
+  expect(historicalVolatility30d(priceHistory().slice(1))).toBeNull();
+});
+
+test("summarizes the selected expiration without presenting it as whole-chain volume", () => {
+  const chain: OptionsChain = {
+    underlyingSymbol: "AAPL",
+    expirationDates: [Date.UTC(2027, 0, 15) / 1000],
+    calls: [contract(100, 0.2, 100, 200), contract(105, 0.3, 200, 400)],
+    puts: [contract(100, 0.22, 150, 180), contract(105, 0.4, 300, 420)],
+  };
+  const summary = calculateOptionsSummary(chain, 101, priceHistory());
+
+  expect(summary.atmImpliedVolatility).toBeCloseTo(0.21, 10);
+  expect(summary.expirationVolume).toBe(750);
+  expect(summary.putCallVolumeRatio).toBe(1.5);
+  expect(summary.putCallOpenInterestRatio).toBe(1);
+  expect(summary.impliedHistoricalRatio).toBeCloseTo(
+    summary.atmImpliedVolatility! / summary.historicalVolatility30d!,
+    10,
+  );
+});
+
+test("derives call and put Greeks from the chain IV", () => {
+  const option = contract(100, 0.25, 0, 0);
+  const now = Date.UTC(2026, 11, 15);
+  const call = calculateOptionGreeks(option, "call", 100, 0, now);
+  const put = calculateOptionGreeks(option, "put", 100, 0, now);
+
+  expect(call?.delta).toBeGreaterThan(0);
+  expect(put?.delta).toBeLessThan(0);
+  expect(call?.gamma).toBeCloseTo(put!.gamma, 10);
+  expect(call?.vegaPerPoint).toBeCloseTo(put!.vegaPerPoint, 10);
+});

package/src/plugins/builtin/options/analytics.ts

@@ -0,0 +1,110 @@
+import type { OptionContract, OptionsChain, PricePoint } from "../../../types/financials";
+import {
+  DEFAULT_OPTION_CALC_DRAFT,
+  daysToExpiryFrom,
+  valueOption,
+  type OptionSide,
+  type OptionValuation,
+} from "../options-calculator/model";
+
+const TRADING_DAYS_PER_YEAR = 252;
+const HISTORICAL_VOLATILITY_SESSIONS = 30;
+
+export interface OptionsSummary {
+  atmImpliedVolatility: number | null;
+  historicalVolatility30d: number | null;
+  impliedHistoricalRatio: number | null;
+  expirationVolume: number;
+  putCallVolumeRatio: number | null;
+  putCallOpenInterestRatio: number | null;
+}
+
+function positive(value: number | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function ratio(numerator: number, denominator: number): number | null {
+  return denominator > 0 ? numerator / denominator : null;
+}
+
+function sum(contracts: readonly OptionContract[], field: "volume" | "openInterest"): number {
+  return contracts.reduce((total, contract) => {
+    const value = contract[field];
+    return total + (Number.isFinite(value) && value > 0 ? value : 0);
+  }, 0);
+}
+
+function atmImpliedVolatility(chain: OptionsChain, spot: number | undefined): number | null {
+  if (!positive(spot)) return null;
+  const contracts = [...chain.calls, ...chain.puts].filter((contract) => positive(contract.impliedVolatility));
+  if (contracts.length === 0) return null;
+  const distance = Math.min(...contracts.map((contract) => Math.abs(contract.strike - spot)));
+  const atTheMoney = contracts
+    .filter((contract) => Math.abs(Math.abs(contract.strike - spot) - distance) < 1e-8)
+    .map((contract) => contract.impliedVolatility);
+  return atTheMoney.reduce((total, value) => total + value, 0) / atTheMoney.length;
+}
+
+/** Annualized standard deviation of the latest 30 daily log returns. */
+export function historicalVolatility30d(points: readonly PricePoint[]): number | null {
+  const closes = points
+    .map((point) => ({
+      close: point.close,
+      time: point.date instanceof Date ? point.date.getTime() : Date.parse(String(point.date)),
+    }))
+    .filter((point) => positive(point.close) && Number.isFinite(point.time))
+    .sort((a, b) => a.time - b.time)
+    .slice(-(HISTORICAL_VOLATILITY_SESSIONS + 1))
+    .map((point) => point.close);
+  if (closes.length < HISTORICAL_VOLATILITY_SESSIONS + 1) return null;
+
+  const returns = closes.slice(1).map((close, index) => Math.log(close / closes[index]!));
+  const mean = returns.reduce((total, value) => total + value, 0) / returns.length;
+  const variance = returns.reduce((total, value) => total + (value - mean) ** 2, 0) / (returns.length - 1);
+  return Math.sqrt(variance * TRADING_DAYS_PER_YEAR);
+}
+
+export function calculateOptionsSummary(
+  chain: OptionsChain,
+  spot: number | undefined,
+  priceHistory: readonly PricePoint[],
+): OptionsSummary {
+  const atmIv = atmImpliedVolatility(chain, spot);
+  const historicalVolatility = historicalVolatility30d(priceHistory);
+  const callVolume = sum(chain.calls, "volume");
+  const putVolume = sum(chain.puts, "volume");
+  const callOpenInterest = sum(chain.calls, "openInterest");
+  const putOpenInterest = sum(chain.puts, "openInterest");
+
+  return {
+    atmImpliedVolatility: atmIv,
+    historicalVolatility30d: historicalVolatility,
+    impliedHistoricalRatio: atmIv != null && historicalVolatility != null && historicalVolatility > 0
+      ? atmIv / historicalVolatility
+      : null,
+    expirationVolume: callVolume + putVolume,
+    putCallVolumeRatio: ratio(putVolume, callVolume),
+    putCallOpenInterestRatio: ratio(putOpenInterest, callOpenInterest),
+  };
+}
+
+export function calculateOptionGreeks(
+  contract: OptionContract | undefined,
+  side: OptionSide,
+  spot: number | undefined,
+  dividendYield: number | undefined,
+  now: number = Date.now(),
+): OptionValuation | undefined {
+  if (!contract || !positive(spot) || !positive(contract.strike) || !positive(contract.impliedVolatility)) {
+    return undefined;
+  }
+  return valueOption({
+    ...DEFAULT_OPTION_CALC_DRAFT,
+    side,
+    spot,
+    strike: contract.strike,
+    daysToExpiry: daysToExpiryFrom(contract.expiration, now),
+    volatility: contract.impliedVolatility,
+    dividendYield: Number.isFinite(dividendYield) ? dividendYield! : 0,
+  });
+}

package/src/plugins/builtin/options/index.tsx

@@ -6,11 +6,26 @@ import {
   LIVE_STREAMING_QUICK_SETTING,
   withLiveStreamingSetting,
 } from "../shared/live-streaming";
+import { OPTION_FIELD_DEFS, resolveOptionFieldIds } from "./table";
 
-function optionsSettings(): PaneSettingsDef {
+function optionsSettings(settings: Record<string, unknown>): PaneSettingsDef {
   return {
     title: "Options Settings",
+    values: {
+      optionColumnIds: resolveOptionFieldIds(settings.optionColumnIds),
+    },
     fields: [
+      {
+        key: "optionColumnIds",
+        label: "Columns",
+        description: "Choose and order the fields mirrored around the strike.",
+        type: "ordered-multi-select",
+        options: OPTION_FIELD_DEFS.map((field) => ({
+          value: field.id,
+          label: field.label,
+          description: field.description,
+        })),
+      },
       {
         key: "chainRefreshMinutes",
         label: "Chain refresh",
@@ -38,7 +53,7 @@ export const optionsModule: PluginModule = {
       defaultMode: "floating",
       defaultFloatingSize: { width: 112, height: 28 },
       quickSettings: [LIVE_STREAMING_QUICK_SETTING],
-      settings: (context) => withLiveStreamingSetting(optionsSettings(), context.settings),
+      settings: (context) => withLiveStreamingSetting(optionsSettings(context.settings), context.settings),
     },
   ],