gloomberb 0.9.5 → 0.9.7

package/src/plugins/builtin/market-heatmap/data.ts

@@ -0,0 +1,296 @@
+import { YahooHttpClient } from "../../../sources/yahoo-finance/http";
+import { httpFetch, type HttpFetchTransport } from "../../../utils/http-transport";
+
+export const MARKET_HEATMAP_UNIVERSES = [
+  { id: "us-equity", label: "US Stocks", yahooQuoteType: "EQUITY", sortField: "intradaymarketcap", sizeField: "intradaymarketcap", minSize: 1_000_000_000 },
+  { id: "us-etf", label: "US ETFs", yahooQuoteType: "ETF", sortField: "fundnetassets", sizeField: "fundnetassets", minSize: 1_000_000_000 },
+] as const;
+
+export type MarketHeatmapUniverseId = typeof MARKET_HEATMAP_UNIVERSES[number]["id"];
+export type MarketHeatmapSource = "yahoo" | "nasdaq";
+export type MarketHeatmapSizeKind = "market-cap" | "net-assets";
+
+export interface MarketHeatmapAsset {
+  symbol: string;
+  name: string;
+  price: number;
+  change: number;
+  changePercent: number;
+  size: number | null;
+  sizeKind: MarketHeatmapSizeKind;
+  volume: number | null;
+  currency: string;
+  exchange: string;
+  sector: string | null;
+  industry: string | null;
+  marketState: string | null;
+  source: MarketHeatmapSource;
+}
+
+export interface MarketHeatmapResult {
+  universe: MarketHeatmapUniverseId;
+  source: MarketHeatmapSource;
+  fetchedAt: number;
+  assets: MarketHeatmapAsset[];
+}
+
+export interface MarketHeatmapFetchOptions {
+  count?: number;
+  forceRefresh?: boolean;
+  cache?: boolean;
+}
+
+export interface YahooMarketHeatmapClient {
+  postJsonWithCrumb<T>(url: string, body: unknown): Promise<T>;
+}
+
+export type MarketHeatmapFetchTransport = HttpFetchTransport;
+
+export interface MarketHeatmapSources {
+  yahooClient?: YahooMarketHeatmapClient;
+  nasdaqFetch?: MarketHeatmapFetchTransport;
+}
+
+const YAHOO_SCREENER_URL = "https://query1.finance.yahoo.com/v1/finance/screener?lang=en-US&region=US&formatted=false&corsDomain=finance.yahoo.com";
+const NASDAQ_SCREENER_URL = "https://api.nasdaq.com/api/screener/stocks";
+const DEFAULT_COUNT = 80;
+const CACHE_TTL_MS = 60_000;
+const defaultYahooClient = new YahooHttpClient();
+const activeFetches = new Map<string, Promise<MarketHeatmapResult>>();
+const memoryCache = new Map<string, { expiresAt: number; result: MarketHeatmapResult }>();
+
+const NASDAQ_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+  Accept: "application/json,text/plain,*/*",
+  "Accept-Language": "en-US,en;q=0.9",
+  Origin: "https://www.nasdaq.com",
+  Referer: "https://www.nasdaq.com/",
+};
+
+function universeSpec(universe: MarketHeatmapUniverseId) {
+  return MARKET_HEATMAP_UNIVERSES.find((entry) => entry.id === universe) ?? MARKET_HEATMAP_UNIVERSES[0];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function getString(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function getNumber(record: Record<string, unknown>, key: string): number | null {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function parseLooseNumber(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "N/A" || trimmed === "--") return null;
+  const negative = trimmed.startsWith("(") && trimmed.endsWith(")");
+  const parsed = Number(trimmed.replace(/[$,%(),]/g, ""));
+  if (!Number.isFinite(parsed)) return null;
+  return negative ? -parsed : parsed;
+}
+
+function sizeKindForUniverse(universe: MarketHeatmapUniverseId): MarketHeatmapSizeKind {
+  return universe === "us-etf" ? "net-assets" : "market-cap";
+}
+
+function buildYahooScreenerBody(universe: MarketHeatmapUniverseId, count: number): unknown {
+  const spec = universeSpec(universe);
+  return {
+    size: count,
+    offset: 0,
+    sortField: spec.sortField,
+    sortType: "DESC",
+    quoteType: spec.yahooQuoteType,
+    topOperator: "AND",
+    query: {
+      operator: "AND",
+      operands: [
+        { operator: "EQ", operands: ["region", "us"] },
+        { operator: "EQ", operands: ["quoteType", spec.yahooQuoteType] },
+        { operator: "GT", operands: [spec.sizeField, spec.minSize] },
+      ],
+    },
+    userId: "",
+    userIdType: "guid",
+  };
+}
+
+export function parseYahooMarketHeatmapResponse(data: unknown, universe: MarketHeatmapUniverseId): MarketHeatmapAsset[] {
+  if (!isRecord(data)) return [];
+  const finance = isRecord(data.finance) ? data.finance : null;
+  const results = Array.isArray(finance?.result) ? finance.result : [];
+  const first = isRecord(results[0]) ? results[0] : null;
+  const quotes = Array.isArray(first?.quotes) ? first.quotes : [];
+  const sizeKind = sizeKindForUniverse(universe);
+  const assets: MarketHeatmapAsset[] = [];
+
+  for (const quote of quotes) {
+    if (!isRecord(quote)) continue;
+    const symbol = getString(quote, "symbol");
+    if (!symbol) continue;
+    const size = sizeKind === "net-assets"
+      ? getNumber(quote, "netAssets") ?? getNumber(quote, "fundNetAssets")
+      : getNumber(quote, "marketCap") ?? getNumber(quote, "intradayMarketCap");
+    const price = getNumber(quote, "regularMarketPrice") ?? 0;
+    const change = getNumber(quote, "regularMarketChange") ?? 0;
+    const changePercent = getNumber(quote, "regularMarketChangePercent") ?? 0;
+
+    assets.push({
+      symbol,
+      name: getString(quote, "shortName") ?? getString(quote, "longName") ?? getString(quote, "displayName") ?? symbol,
+      price,
+      change,
+      changePercent,
+      size,
+      sizeKind,
+      volume: getNumber(quote, "regularMarketVolume"),
+      currency: getString(quote, "currency") ?? "USD",
+      exchange: getString(quote, "fullExchangeName") ?? getString(quote, "exchange") ?? "",
+      sector: getString(quote, "sector"),
+      industry: getString(quote, "industry"),
+      marketState: getString(quote, "marketState"),
+      source: "yahoo",
+    });
+  }
+
+  return assets;
+}
+
+export function parseNasdaqMarketHeatmapResponse(data: unknown): MarketHeatmapAsset[] {
+  if (!isRecord(data)) return [];
+  const dataNode = isRecord(data.data) ? data.data : null;
+  const rows = Array.isArray(dataNode?.rows) ? dataNode.rows : [];
+  const assets: MarketHeatmapAsset[] = [];
+
+  for (const row of rows) {
+    if (!isRecord(row)) continue;
+    const symbol = getString(row, "symbol");
+    if (!symbol) continue;
+    const size = parseLooseNumber(row.marketCap);
+    if (size == null || size <= 0) continue;
+    const price = parseLooseNumber(row.lastsale) ?? 0;
+
+    assets.push({
+      symbol,
+      name: getString(row, "name") ?? symbol,
+      price,
+      change: parseLooseNumber(row.netchange) ?? 0,
+      changePercent: parseLooseNumber(row.pctchange) ?? 0,
+      size,
+      sizeKind: "market-cap",
+      volume: parseLooseNumber(row.volume),
+      currency: "USD",
+      exchange: getString(row, "exchange") ?? "",
+      sector: getString(row, "sector"),
+      industry: getString(row, "industry"),
+      marketState: null,
+      source: "nasdaq",
+    });
+  }
+
+  return assets.sort((left, right) => (right.size ?? 0) - (left.size ?? 0));
+}
+
+async function fetchYahooMarketHeatmap(
+  universe: MarketHeatmapUniverseId,
+  count: number,
+  client: YahooMarketHeatmapClient,
+): Promise<MarketHeatmapAsset[]> {
+  const data = await client.postJsonWithCrumb<unknown>(YAHOO_SCREENER_URL, buildYahooScreenerBody(universe, count));
+  return parseYahooMarketHeatmapResponse(data, universe);
+}
+
+async function fetchNasdaqMarketHeatmap(count: number, transport: MarketHeatmapFetchTransport): Promise<MarketHeatmapAsset[]> {
+  const url = new URL(NASDAQ_SCREENER_URL);
+  url.searchParams.set("tableonly", "true");
+  url.searchParams.set("limit", "10000");
+  url.searchParams.set("offset", "0");
+  url.searchParams.set("download", "true");
+
+  const response = await transport(url.toString(), {
+    headers: NASDAQ_HEADERS,
+    signal: AbortSignal.timeout(20_000),
+  });
+  if (!response.ok) {
+    throw new Error(`[${response.status}] Nasdaq screener unavailable`);
+  }
+
+  const data = await response.json();
+  return parseNasdaqMarketHeatmapResponse(data).slice(0, count);
+}
+
+async function loadMarketHeatmap(
+  universe: MarketHeatmapUniverseId,
+  count: number,
+  sources?: MarketHeatmapSources,
+): Promise<MarketHeatmapResult> {
+  const yahooClient = sources?.yahooClient ?? defaultYahooClient;
+  const nasdaqFetch = sources?.nasdaqFetch ?? httpFetch;
+  let yahooError: unknown;
+
+  try {
+    const assets = await fetchYahooMarketHeatmap(universe, count, yahooClient);
+    if (assets.length > 0) {
+      return { universe, source: "yahoo", fetchedAt: Date.now(), assets: assets.slice(0, count) };
+    }
+  } catch (error) {
+    yahooError = error;
+  }
+
+  if (universe === "us-equity") {
+    const assets = await fetchNasdaqMarketHeatmap(count, nasdaqFetch);
+    return { universe, source: "nasdaq", fetchedAt: Date.now(), assets };
+  }
+
+  throw yahooError instanceof Error
+    ? yahooError
+    : new Error("Market heatmap unavailable");
+}
+
+export async function fetchMarketHeatmap(
+  universe: MarketHeatmapUniverseId,
+  options?: MarketHeatmapFetchOptions,
+  sources?: MarketHeatmapSources,
+): Promise<MarketHeatmapResult> {
+  const count = Math.max(1, Math.min(160, Math.round(options?.count ?? DEFAULT_COUNT)));
+  const cacheKey = `${universe}:${count}`;
+  const useCache = options?.cache !== false && !sources?.yahooClient && !sources?.nasdaqFetch;
+  const now = Date.now();
+  const cached = memoryCache.get(cacheKey);
+  if (useCache && !options?.forceRefresh && cached && cached.expiresAt > now) {
+    return cached.result;
+  }
+
+  if (useCache) {
+    const active = activeFetches.get(cacheKey);
+    if (active) return active;
+  }
+
+  const fetchPromise = loadMarketHeatmap(universe, count, sources)
+    .then((result) => {
+      if (useCache) {
+        memoryCache.set(cacheKey, { result, expiresAt: Date.now() + CACHE_TTL_MS });
+      }
+      return result;
+    })
+    .finally(() => {
+      if (activeFetches.get(cacheKey) === fetchPromise) {
+        activeFetches.delete(cacheKey);
+      }
+    });
+
+  if (useCache) activeFetches.set(cacheKey, fetchPromise);
+  return fetchPromise;
+}
+
+export function resetMarketHeatmapCache(): void {
+  activeFetches.clear();
+  memoryCache.clear();
+}

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

@@ -0,0 +1,320 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, useUiCapabilities } from "../../../ui";
+import {
+  buildMetricTreemapNavigationTiles,
+  findMetricTreemapNeighbor,
+  MetricTreemapSurface,
+  Tabs,
+  usePaneFooter,
+  type MetricTreemapDirection,
+  type MetricTreemapItem,
+} from "../../../components";
+import { useShortcut } from "../../../react/input";
+import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
+import type { GloomPlugin, PaneProps } from "../../../types/plugin";
+import { priceColor } from "../../../theme/colors";
+import { formatCompact, formatCurrency, formatPercentRaw } from "../../../utils/format";
+import { isPlainKey } from "../../../utils/keyboard";
+import { usePluginPaneState, usePluginTickerActions } from "../../runtime";
+import {
+  MARKET_HEATMAP_UNIVERSES,
+  fetchMarketHeatmap,
+  resetMarketHeatmapCache,
+  type MarketHeatmapAsset,
+  type MarketHeatmapUniverseId,
+} from "./data";
+
+function formatMoneyCompact(value: number | null | undefined, currency: string): string {
+  if (value == null) return "—";
+  if (currency.toUpperCase() === "USD") return `$${formatCompact(value)}`;
+  return `${formatCompact(value)} ${currency}`;
+}
+
+function sizeLabel(asset: MarketHeatmapAsset): string {
+  const label = asset.sizeKind === "net-assets" ? "Assets" : "Mkt";
+  return `${label} ${formatMoneyCompact(asset.size, asset.currency)}`;
+}
+
+function updatedLabel(timestamp: number | null): string | null {
+  if (!timestamp) return null;
+  return new Date(timestamp).toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+function buildItems(assets: MarketHeatmapAsset[]): Array<MetricTreemapItem<MarketHeatmapAsset>> {
+  return assets.map((asset) => ({
+    id: asset.symbol,
+    label: asset.symbol,
+    weight: asset.size ?? 0,
+    colorValue: asset.changePercent,
+    primaryText: formatPercentRaw(asset.changePercent),
+    secondaryText: sizeLabel(asset),
+    tertiaryText: asset.volume != null ? `Vol ${formatCompact(asset.volume)}` : asset.exchange || null,
+    data: asset,
+  }));
+}
+
+function MarketHeatmapPane({ focused, width, height }: PaneProps) {
+  const { pinTicker } = usePluginTickerActions();
+  const { cellWidthPx = 8, cellHeightPx = 18, nativePaneChrome } = useUiCapabilities();
+  const [activeUniverse, setActiveUniverse] = usePluginPaneState<MarketHeatmapUniverseId>("universe", "us-equity");
+  const [assets, setAssets] = useState<MarketHeatmapAsset[]>([]);
+  const [lastUpdated, setLastUpdated] = useState<number | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const [selectedSymbol, setSelectedSymbol] = useState<string | null>(null);
+  const fetchGenRef = useRef(0);
+
+  const chartHeight = Math.max(1, height - 1);
+  const chartWidth = Math.max(1, width - 2);
+  const cellAspect = Math.max(0.5, Math.min(4, cellHeightPx / Math.max(1, cellWidthPx)));
+  const items = useMemo(() => buildItems(assets), [assets]);
+  const navigationTiles = useMemo(
+    () => buildMetricTreemapNavigationTiles(items, chartWidth, chartHeight, cellAspect, nativePaneChrome ? "float" : "integer"),
+    [cellAspect, chartHeight, chartWidth, items, nativePaneChrome],
+  );
+  const selectedIdx = selectedSymbol
+    ? assets.findIndex((asset) => asset.symbol === selectedSymbol)
+    : -1;
+  const activeIdx = selectedIdx >= 0 ? selectedIdx : (assets.length > 0 ? 0 : -1);
+  const selectedAsset = activeIdx >= 0 ? assets[activeIdx] ?? null : null;
+
+  const loadUniverse = useCallback(async (universe: MarketHeatmapUniverseId, options?: { forceRefresh?: boolean }) => {
+    fetchGenRef.current += 1;
+    const gen = fetchGenRef.current;
+    setLoading(true);
+    setLoadError(null);
+
+    try {
+      const result = await fetchMarketHeatmap(universe, {
+        count: 96,
+        forceRefresh: options?.forceRefresh,
+      });
+      if (fetchGenRef.current !== gen) return;
+      setAssets(result.assets);
+      setLastUpdated(result.fetchedAt);
+      setSelectedSymbol(result.assets[0]?.symbol ?? null);
+    } catch (error) {
+      if (fetchGenRef.current !== gen) return;
+      setAssets([]);
+      setLastUpdated(null);
+      setSelectedSymbol(null);
+      setLoadError(error instanceof Error ? error.message : "Market heatmap unavailable");
+    } finally {
+      if (fetchGenRef.current === gen) setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadUniverse(activeUniverse);
+  }, [activeUniverse, loadUniverse]);
+
+  useEffect(() => {
+    if (selectedSymbol && assets.some((asset) => asset.symbol === selectedSymbol)) return;
+    setSelectedSymbol(assets[0]?.symbol ?? null);
+  }, [assets, selectedSymbol]);
+
+  const refresh = useCallback(() => {
+    void loadUniverse(activeUniverse, { forceRefresh: true });
+  }, [activeUniverse, loadUniverse]);
+
+  const selectAdjacentUniverse = useCallback((direction: -1 | 1) => {
+    const index = MARKET_HEATMAP_UNIVERSES.findIndex((universe) => universe.id === activeUniverse);
+    const nextUniverse = MARKET_HEATMAP_UNIVERSES[Math.max(0, Math.min(MARKET_HEATMAP_UNIVERSES.length - 1, index + direction))];
+    if (nextUniverse && nextUniverse.id !== activeUniverse) {
+      setActiveUniverse(nextUniverse.id);
+      setSelectedSymbol(null);
+    }
+  }, [activeUniverse, setActiveUniverse]);
+
+  const selectUniverseAt = useCallback((index: number) => {
+    const universe = MARKET_HEATMAP_UNIVERSES[index];
+    if (!universe || universe.id === activeUniverse) return;
+    setActiveUniverse(universe.id);
+    setSelectedSymbol(null);
+  }, [activeUniverse, setActiveUniverse]);
+
+  const openSymbol = useCallback((symbol: string) => {
+    pinTicker(symbol, { floating: true, paneType: TICKER_RESEARCH_PANE_ID });
+  }, [pinTicker]);
+
+  const selectIndex = useCallback((index: number) => {
+    const asset = assets[index];
+    if (asset) setSelectedSymbol(asset.symbol);
+  }, [assets]);
+
+  const selectNeighbor = useCallback((direction: MetricTreemapDirection) => {
+    const target = findMetricTreemapNeighbor(navigationTiles, selectedSymbol, direction);
+    if (target) setSelectedSymbol(target.item.data.symbol);
+  }, [navigationTiles, selectedSymbol]);
+
+  useShortcut((event) => {
+    if (!focused) return;
+    if (isPlainKey(event, "r")) {
+      event.preventDefault();
+      event.stopPropagation();
+      refresh();
+      return;
+    }
+    if (isPlainKey(event, "1")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectUniverseAt(0);
+      return;
+    }
+    if (isPlainKey(event, "2")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectUniverseAt(1);
+      return;
+    }
+    if (isPlainKey(event, "[")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectAdjacentUniverse(-1);
+      return;
+    }
+    if (isPlainKey(event, "]")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectAdjacentUniverse(1);
+      return;
+    }
+    if (isPlainKey(event, "j")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectIndex(Math.min((activeIdx >= 0 ? activeIdx : 0) + 1, assets.length - 1));
+      return;
+    }
+    if (isPlainKey(event, "k")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectIndex(Math.max((activeIdx >= 0 ? activeIdx : 0) - 1, 0));
+      return;
+    }
+    if (isPlainKey(event, "left", "h")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectNeighbor("left");
+      return;
+    }
+    if (isPlainKey(event, "right", "l")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectNeighbor("right");
+      return;
+    }
+    if (isPlainKey(event, "up")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectNeighbor("up");
+      return;
+    }
+    if (isPlainKey(event, "down")) {
+      event.preventDefault();
+      event.stopPropagation();
+      selectNeighbor("down");
+      return;
+    }
+    if (isPlainKey(event, "enter", "return") && selectedAsset) {
+      event.preventDefault();
+      event.stopPropagation();
+      openSymbol(selectedAsset.symbol);
+    }
+  });
+
+  usePaneFooter("market-heatmap", () => {
+    const updated = updatedLabel(lastUpdated);
+    return {
+      info: [
+        ...(selectedAsset ? [{
+          id: "selected",
+          parts: [
+            { text: selectedAsset.symbol, tone: "label" as const },
+            { text: formatCurrency(selectedAsset.price, selectedAsset.currency), tone: "value" as const },
+            { text: formatPercentRaw(selectedAsset.changePercent), tone: "value" as const, color: priceColor(selectedAsset.changePercent), bold: true },
+          ],
+        }] : []),
+        ...(updated ? [{
+          id: "updated",
+          parts: [
+            { text: "updated", tone: "label" as const },
+            { text: updated, tone: "value" as const },
+          ],
+        }] : []),
+        ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
+        ...(loadError ? [{ id: "error", parts: [{ text: "error", tone: "muted" as const }] }] : []),
+      ],
+    };
+  }, [lastUpdated, loadError, loading, selectedAsset]);
+
+  const emptyStateTitle = loading
+    ? "Loading market heatmap..."
+    : loadError ?? "No market heatmap data";
+
+  return (
+    <Box flexDirection="column" width={width} height={height}>
+      <Box height={1} paddingX={1}>
+        <Tabs
+          tabs={MARKET_HEATMAP_UNIVERSES.map((universe) => ({ label: universe.label, value: universe.id }))}
+          activeValue={activeUniverse}
+          onSelect={(value) => {
+            setActiveUniverse(value as MarketHeatmapUniverseId);
+            setSelectedSymbol(null);
+          }}
+          compact
+          variant="bare"
+          focused={focused}
+          keyboardNavigation={false}
+        />
+      </Box>
+
+      <MetricTreemapSurface
+        items={items}
+        width={width}
+        height={chartHeight}
+        selectedId={selectedSymbol}
+        onSelect={(item) => setSelectedSymbol(item.data.symbol)}
+        onActivate={(item) => openSymbol(item.data.symbol)}
+        emptyStateTitle={emptyStateTitle}
+      />
+    </Box>
+  );
+}
+
+export const marketHeatmapPlugin: GloomPlugin = {
+  id: "market-heatmap",
+  name: "Market Heatmap",
+  version: "1.0.0",
+  description: "Public market heatmap for the largest US stocks and ETFs.",
+  toggleable: true,
+
+  dispose() {
+    resetMarketHeatmapCache();
+  },
+
+  panes: [
+    {
+      id: "market-heatmap",
+      name: "Market Heatmap",
+      icon: "H",
+      component: MarketHeatmapPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 110, height: 36 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "market-heatmap-pane",
+      paneId: "market-heatmap",
+      label: "Market Heatmap",
+      description: "Largest US stocks and ETFs, sized by market cap or assets and colored by daily move.",
+      keywords: ["heatmap", "market", "largest", "top", "stocks", "etf", "screener"],
+      shortcut: { prefix: "HM" },
+    },
+  ],
+};

package/src/plugins/builtin/plugin-groups.ts

@@ -7,6 +7,7 @@ import { fxMatrixPlugin } from "./fx-matrix";
 import { fearGreedPlugin } from "./fear-greed";
 import { holdersPlugin } from "./holders";
 import { insiderPlugin } from "./insider";
+import { marketHeatmapPlugin } from "./market-heatmap";
 import { marketMoversPlugin } from "./market-movers";
 import { optionsPlugin } from "./options";
 import { researchPlugin } from "./research";
@@ -91,6 +92,7 @@ export const marketOverviewPlugin = createPluginGroup({
     comparisonChartPlugin,
     correlationPlugin,
     worldIndicesPlugin,
+    marketHeatmapPlugin,
     marketMoversPlugin,
     fearGreedPlugin,
     sectorsPlugin,