gloomberb 0.9.9 → 0.10.0

package/src/time-series/transforms.ts

@@ -0,0 +1,152 @@
+import type { ResolvedSeries, SeriesTransform, TimeSeriesPoint } from "./types";
+
+const DAY_MS = 24 * 60 * 60 * 1_000;
+const NUMERIC_POINT_FIELDS = ["value", "open", "high", "low", "close", "volume"] as const;
+
+function finiteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function clonePoint(point: TimeSeriesPoint): TimeSeriesPoint {
+  return {
+    ...point,
+    date: new Date(point.date),
+    observedAt: new Date(point.observedAt),
+    availableAt: point.availableAt ? new Date(point.availableAt) : undefined,
+    provenance: point.provenance ? { ...point.provenance } : undefined,
+  };
+}
+
+function primaryValue(point: TimeSeriesPoint): number | null {
+  return finiteNumber(point.value)
+    ? point.value
+    : finiteNumber(point.close)
+      ? point.close
+      : null;
+}
+
+function relativeValue(value: number | null | undefined, baseline: number, index100: boolean): number | null {
+  if (!finiteNumber(value) || baseline === 0) return null;
+  return index100 ? (value / baseline) * 100 : ((value - baseline) / Math.abs(baseline)) * 100;
+}
+
+function growthValue(value: number | null | undefined, previous: number | null | undefined): number | null {
+  if (!finiteNumber(value) || !finiteNumber(previous) || previous === 0) return null;
+  return ((value - previous) / Math.abs(previous)) * 100;
+}
+
+function shiftUtcMonths(date: Date, months: number): Date {
+  const shifted = new Date(date);
+  const originalDay = shifted.getUTCDate();
+  shifted.setUTCDate(1);
+  shifted.setUTCMonth(shifted.getUTCMonth() - months);
+  const lastDay = new Date(Date.UTC(
+    shifted.getUTCFullYear(),
+    shifted.getUTCMonth() + 1,
+    0,
+  )).getUTCDate();
+  shifted.setUTCDate(Math.min(originalDay, lastDay));
+  return shifted;
+}
+
+function referencePoint(
+  points: readonly TimeSeriesPoint[],
+  currentIndex: number,
+  months: number,
+  toleranceDays: number,
+): TimeSeriesPoint | null {
+  const current = points[currentIndex];
+  if (!current) return null;
+  const currentTime = current.observedAt.getTime();
+  const target = shiftUtcMonths(current.observedAt, months).getTime();
+  let best: { point: TimeSeriesPoint; distance: number; date: number } | null = null;
+  for (let index = 0; index < currentIndex; index += 1) {
+    const candidate = points[index]!;
+    const candidateTime = candidate.observedAt.getTime();
+    if (!Number.isFinite(candidateTime) || candidateTime >= currentTime) continue;
+    const distance = Math.abs(candidateTime - target);
+    if (distance > toleranceDays * DAY_MS) continue;
+    if (!best || distance < best.distance || (distance === best.distance && candidateTime > best.date)) {
+      best = { point: candidate, distance, date: candidateTime };
+    }
+  }
+  return best?.point ?? null;
+}
+
+function mapNumericFields(
+  point: TimeSeriesPoint,
+  mapper: (value: number | null | undefined, field: typeof NUMERIC_POINT_FIELDS[number]) => number | null,
+): TimeSeriesPoint {
+  const transformed = clonePoint(point);
+  for (const field of NUMERIC_POINT_FIELDS) {
+    const value = point[field];
+    if (field !== "value" && value === undefined) continue;
+    (transformed as unknown as Record<string, unknown>)[field] = mapper(value, field);
+  }
+  return transformed;
+}
+
+/** Applies a display transform without mutating the source observations. */
+export function applySeriesTransform(
+  sourcePoints: readonly TimeSeriesPoint[],
+  transform: SeriesTransform,
+  options: { baseline?: number | null } = {},
+): TimeSeriesPoint[] {
+  const points = sourcePoints
+    .map(clonePoint)
+    .filter((point) => Number.isFinite(point.date.getTime()) && Number.isFinite(point.observedAt.getTime()))
+    .sort((left, right) => left.date.getTime() - right.date.getTime());
+  if (transform === "raw") return points;
+
+  if (transform === "percent" || transform === "index100") {
+    const baselinePoint = points.find((point) => {
+      const value = primaryValue(point);
+      return value !== null && value !== 0;
+    });
+    const baseline = options.baseline !== undefined
+      ? options.baseline
+      : baselinePoint ? primaryValue(baselinePoint) : null;
+    if (baseline === null || baseline === 0) {
+      return points.map((point) => mapNumericFields(point, () => null));
+    }
+    return points.map((point) => mapNumericFields(
+      point,
+      (value) => relativeValue(value, baseline, transform === "index100"),
+    ));
+  }
+
+  if (transform === "log") {
+    return points.map((point) => mapNumericFields(
+      point,
+      (value) => finiteNumber(value) && value > 0 ? Math.log(value) : null,
+    ));
+  }
+
+  const months = transform === "yoy" ? 12 : 3;
+  const toleranceDays = transform === "yoy" ? 62 : 46;
+  return points.map((point, index) => {
+    const reference = referencePoint(points, index, months, toleranceDays);
+    if (!reference) return mapNumericFields(point, () => null);
+    return mapNumericFields(point, (value, field) => growthValue(value, reference[field]));
+  });
+}
+
+export function applyResolvedSeriesTransform(
+  series: ResolvedSeries,
+  transform: SeriesTransform = series.transform,
+  options: { baseline?: number | null } = {},
+): ResolvedSeries {
+  if (transform === "raw") return { ...series, transform, points: applySeriesTransform(series.points, "raw") };
+  const percent = transform === "percent" || transform === "yoy" || transform === "qoq";
+  return {
+    ...series,
+    transform,
+    unit: percent ? "%" : transform === "index100" ? "index" : "log",
+    unitGroup: percent ? "percent" : transform === "index100" ? "index" : "log",
+    dataShape: "scalar",
+    style: series.style === "candles" || series.style === "ohlc" || series.style === "hlc"
+      ? "line"
+      : series.style,
+    points: applySeriesTransform(series.points, transform, options),
+  };
+}

package/src/time-series/types.ts

@@ -0,0 +1,162 @@
+import type { ChartResolution, TimeRange } from "../components/chart/core/types";
+import type { InstrumentRef } from "../market-data/request-types";
+
+export const CHART_SPEC_VERSION = 1 as const;
+
+export type SeriesPeriod = "auto" | "daily" | "weekly" | "monthly" | "quarterly" | "annual" | "ttm";
+export type SeriesStyle = "line" | "area" | "step" | "columns" | "points" | "candles" | "ohlc" | "hlc";
+export type SeriesTransform = "raw" | "percent" | "index100" | "yoy" | "qoq" | "log";
+export type SeriesAxis = "auto" | "left" | "right";
+export type SeriesInterpolation = "none" | "step-after";
+export type SeriesTimestampMode = "available-at" | "period-end";
+export type PanelScale = "linear" | "log";
+
+export interface SecuritySeriesSource {
+  kind: "security";
+  instrument: InstrumentRef;
+  fieldId: string;
+  period?: SeriesPeriod;
+  timestampMode?: SeriesTimestampMode;
+}
+
+export interface EconomicSeriesSource {
+  kind: "economic";
+  provider: "fred";
+  seriesId: string;
+}
+
+export type ChartSeriesSource = SecuritySeriesSource | EconomicSeriesSource;
+
+export interface ChartSeriesSpec {
+  id: string;
+  source: ChartSeriesSource;
+  label?: string;
+  style: SeriesStyle;
+  transform: SeriesTransform;
+  axis: SeriesAxis;
+  panelId: string;
+  interpolation: SeriesInterpolation;
+  color?: string;
+  visible?: boolean;
+}
+
+export type ChartStudyKind =
+  | "volume"
+  | "sma"
+  | "ema"
+  | "bollinger"
+  | "rsi"
+  | "macd"
+  | "ratio"
+  | "spread"
+  | "correlation";
+
+export interface ChartStudySpec {
+  id: string;
+  kind: ChartStudyKind;
+  inputSeriesIds: string[];
+  parameters: Record<string, number>;
+  panelId: string;
+  axis: SeriesAxis;
+  color?: string;
+  visible?: boolean;
+}
+
+export interface ChartPanelSpec {
+  id: string;
+  label?: string;
+  height?: number;
+  scale?: PanelScale;
+}
+
+export interface ChartViewportSpec {
+  range: TimeRange;
+  resolution: ChartResolution;
+  dateWindow?: { start: string; end: string };
+  /** Optional latest-observation cap, useful for period-based financial views. */
+  maxPoints?: number;
+}
+
+export interface ChartSpec {
+  version: typeof CHART_SPEC_VERSION;
+  viewport: ChartViewportSpec;
+  panels: ChartPanelSpec[];
+  series: ChartSeriesSpec[];
+  studies: ChartStudySpec[];
+}
+
+export type SeriesDataShape = "scalar" | "ohlcv" | "event" | "band";
+
+export interface TimeSeriesPoint {
+  date: Date;
+  observedAt: Date;
+  availableAt?: Date;
+  value: number | null;
+  open?: number | null;
+  high?: number | null;
+  low?: number | null;
+  close?: number | null;
+  volume?: number | null;
+  periodLabel?: string;
+  provenance?: {
+    providerId?: string;
+    quality?: "reported" | "derived" | "estimated";
+  };
+}
+
+export interface ResolvedSeriesMarketTimeBasis {
+  kind: "market";
+  /** IANA timezone used to recognize one exchange-local trading day. */
+  timeZone: string;
+  /** Requested bar cadence when known; otherwise the chart derives it. */
+  cadenceMs?: number;
+}
+
+export interface ResolvedSeries {
+  id: string;
+  label: string;
+  color: string;
+  unit: string;
+  unitGroup: string;
+  nativeFrequency: SeriesPeriod;
+  /** Authored time basis retained for layout and cursor semantics. */
+  timestampMode?: SeriesTimestampMode;
+  dataShape: SeriesDataShape;
+  style: SeriesStyle;
+  transform: SeriesTransform;
+  axis: Exclude<SeriesAxis, "auto">;
+  panelId: string;
+  interpolation: SeriesInterpolation;
+  /** Present only for exchange-traded market observations. */
+  timeBasis?: ResolvedSeriesMarketTimeBasis;
+  points: TimeSeriesPoint[];
+  warning?: string;
+}
+
+export interface TimeSeriesFieldDefinition {
+  id: string;
+  label: string;
+  shortLabel: string;
+  sourceKind: ChartSeriesSource["kind"];
+  dataShape: SeriesDataShape;
+  unit: string;
+  unitGroup: string;
+  nativeFrequency: SeriesPeriod;
+  styles: SeriesStyle[];
+  defaultStyle: SeriesStyle;
+  transforms: SeriesTransform[];
+  defaultInterpolation: SeriesInterpolation;
+}
+
+export interface ChartResolutionResult {
+  series: ResolvedSeries[];
+  /** 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. */
+  bufferedSeries?: ResolvedSeries[];
+  loading: boolean;
+  errors: string[];
+  warnings: string[];
+  /** Effective inclusive bounds used to clip the resolved chart data. */
+  viewport?: { start: Date; end: Date };
+}

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

@@ -0,0 +1,166 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  ChartResolveCache,
+  resolveChartSpecData,
+  type ChartResolveOptions,
+  type ChartResolveSources,
+} from "./resolve";
+import type { ChartResolutionResult, ChartSpec } from "./types";
+import {
+  LIVE_CHART_REFRESH_INTERVAL_MS,
+  liveChartQuoteTargetSignature,
+  subscribeToLiveChartQuotes,
+} from "./live-quotes";
+import type { Quote } from "../types/financials";
+
+export interface UseChartResolutionResult extends ChartResolutionResult {
+  reload: () => void;
+}
+
+export interface UseChartResolutionOptions {
+  liveRefreshIntervalMs?: number;
+  autoViewport?: ChartResolveOptions["autoViewport"];
+  targetPointCount?: number;
+}
+
+const EMPTY_RESULT: ChartResolutionResult = {
+  series: [],
+  loading: false,
+  errors: [],
+  warnings: [],
+};
+
+function withQuoteOverrides(
+  sources: ChartResolveSources,
+  liveOverrides: ReadonlyMap<string, Quote>,
+): ChartResolveSources {
+  if (liveOverrides.size === 0) return sources;
+  if (!sources.quoteOverrides || sources.quoteOverrides.size === 0) {
+    return { ...sources, quoteOverrides: liveOverrides };
+  }
+  const combined = new Map(sources.quoteOverrides);
+  for (const [key, quote] of liveOverrides) combined.set(key, quote);
+  return { ...sources, quoteOverrides: combined };
+}
+
+export function useChartResolution(
+  spec: ChartSpec,
+  sources: ChartResolveSources,
+  options: UseChartResolutionOptions = {},
+): UseChartResolutionResult {
+  const [result, setResult] = useState<ChartResolutionResult>(EMPTY_RESULT);
+  const [revision, setRevision] = useState(0);
+  const generationRef = useRef(0);
+  const liveSubscriptionGenerationRef = useRef(0);
+  const liveQuoteOverridesRef = useRef<ReadonlyMap<string, Quote>>(new Map());
+  const resolveCacheRef = useRef(new ChartResolveCache());
+  const cacheIdentityRef = useRef<{
+    spec: ChartSpec | null;
+    sources: ChartResolveSources | null;
+    revision: number;
+  }>({ spec: null, sources: null, revision: -1 });
+  const autoViewportStart = options.autoViewport?.start.getTime();
+  const autoViewportEnd = options.autoViewport?.end.getTime();
+  const validAutoViewport = typeof autoViewportStart === "number"
+      && Number.isFinite(autoViewportStart)
+      && typeof autoViewportEnd === "number"
+      && Number.isFinite(autoViewportEnd)
+      && autoViewportStart <= autoViewportEnd
+    ? { start: new Date(autoViewportStart), end: new Date(autoViewportEnd) }
+    : null;
+  const adaptiveTargetPointCount = validAutoViewport ? options.targetPointCount : undefined;
+  const resolveOptions: ChartResolveOptions = {
+    autoViewport: validAutoViewport,
+    targetPointCount: adaptiveTargetPointCount,
+  };
+  const latestRequestRef = useRef({ spec, sources, options: resolveOptions });
+  latestRequestRef.current = { spec, sources, options: resolveOptions };
+  const reload = useCallback(() => setRevision((current) => current + 1), []);
+
+  useEffect(() => {
+    generationRef.current += 1;
+    const generation = generationRef.current;
+    const cacheIdentity = cacheIdentityRef.current;
+    const resetCache = cacheIdentity.spec !== spec
+      || cacheIdentity.sources !== sources
+      || cacheIdentity.revision !== revision;
+    if (resetCache) {
+      resolveCacheRef.current = new ChartResolveCache();
+      cacheIdentityRef.current = { spec, sources, revision };
+    }
+    const cache = resolveCacheRef.current;
+    setResult((current) => ({ ...current, loading: true, errors: [] }));
+    resolveChartSpecData(
+      spec,
+      withQuoteOverrides(sources, liveQuoteOverridesRef.current),
+      cache,
+      resolveOptions,
+    )
+      .then((next) => {
+        if (generationRef.current === generation) setResult(next);
+      })
+      .catch((error) => {
+        if (generationRef.current !== generation) return;
+        setResult({
+          series: [],
+          loading: false,
+          errors: [error instanceof Error ? error.message : String(error)],
+          warnings: [],
+        });
+      });
+    return () => {
+      if (generationRef.current === generation) generationRef.current += 1;
+    };
+  }, [adaptiveTargetPointCount, autoViewportEnd, autoViewportStart, revision, sources, spec]);
+
+  const liveTargetSignature = liveChartQuoteTargetSignature(spec);
+  const liveRefreshIntervalMs = options.liveRefreshIntervalMs ?? LIVE_CHART_REFRESH_INTERVAL_MS;
+  useEffect(() => {
+    const subscriptionGeneration = ++liveSubscriptionGenerationRef.current;
+    liveQuoteOverridesRef.current = new Map();
+    const dispose = subscribeToLiveChartQuotes({
+      spec,
+      dataProvider: sources.dataProvider,
+      refreshIntervalMs: liveRefreshIntervalMs,
+      onRefresh: async (quoteOverrides) => {
+        if (liveSubscriptionGenerationRef.current !== subscriptionGeneration) return;
+        liveQuoteOverridesRef.current = quoteOverrides;
+        const request = latestRequestRef.current;
+        const generation = ++generationRef.current;
+        try {
+          const next = await resolveChartSpecData(
+            request.spec,
+            withQuoteOverrides(request.sources, quoteOverrides),
+            resolveCacheRef.current,
+            request.options,
+          );
+          if (
+            liveSubscriptionGenerationRef.current === subscriptionGeneration
+            && generationRef.current === generation
+          ) {
+            setResult(next);
+          }
+        } catch (error) {
+          if (
+            liveSubscriptionGenerationRef.current !== subscriptionGeneration
+            || generationRef.current !== generation
+          ) return;
+          setResult((current) => ({
+            ...current,
+            loading: false,
+            errors: [error instanceof Error ? error.message : String(error)],
+          }));
+        }
+      },
+    });
+    return () => {
+      dispose();
+      if (liveSubscriptionGenerationRef.current === subscriptionGeneration) {
+        liveSubscriptionGenerationRef.current += 1;
+        liveQuoteOverridesRef.current = new Map();
+      }
+    };
+  }, [liveRefreshIntervalMs, liveTargetSignature, sources.dataProvider]);
+
+  return { ...result, reload };
+}

package/src/types/config.ts

@@ -1,12 +1,11 @@
 import type { Portfolio, Watchlist } from "./ticker";
+import type { LanguagePreference } from "../i18n/languages";
 
-export const CURRENT_CONFIG_VERSION = 19;
+export const CURRENT_CONFIG_VERSION = 20;
 
-type DefaultChartRenderMode = "area" | "line" | "candles" | "ohlc" | "hlc";
 type ChartRendererPreference = "auto" | "kitty" | "braille";
 
 export interface ChartPreferences {
-  defaultRenderMode: DefaultChartRenderMode;
   renderer: ChartRendererPreference;
 }
 
@@ -135,21 +134,26 @@ export interface AppConfig {
   chartPreferences: ChartPreferences;
   valueFlashingEnabled: boolean;
   recentTickers: string[];
+  language?: LanguagePreference;
   onboardingComplete?: boolean;
 }
 
 export const TICKER_RESEARCH_PANE_ID = "ticker-research";
 export const LEGACY_TICKER_DETAIL_PANE_ID = "ticker-detail";
+export const CHART_COMPOSER_PANE_ID = "chart-composer";
 
 export function normalizePaneId(paneId: string): string {
-  return paneId === LEGACY_TICKER_DETAIL_PANE_ID ? TICKER_RESEARCH_PANE_ID : paneId;
+  if (paneId === LEGACY_TICKER_DETAIL_PANE_ID) return TICKER_RESEARCH_PANE_ID;
+  if (paneId === "comparison-chart" || paneId === "ticker-chart" || paneId === "fundamental-graph") {
+    return CHART_COMPOSER_PANE_ID;
+  }
+  return paneId;
 }
 
 const TICKER_PANE_IDS = new Set([
   TICKER_RESEARCH_PANE_ID,
   LEGACY_TICKER_DETAIL_PANE_ID,
   "financial-analysis",
-  "ticker-chart",
   "quote-monitor",
   "ticker-news",
   "notes",
@@ -161,7 +165,6 @@ const TICKER_PANE_IDS = new Set([
   "corporate-actions",
   "earnings-estimates",
   "historical-prices",
-  "fundamental-graph",
   "ibkr-trading",
 ]);
 
@@ -226,8 +229,6 @@ const DEFAULT_HOME_LAYOUT: LayoutConfig = {
       settings: {
         hideTabs: false,
         lockedTabId: "overview",
-        chartRangePreset: "5Y",
-        chartResolution: "auto",
       },
       binding: { kind: "follow", sourceInstanceId: "portfolio-list:main" },
     },
@@ -238,8 +239,6 @@ const DEFAULT_HOME_LAYOUT: LayoutConfig = {
       settings: {
         hideTabs: false,
         lockedTabId: "overview",
-        chartRangePreset: "5Y",
-        chartResolution: "auto",
       },
       binding: { kind: "fixed", symbol: "NVDA" },
     },
@@ -630,7 +629,6 @@ export function createDefaultConfig(dataDir: string): AppConfig {
     pluginConfig: {},
     theme: "amber",
     chartPreferences: {
-      defaultRenderMode: "area",
       renderer: "auto",
     },
     valueFlashingEnabled: true,

package/src/types/desktop-window.ts

@@ -7,6 +7,7 @@ export interface DesktopSharedStateSnapshot {
   focusedPaneId: string | null;
   activePanel: "left" | "right";
   statusBarVisible: boolean;
+  mainStateRevision?: number;
   layoutChanged?: boolean;
 }
 

package/src/types/financials.ts

@@ -216,6 +216,10 @@ export interface CompanyProfile {
 
 export interface FinancialStatement {
   date: string;
+  /** Earliest date on which the complete row was publicly available, when known. */
+  availableAt?: string;
+  /** Per-field publication dates used by point-in-time charts and calculations. */
+  fieldAvailability?: Record<string, string>;
   // Income Statement
   totalRevenue?: number;
   costOfRevenue?: number;

package/src/types/media.ts

@@ -0,0 +1,17 @@
+export interface LiveStreamResolveRequest {
+  provider: "youtube";
+  sourceId: string;
+  force?: boolean;
+}
+
+export interface ResolvedLiveStream {
+  provider: "youtube";
+  sourceId: string;
+  videoId: string;
+  title: string;
+  manifestUrl: string;
+  watchUrl: string;
+  posterUrl?: string;
+  resolvedAt: number;
+  expiresAt: number;
+}

package/src/types/plugin.ts

@@ -78,6 +78,8 @@ interface PaneSettingFieldBase {
   label: string;
   description?: string;
   storage?: "pane" | "plugin";
+  /** Keys in the same storage scope that should be reset when this value changes. */
+  clearOnChange?: string[];
 }
 
 interface PaneSettingToggleField extends PaneSettingFieldBase {
@@ -104,17 +106,43 @@ interface PaneSettingOrderedMultiSelectField extends PaneSettingFieldBase {
   options: PaneSettingOption[];
 }
 
+export interface PaneSettingActionContext extends PaneSettingsContext {
+  surface: "pane-dialog" | "command-bar";
+  close(): void;
+  openCommandBar(query?: string): void;
+  notify(notification: AppNotificationRequest): void;
+}
+
+export type PaneSettingActionHandler = (
+  context: PaneSettingActionContext,
+) => void | Promise<void>;
+
+export type PaneSettingActionField = Omit<PaneSettingFieldBase, "storage" | "clearOnChange"> & {
+  type: "action";
+  actionId: string;
+  actionLabel?: string;
+  disabled?: boolean;
+  action: PaneSettingActionHandler;
+};
+
 export type PaneSettingField =
   | PaneSettingToggleField
   | PaneSettingTextField
   | PaneSettingSelectField
   | PaneSettingMultiSelectField
-  | PaneSettingOrderedMultiSelectField;
+  | PaneSettingOrderedMultiSelectField
+  | PaneSettingActionField;
 
 export interface PaneSettingsDef {
   title?: string;
   values?: Record<string, unknown>;
   fields: PaneSettingField[];
+  applyValue?: (
+    settings: Record<string, unknown>,
+    field: PaneSettingField,
+    value: unknown,
+    context: PaneSettingsContext,
+  ) => Record<string, unknown> | Promise<Record<string, unknown>>;
 }
 
 export interface PaneTemplateContext {
@@ -172,9 +200,12 @@ export interface WizardStep {
   label: string;
   placeholder?: string;
   defaultValue?: string;
+  required?: boolean;
   type?: "text" | "password" | "info" | "select" | "number" | "textarea";
   options?: Array<{ label: string; value: string }>;
   dependsOn?: { key: string; value: string };
+  /** Later wizard values to clear when this selection changes from its default. */
+  clearOnChange?: string[];
   body?: string[];
 }