gloomberb 0.9.9 → 0.10.0

package/src/data/config/layout.ts

@@ -13,6 +13,10 @@ import {
   normalizePaneLayout,
   normalizePaneId,
 } from "../../types/config";
+import {
+  migrateChartPaneSettings,
+  type LegacyChartMigrationContext,
+} from "./chart-settings";
 
 export function isLayoutConfig(value: unknown): value is LayoutConfig {
   return !!value
@@ -116,7 +120,11 @@ function sanitizePaneSettings(value: unknown): Record<string, unknown> | undefin
   return Object.keys(settings).length > 0 ? clonePaneSettings(settings) : undefined;
 }
 
-function sanitizePaneInstances(value: unknown, fallback: LayoutConfig): PaneInstanceConfig[] {
+function sanitizePaneInstances(
+  value: unknown,
+  fallback: LayoutConfig,
+  chartMigration: LegacyChartMigrationContext,
+): PaneInstanceConfig[] {
   if (!Array.isArray(value)) return cloneLayout(fallback).instances;
   const seen = new Set<string>();
   const instances = value
@@ -127,20 +135,23 @@ function sanitizePaneInstances(value: unknown, fallback: LayoutConfig): PaneInst
       && typeof (entry as PaneInstanceConfig).paneId === "string",
     )
     .map((entry) => {
+      const originalPaneId = entry.paneId;
       const paneId = normalizePaneId(entry.paneId);
       const instanceId = seen.has(entry.instanceId) ? createPaneInstanceId(paneId) : entry.instanceId;
       seen.add(instanceId);
+      const binding = sanitizePaneBinding(entry.binding);
+      const settings = sanitizePaneSettings(entry.settings);
       return {
         instanceId,
         paneId,
         title: typeof entry.title === "string" ? entry.title : undefined,
-        binding: sanitizePaneBinding(entry.binding),
+        binding,
         params: entry.params && typeof entry.params === "object"
           ? Object.fromEntries(
             Object.entries(entry.params).filter((param): param is [string, string] => typeof param[1] === "string"),
           )
           : undefined,
-        settings: sanitizePaneSettings(entry.settings),
+        settings: migrateChartPaneSettings(originalPaneId, binding, settings, chartMigration),
         placementMemory: sanitizePlacementMemory(entry.placementMemory),
       };
     });
@@ -196,7 +207,11 @@ function sanitizeDetachedEntries(value: unknown, validInstanceIds: Set<string>):
     }));
 }
 
-export function sanitizeLayout(value: unknown, fallback: LayoutConfig): LayoutConfig {
+export function sanitizeLayout(
+  value: unknown,
+  fallback: LayoutConfig,
+  chartMigration: LegacyChartMigrationContext = {},
+): LayoutConfig {
   if (!isLayoutConfig(value)) {
     return cloneLayout(fallback);
   }
@@ -208,7 +223,11 @@ export function sanitizeLayout(value: unknown, fallback: LayoutConfig): LayoutCo
     });
   }
 
-  const instances = sanitizePaneInstances((value as LayoutConfig & { instances?: unknown }).instances, fallback);
+  const instances = sanitizePaneInstances(
+    (value as LayoutConfig & { instances?: unknown }).instances,
+    fallback,
+    chartMigration,
+  );
   const validInstanceIds = new Set(instances.map((entry) => entry.instanceId));
   const dockRoot = (value as { dockRoot?: LayoutConfig["dockRoot"] }).dockRoot ?? null;
   const floating = sanitizeFloatingEntries((value as { floating?: unknown }).floating, validInstanceIds);

package/src/data/config/store/index.test.ts

@@ -37,7 +37,7 @@ function createSavedConfig(overrides: Record<string, unknown> = {}): Record<stri
     brokerInstances: [],
     disabledPlugins: [],
     theme: "amber",
-    chartPreferences: { defaultRenderMode: "area", renderer: "auto" },
+    chartPreferences: { renderer: "auto" },
     valueFlashingEnabled: true,
     recentTickers: [],
     ...overrides,
@@ -49,6 +49,17 @@ async function writeConfigJson(dataDir: string, config: Record<string, unknown>)
 }
 
 describe("sanitizeLayout", () => {
+  test("keeps the default research layout free of retired chart settings", () => {
+    const researchPanes = DEFAULT_LAYOUT.instances.filter((instance) => instance.paneId === "ticker-research");
+    expect(researchPanes.length).toBeGreaterThan(0);
+    for (const pane of researchPanes) {
+      expect(pane.settings).not.toHaveProperty("chartRangePreset");
+      expect(pane.settings).not.toHaveProperty("chartResolution");
+      expect(pane.settings).not.toHaveProperty("chartAxisMode");
+      expect(pane.settings).not.toHaveProperty("chartRenderMode");
+    }
+  });
+
   test("rewrites unbound ticker-detail panes to follow the first portfolio pane", () => {
     const layout = sanitizeLayout({
       dockRoot: {
@@ -159,6 +170,88 @@ describe("sanitizeLayout", () => {
     });
   });
 
+  test("converts retired chart panes into composer specs", () => {
+    const layout = sanitizeLayout({
+      dockRoot: { kind: "pane", instanceId: "comparison-chart:main" },
+      instances: [{
+        instanceId: "comparison-chart:main",
+        paneId: "comparison-chart",
+        binding: { kind: "none" },
+        settings: {
+          symbols: ["AAPL", "MSFT"],
+          axisMode: "percent",
+          rangePreset: "1Y",
+          chartResolution: "1d",
+        },
+      }],
+      floating: [],
+      detached: [],
+    }, DEFAULT_LAYOUT);
+
+    const pane = findPaneInstance(layout, "comparison-chart:main");
+    expect(pane?.paneId).toBe("chart-composer");
+    expect(pane?.settings).toEqual({
+      chartSpec: expect.objectContaining({
+        version: 1,
+        viewport: { range: "1Y", resolution: "1d" },
+        series: [
+          expect.objectContaining({
+            transform: "percent",
+            interpolation: "none",
+            source: expect.objectContaining({ fieldId: "market.close" }),
+          }),
+          expect.objectContaining({
+            transform: "percent",
+            interpolation: "none",
+            source: expect.objectContaining({ fieldId: "market.close" }),
+          }),
+        ],
+      }),
+    });
+  });
+
+  test("migrates ticker research chart settings into one composer spec", () => {
+    const layout = sanitizeLayout({
+      dockRoot: { kind: "pane", instanceId: "ticker-detail:aapl" },
+      instances: [{
+        instanceId: "ticker-detail:aapl",
+        paneId: "ticker-research",
+        binding: { kind: "fixed", symbol: "AAPL" },
+        settings: {
+          hideTabs: true,
+          lockedTabId: "fundamental-graphs",
+          chartAxisMode: "percent",
+          chartRangePreset: "1Y",
+          chartResolution: "1wk",
+        },
+      }],
+      floating: [],
+      detached: [],
+    }, DEFAULT_LAYOUT);
+
+    const settings = findPaneInstance(layout, "ticker-detail:aapl")?.settings;
+    expect(settings).toEqual({
+      hideTabs: true,
+      lockedTabId: "chart",
+      chartSpec: expect.objectContaining({
+        version: 1,
+        viewport: { range: "1Y", resolution: "1wk" },
+        series: [expect.objectContaining({
+          transform: "percent",
+          interpolation: "none",
+          source: expect.objectContaining({
+            kind: "security",
+            instrument: { symbol: "AAPL" },
+            fieldId: "market.ohlcv",
+          }),
+        })],
+      }),
+    });
+    expect(settings).not.toHaveProperty("chartAxisMode");
+    expect(settings).not.toHaveProperty("chartRangePreset");
+    expect(settings).not.toHaveProperty("chartResolution");
+  });
+
   test("falls back to the default layout when given an obsolete column layout", () => {
     const layout = sanitizeLayout({
       columns: [{ width: "100%" }],
@@ -179,6 +272,175 @@ describe("sanitizeLayout", () => {
 });
 
 describe("loadConfig", () => {
+  test("folds saved graph plugin state into composer specs and removes only chart-owned state", async () => {
+    const dataDir = await createTempConfigDir();
+    const legacyLayout = {
+      dockRoot: {
+        kind: "split" as const,
+        axis: "horizontal" as const,
+        ratio: 0.5,
+        first: { kind: "pane" as const, instanceId: "fundamental-graph:pair" },
+        second: { kind: "pane" as const, instanceId: "ticker-detail:nvda" },
+      },
+      instances: [
+        {
+          instanceId: "fundamental-graph:pair",
+          paneId: "fundamental-graph",
+          binding: { kind: "fixed" as const, symbol: "AAPL" },
+          settings: {
+            chartKind: "fundamental",
+            metric: "totalRevenue",
+            period: "quarterly",
+            periods: 8,
+            symbols: ["AAPL", "MSFT"],
+            symbolsText: "AAPL, MSFT",
+          },
+        },
+        {
+          instanceId: "ticker-detail:nvda",
+          paneId: "ticker-research",
+          binding: { kind: "fixed" as const, symbol: "NVDA" },
+          settings: {
+            hideTabs: true,
+            lockedTabId: "fundamental-graphs",
+            chartRangePreset: "1Y",
+            chartResolution: "1wk",
+          },
+        },
+      ],
+      floating: [],
+      detached: [],
+    };
+    await writeConfigJson(dataDir, createSavedConfig({
+      configVersion: CURRENT_CONFIG_VERSION - 1,
+      layout: legacyLayout,
+      layouts: [{
+        name: "Graphs",
+        layout: legacyLayout,
+        paneState: {
+          "fundamental-graph:pair": {
+            cursorSymbol: "AAPL",
+            pluginState: {
+              "ticker-detail": {
+                period: "annual",
+                chartKind: "valuation",
+                metric: "evSales",
+                periods: 3,
+                selectedIdx: 4,
+                hiddenSeriesIds: ["MSFT"],
+                retainedPreference: "keep",
+              },
+            },
+          },
+          "ticker-detail:nvda": {
+            activeTabId: "fundamental-graphs",
+            financialSubTab: "cashflow",
+            pluginState: {
+              "ticker-detail": {
+                detailPeriod: "annual",
+                detailChartKind: "fundamental",
+                detailMetric: "grossProfit",
+                selectedIdx: 2,
+                hiddenSeriesIds: [],
+                retainedPreference: "keep-too",
+              },
+            },
+          },
+        },
+      }],
+      activeLayoutIndex: 0,
+    }));
+
+    const config = await loadConfig(dataDir);
+    const standalone = findPaneInstance(config.layout, "fundamental-graph:pair");
+    const standaloneSpec = standalone?.settings?.chartSpec as any;
+    expect(standalone?.paneId).toBe("chart-composer");
+    expect(standalone?.settings).toEqual({ chartSpec: expect.any(Object) });
+    expect(standaloneSpec.viewport).toEqual({ range: "ALL", resolution: "auto", maxPoints: 3 });
+    expect(standaloneSpec.series.map((series: any) => ({
+      symbol: series.source.instrument.symbol,
+      fieldId: series.source.fieldId,
+      period: series.source.period,
+      visible: series.visible,
+    }))).toEqual([
+      { symbol: "AAPL", fieldId: "valuation.evSales", period: "annual", visible: true },
+      { symbol: "MSFT", fieldId: "valuation.evSales", period: "annual", visible: false },
+    ]);
+
+    const research = findPaneInstance(config.layout, "ticker-detail:nvda");
+    const researchSpec = research?.settings?.chartSpec as any;
+    expect(research?.settings?.lockedTabId).toBe("chart");
+    expect(researchSpec.viewport).toEqual({ range: "ALL", resolution: "auto", maxPoints: undefined });
+    expect(researchSpec.series[0]).toEqual(expect.objectContaining({
+      style: "columns",
+      source: expect.objectContaining({
+        fieldId: "fundamental.grossProfit",
+        period: "annual",
+      }),
+    }));
+
+    expect(config.layouts[0]?.paneState).toEqual({
+      "fundamental-graph:pair": {
+        cursorSymbol: "AAPL",
+        pluginState: { "ticker-research": { retainedPreference: "keep" } },
+      },
+      "ticker-detail:nvda": {
+        activeTabId: "chart",
+        financialSubTab: "cashflow",
+        pluginState: { "ticker-research": { retainedPreference: "keep-too" } },
+      },
+    });
+  });
+
+  test("migrates global indicator selection and render mode without retaining plugin keys", async () => {
+    const dataDir = await createTempConfigDir();
+    const legacyLayout = {
+      dockRoot: { kind: "pane" as const, instanceId: "ticker-chart:aapl" },
+      instances: [{
+        instanceId: "ticker-chart:aapl",
+        paneId: "ticker-chart",
+        binding: { kind: "fixed" as const, symbol: "AAPL" },
+        settings: {
+          chartAxisMode: "percent",
+          chartRangePreset: "6M",
+          chartResolution: "1d",
+          chartRenderMode: "candles",
+        },
+      }],
+      floating: [],
+      detached: [],
+    };
+    await writeConfigJson(dataDir, createSavedConfig({
+      configVersion: CURRENT_CONFIG_VERSION - 1,
+      layout: legacyLayout,
+      layouts: [{ name: "Price", layout: legacyLayout }],
+      activeLayoutIndex: 0,
+      chartPreferences: { renderer: "kitty", defaultRenderMode: "line" },
+      pluginConfig: {
+        "ticker-detail": {
+          chartIndicators: ["sma50", "bollinger20"],
+          chartIndicatorsVersion: 2,
+          retainedPreference: "keep",
+        },
+      },
+    }));
+
+    const config = await loadConfig(dataDir);
+    const pane = findPaneInstance(config.layout, "ticker-chart:aapl");
+    const spec = pane?.settings?.chartSpec as any;
+    expect(pane?.paneId).toBe("chart-composer");
+    expect(spec.viewport).toEqual({ range: "6M", resolution: "1d" });
+    expect(spec.series[0]).toEqual(expect.objectContaining({ style: "candles", transform: "raw" }));
+    expect(spec.studies.map((study: any) => ({ kind: study.kind, parameters: study.parameters }))).toEqual([
+      { kind: "sma", parameters: { period: 50 } },
+      { kind: "bollinger", parameters: { period: 20, stdDev: 2 } },
+    ]);
+    expect(config.pluginConfig).toEqual({
+      "ticker-research": { retainedPreference: "keep" },
+    });
+    expect(config.chartPreferences).toEqual({ renderer: "kitty" });
+  });
+
   test("defaults detached layouts to an empty list for older configs", async () => {
     const dataDir = await createTempConfigDir();
     const layoutWithoutDetached = {
@@ -209,7 +471,6 @@ describe("loadConfig", () => {
     const config = await loadConfig(dataDir);
 
     expect(config.chartPreferences).toEqual({
-      defaultRenderMode: "area",
       renderer: "auto",
     });
   });
@@ -219,7 +480,6 @@ describe("loadConfig", () => {
     await writeConfigJson(dataDir, createSavedConfig({
       configVersion: 7,
       chartPreferences: {
-        defaultRenderMode: "hlc",
         renderer: "nope",
       },
     }));
@@ -227,7 +487,6 @@ describe("loadConfig", () => {
     const config = await loadConfig(dataDir);
 
     expect(config.chartPreferences).toEqual({
-      defaultRenderMode: "hlc",
       renderer: "auto",
     });
     expect(config.pluginConfig).toEqual({});
@@ -261,7 +520,7 @@ describe("loadConfig", () => {
           displayMode: "expanded",
         },
       },
-      chartPreferences: { defaultRenderMode: "line" },
+      chartPreferences: { renderer: "auto" },
     }));
 
     const config = await loadConfig(dataDir);
@@ -285,16 +544,43 @@ describe("loadConfig", () => {
     expect(config.disabledPlugins).toEqual(["chat", "news"]);
   });
 
-  test("migrates disabled built-in feature plugins to grouped plugin ids", async () => {
+  test("migrates disabled built-in modules to their owning plugin ids", async () => {
     const dataDir = await createTempConfigDir();
     await writeConfigJson(dataDir, createSavedConfig({
       configVersion: CURRENT_CONFIG_VERSION - 1,
-      disabledPlugins: ["options", "sec", "world-indices", "earnings-calendar", "ibkr", "broker-manager", "options"],
+      disabledPlugins: [
+        "options",
+        "sec",
+        "thirteenf",
+        "world-indices",
+        "market-heatmap",
+        "fear-greed",
+        "chart-composer",
+        "comparison-chart",
+        "earnings-calendar",
+        "macro-tv",
+        "ibkr",
+        "broker-manager",
+        "analytics",
+        "kelly-sizer",
+        "portfolio-list",
+        "changelog",
+        "help",
+        "layout-manager",
+        "application",
+      ],
     }));
 
     const config = await loadConfig(dataDir);
 
-    expect(config.disabledPlugins).toEqual(["ticker-research", "market-overview", "macro", "ibkr", "broker"]);
+    expect(config.disabledPlugins).toEqual([
+      "ticker-research",
+      "market-overview",
+      "macro",
+      "ibkr",
+      "broker",
+      "portfolio",
+    ]);
   });
 
   test("migrates grouped built-in plugin config keys", async () => {
@@ -308,6 +594,16 @@ describe("loadConfig", () => {
         "company-research": {
           preferredTab: "analyst-research",
         },
+        "kelly-sizer": {
+          inherited: true,
+          shared: "legacy",
+        },
+        portfolio: {
+          shared: "canonical",
+        },
+        changelog: {
+          dismissedVersion: "1.2.3",
+        },
       },
     }));
 
@@ -318,9 +614,28 @@ describe("loadConfig", () => {
         selectedExpiration: "2026-06-19",
         preferredTab: "analyst-research",
       },
+      portfolio: {
+        inherited: true,
+        shared: "canonical",
+      },
+      application: {
+        dismissedVersion: "1.2.3",
+      },
     });
   });
 
+  test("does not repeat the legacy Cloud-to-Macro disable migration", async () => {
+    const dataDir = await createTempConfigDir();
+    await writeConfigJson(dataDir, createSavedConfig({
+      configVersion: CURRENT_CONFIG_VERSION - 1,
+      disabledPlugins: ["gloomberb-cloud"],
+    }));
+
+    const config = await loadConfig(dataDir);
+
+    expect(config.disabledPlugins).toEqual(["gloomberb-cloud"]);
+  });
+
   test("enables Gloom Cloud when migrating older default configs", async () => {
     const dataDir = await createTempConfigDir();
     await writeConfigJson(dataDir, createSavedConfig({
@@ -361,14 +676,20 @@ describe("loadConfig", () => {
     });
   });
 
-  test("preserves saved layout pane state and focus metadata", async () => {
+  test("migrates legacy saved pane tab IDs and preserves focus metadata", async () => {
     const dataDir = await createTempConfigDir();
     await writeConfigJson(dataDir, createSavedConfig({
       layouts: [{
         name: "Chart",
         layout: DEFAULT_LAYOUT,
         paneState: {
-          "ticker-detail:main": { activeTabId: "chart" },
+          "ticker-detail:main": {
+            activeTabId: "fundamental-graphs",
+            pluginState: {
+              "ticker-detail": { detailMetric: "revenue", shared: "legacy" },
+              "ticker-research": { shared: "canonical" },
+            },
+          },
           "missing:pane": { activeTabId: "overview" },
         },
         focusedPaneId: "ticker-detail:main",
@@ -379,7 +700,12 @@ describe("loadConfig", () => {
     const config = await loadConfig(dataDir);
 
     expect(config.layouts[0]?.paneState).toEqual({
-      "ticker-detail:main": { activeTabId: "chart" },
+      "ticker-detail:main": {
+        activeTabId: "chart",
+        pluginState: {
+          "ticker-research": { shared: "canonical" },
+        },
+      },
     });
     expect(config.layouts[0]?.focusedPaneId).toBe("ticker-detail:main");
     expect(config.layouts[0]?.activePanel).toBe("right");
@@ -389,7 +715,12 @@ describe("loadConfig", () => {
       layouts: Array<{ paneState?: Record<string, unknown>; focusedPaneId?: string | null; activePanel?: string }>;
     };
     expect(persisted.layouts[0]?.paneState).toEqual({
-      "ticker-detail:main": { activeTabId: "chart" },
+      "ticker-detail:main": {
+        activeTabId: "chart",
+        pluginState: {
+          "ticker-research": { shared: "canonical" },
+        },
+      },
     });
     expect(persisted.layouts[0]?.focusedPaneId).toBe("ticker-detail:main");
     expect(persisted.layouts[0]?.activePanel).toBe("right");
@@ -426,6 +757,37 @@ describe("loadConfig", () => {
       .toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
   });
 
+  test("does not replay the portfolio column migration for version 19 configs", async () => {
+    const dataDir = await createTempConfigDir();
+    const selectedColumnIds = DEFAULT_COLUMNS.map((column) => column.id);
+    const layout = {
+      ...DEFAULT_LAYOUT,
+      instances: DEFAULT_LAYOUT.instances.map((instance) => (
+        instance.instanceId === "portfolio-list:main"
+          ? {
+            ...instance,
+            settings: {
+              ...(instance.settings ?? {}),
+              columnIds: selectedColumnIds,
+            },
+          }
+          : instance
+      )),
+    };
+
+    await writeConfigJson(dataDir, createSavedConfig({
+      configVersion: 19,
+      layout,
+      layouts: [{ name: "Default", layout }],
+    }));
+
+    const config = await loadConfig(dataDir);
+
+    expect(findPaneInstance(config.layout, "portfolio-list:main")?.settings?.columnIds).toEqual(selectedColumnIds);
+    expect(findPaneInstance(config.layouts[0]?.layout ?? DEFAULT_LAYOUT, "portfolio-list:main")?.settings?.columnIds)
+      .toEqual(selectedColumnIds);
+  });
+
   test("falls back to the default layout when persisted layouts use the obsolete column shape", async () => {
     const dataDir = await createTempConfigDir();
     const obsoleteLayout = {
@@ -456,7 +818,8 @@ describe("loadConfig", () => {
     expect(config.configVersion).toBe(CURRENT_CONFIG_VERSION);
     expect(config.activeLayoutIndex).toBe(1);
     expect(config.layouts.map((layout) => layout.name)).toEqual(["Default", "Research"]);
-    expect(config.layout).toEqual(DEFAULT_LAYOUT);
+    const expectedLayout = sanitizeLayout(DEFAULT_LAYOUT, DEFAULT_LAYOUT);
+    expect(config.layout).toEqual(expectedLayout);
 
     await saveConfig(config);
     const persisted = JSON.parse(await readFile(join(dataDir, "config.json"), "utf-8")) as {
@@ -467,7 +830,7 @@ describe("loadConfig", () => {
 
     expect(persisted.configVersion).toBe(CURRENT_CONFIG_VERSION);
     expect(persisted.activeLayoutIndex).toBe(1);
-    expect(persisted.layouts[1]?.layout).toEqual(DEFAULT_LAYOUT as unknown as Record<string, unknown>);
+    expect(persisted.layouts[1]?.layout).toEqual(JSON.parse(JSON.stringify(expectedLayout)));
   });
 });