gloomberb 0.9.7 → 0.9.9

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph/model.ts

@@ -1,6 +1,6 @@
 import type { BarChartSeries } from "../../../../../components/chart/bar-chart-renderer";
 import { colors } from "../../../../../theme/colors";
-import type { FinancialStatement, TickerFinancials } from "../../../../../types/financials";
+import type { FinancialStatement, PricePoint, TickerFinancials } from "../../../../../types/financials";
 import { formatCompact, formatNumber, formatPercent } from "../../../../../utils/format";
 import type {
   FundamentalColumn,
@@ -13,13 +13,62 @@ import type {
   ValuationMetricKey,
 } from "./types";
 
+function finiteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function financialRatio(
+  numerator: number | null | undefined,
+  denominator: number | null | undefined,
+): number | null {
+  return finiteNumber(numerator) && finiteNumber(denominator) && denominator !== 0
+    ? numerator / denominator
+    : null;
+}
+
+function freeCashFlowValue(statement: FinancialStatement): number | null {
+  if (finiteNumber(statement.freeCashFlow)) return statement.freeCashFlow;
+  if (finiteNumber(statement.operatingCashFlow) && finiteNumber(statement.capitalExpenditure)) {
+    return statement.operatingCashFlow + statement.capitalExpenditure;
+  }
+  return null;
+}
+
+function formatMargin(value: number): string {
+  return `${formatNumber(value * 100, 1)}%`;
+}
+
 const FUNDAMENTAL_METRICS: ReadonlyArray<MetricDefinition<FundamentalMetricKey>> = [
   { key: "totalRevenue", label: "Revenue", format: formatCompact },
   { key: "grossProfit", label: "Gross Profit", format: formatCompact },
+  {
+    key: "grossMargin",
+    label: "Gross Margin",
+    format: formatMargin,
+    value: (statement) => financialRatio(statement.grossProfit, statement.totalRevenue),
+  },
   { key: "operatingIncome", label: "Operating Income", format: formatCompact },
+  {
+    key: "operatingMargin",
+    label: "Operating Margin",
+    format: formatMargin,
+    value: (statement) => financialRatio(statement.operatingIncome, statement.totalRevenue),
+  },
   { key: "netIncome", label: "Net Income", format: formatCompact },
+  {
+    key: "netMargin",
+    label: "Net Margin",
+    format: formatMargin,
+    value: (statement) => financialRatio(statement.netIncome, statement.totalRevenue),
+  },
   { key: "operatingCashFlow", label: "Operating Cash Flow", format: formatCompact },
-  { key: "freeCashFlow", label: "Free Cash Flow", format: formatCompact },
+  { key: "freeCashFlow", label: "Free Cash Flow", format: formatCompact, value: freeCashFlowValue },
+  {
+    key: "freeCashFlowMargin",
+    label: "FCF Margin",
+    format: formatMargin,
+    value: (statement) => financialRatio(freeCashFlowValue(statement), statement.totalRevenue),
+  },
   { key: "totalAssets", label: "Total Assets", format: formatCompact },
   { key: "totalDebt", label: "Total Debt", format: formatCompact },
   { key: "totalEquity", label: "Equity", format: formatCompact },
@@ -52,52 +101,221 @@ export function formatMaybePercent(value: number | null): string {
 }
 
 function selectedStatements(financials: TickerFinancials | null, period: FundamentalPeriod): FinancialStatement[] {
-  return period === "annual"
-    ? financials?.annualStatements ?? []
-    : financials?.quarterlyStatements ?? [];
+  if (period === "annual") return financials?.annualStatements ?? [];
+  return deriveQuarterlyStatements(financials?.quarterlyStatements ?? [], financials?.annualStatements ?? []);
 }
 
 function periodCategory(date: string, period: FundamentalPeriod): string {
-  const year = date.slice(0, 4);
-  if (period === "annual") return `FY${year}`;
-  const month = Number(date.slice(5, 7));
+  const parsedYear = Number(date.slice(0, 4));
+  let year = Number.isFinite(parsedYear) ? parsedYear : 0;
+  if (period === "annual") return year > 0 ? `FY${year}` : date;
+  let month = Number(date.slice(5, 7));
+  const day = Number(date.slice(8, 10));
+  if (Number.isFinite(month) && Number.isFinite(day) && day <= 7 && (month - 1) % 3 === 0) {
+    month -= 1;
+    if (month === 0) {
+      month = 12;
+      year -= 1;
+    }
+  }
   const quarter = Number.isFinite(month) && month > 0 ? Math.ceil(month / 3) : 0;
-  return quarter > 0 ? `${year} Q${quarter}` : date;
+  return quarter > 0 && year > 0 ? `${year} Q${quarter}` : date;
 }
 
-export function buildFundamentalGraphRows(
-  statements: FinancialStatement[],
-  metric: FundamentalMetricKey,
-  symbol = "",
-  period: FundamentalPeriod = "annual",
+type NumericStatementField = Exclude<keyof FinancialStatement, "date">;
+
+const QUARTERLY_FLOW_FIELDS: NumericStatementField[] = [
+  "totalRevenue",
+  "grossProfit",
+  "operatingIncome",
+  "netIncome",
+  "ebitda",
+  "operatingCashFlow",
+  "capitalExpenditure",
+  "freeCashFlow",
+  "eps",
+];
+
+const QUARTERLY_SNAPSHOT_FIELDS: NumericStatementField[] = [
+  "totalAssets",
+  "cashAndCashEquivalents",
+  "cashCashEquivalentsAndShortTermInvestments",
+  "totalDebt",
+  "totalEquity",
+  "basicShares",
+  "dilutedShares",
+  "shareIssued",
+  "ordinarySharesNumber",
+];
+
+function statementNumber(statement: FinancialStatement, field: NumericStatementField): number | null {
+  const value = statement[field];
+  return finiteNumber(value) ? value : null;
+}
+
+function setStatementNumber(statement: FinancialStatement, field: NumericStatementField, value: number): void {
+  (statement as Record<NumericStatementField, number | undefined>)[field] = value;
+}
+
+function statementTime(statement: FinancialStatement): number {
+  const time = Date.parse(statement.date);
+  return Number.isFinite(time) ? time : Number.NaN;
+}
+
+function precedingQuarterValues(
+  quarterlyStatements: FinancialStatement[],
+  annualStatement: FinancialStatement,
+  field: NumericStatementField,
+): number[] {
+  const annualTime = statementTime(annualStatement);
+  if (!Number.isFinite(annualTime)) return [];
+
+  const annualCategory = periodCategory(annualStatement.date, "quarterly");
+  const byCategory = new Map<string, { date: string; time: number; value: number }>();
+  for (const statement of quarterlyStatements) {
+    const time = statementTime(statement);
+    if (!Number.isFinite(time) || time >= annualTime || annualTime - time > 370 * 24 * 60 * 60 * 1000) {
+      continue;
+    }
+    const category = periodCategory(statement.date, "quarterly");
+    if (category === annualCategory) continue;
+    const value = statementNumber(statement, field);
+    if (value === null) continue;
+    const previous = byCategory.get(category);
+    if (!previous || statement.date.localeCompare(previous.date) > 0) {
+      byCategory.set(category, { date: statement.date, time, value });
+    }
+  }
+
+  return [...byCategory.values()]
+    .sort((left, right) => right.time - left.time)
+    .slice(0, 3)
+    .sort((left, right) => left.time - right.time)
+    .map((entry) => entry.value);
+}
+
+function mergeStatementsByDate(statements: FinancialStatement[]): FinancialStatement[] {
+  const byDate = new Map<string, FinancialStatement>();
+  for (const statement of statements) {
+    const existing = byDate.get(statement.date);
+    if (!existing) {
+      byDate.set(statement.date, { ...statement });
+      continue;
+    }
+    for (const [key, value] of Object.entries(statement) as Array<[keyof FinancialStatement, unknown]>) {
+      if (key === "date") continue;
+      if (value !== undefined && existing[key] === undefined) {
+        (existing as unknown as Record<string, unknown>)[key] = value;
+      }
+    }
+  }
+  return [...byDate.values()];
+}
+
+function deriveQuarterlyStatements(
+  quarterlyStatements: FinancialStatement[],
+  annualStatements: FinancialStatement[],
+): FinancialStatement[] {
+  const mergedQuarterly = mergeStatementsByDate(quarterlyStatements);
+  const byDate = new Map(mergedQuarterly.map((statement) => [statement.date, { ...statement }]));
+
+  for (const annualStatement of annualStatements) {
+    let target = byDate.get(annualStatement.date);
+    let changed = false;
+    if (!target) {
+      target = { date: annualStatement.date };
+    }
+
+    for (const field of QUARTERLY_FLOW_FIELDS) {
+      if (statementNumber(target, field) !== null) continue;
+      const annualValue = statementNumber(annualStatement, field);
+      if (annualValue === null) continue;
+      const previousValues = precedingQuarterValues(mergedQuarterly, annualStatement, field);
+      if (previousValues.length !== 3) continue;
+      const derived = annualValue - previousValues.reduce((sum, value) => sum + value, 0);
+      if (!Number.isFinite(derived)) continue;
+      setStatementNumber(target, field, derived);
+      changed = true;
+    }
+
+    for (const field of QUARTERLY_SNAPSHOT_FIELDS) {
+      if (statementNumber(target, field) !== null) continue;
+      const annualValue = statementNumber(annualStatement, field);
+      if (annualValue === null) continue;
+      setStatementNumber(target, field, annualValue);
+      changed = true;
+    }
+
+    if (changed) byDate.set(target.date, target);
+  }
+
+  return [...byDate.values()].sort((left, right) => left.date.localeCompare(right.date));
+}
+
+function fundamentalMetricDef(metric: FundamentalMetricKey): MetricDefinition<FundamentalMetricKey> {
+  return FUNDAMENTAL_METRICS.find((definition) => definition.key === metric) ?? FUNDAMENTAL_METRICS[0]!;
+}
+
+function fundamentalMetricValue(statement: FinancialStatement, metric: FundamentalMetricKey): number | null {
+  const definition = fundamentalMetricDef(metric);
+  const value = definition.value
+    ? definition.value(statement)
+    : statement[metric as keyof FinancialStatement];
+  return finiteNumber(value) ? value : null;
+}
+
+interface GraphRowEntry {
+  date: string;
+  category: string;
+  value: number;
+}
+
+function buildRowsFromEntries(
+  entries: GraphRowEntry[],
+  metric: GraphMetricKey,
+  symbol: string,
 ): FundamentalGraphRow[] {
-  const sortedStatements = [...statements]
-    .filter((statement) => typeof statement[metric] === "number")
-    .sort((left, right) => left.date.localeCompare(right.date));
-  const byCategory = new Map<string, FinancialStatement>();
-  for (const statement of sortedStatements) {
-    const category = periodCategory(statement.date, period);
-    const key = `${symbol}\u0000${category}`;
-    const previous = byCategory.get(key);
-    if (!previous || statement.date.localeCompare(previous.date) >= 0) {
-      byCategory.set(key, statement);
+  const byCategory = new Map<string, GraphRowEntry>();
+  for (const entry of [...entries].sort((left, right) => left.date.localeCompare(right.date))) {
+    const previous = byCategory.get(entry.category);
+    if (!previous || entry.date.localeCompare(previous.date) >= 0) {
+      byCategory.set(entry.category, entry);
     }
   }
   const sorted = [...byCategory.values()].sort((left, right) => left.date.localeCompare(right.date));
-  const maxAbs = Math.max(1, ...sorted.map((statement) => Math.abs(statement[metric] as number)));
-  return sorted.map((statement, index) => {
-    const value = statement[metric] as number;
-    const previous = sorted[index - 1]?.[metric];
+  const maxAbs = Math.max(1, ...sorted.map((entry) => Math.abs(entry.value)));
+
+  return sorted.map((entry, index) => {
+    const previous = sorted[index - 1]?.value;
     return {
-      key: [symbol, statement.date, metric].filter(Boolean).join(":"),
+      key: [symbol, entry.date, metric].filter(Boolean).join(":"),
       symbol,
+      date: entry.date,
+      category: entry.category,
+      value: entry.value,
+      growth: typeof previous === "number" && previous !== 0
+        ? (entry.value - previous) / Math.abs(previous)
+        : null,
+      barWidth: Math.max(1, Math.round((Math.abs(entry.value) / maxAbs) * 24)),
+    };
+  });
+}
+
+export function buildFundamentalGraphRows(
+  statements: FinancialStatement[],
+  metric: FundamentalMetricKey,
+  symbol = "",
+  period: FundamentalPeriod = "annual",
+): FundamentalGraphRow[] {
+  const entries = statements
+    .map((statement) => ({ statement, value: fundamentalMetricValue(statement, metric) }))
+    .filter((entry): entry is { statement: FinancialStatement; value: number } => entry.value !== null)
+    .map(({ statement, value }) => ({
       date: statement.date,
       category: periodCategory(statement.date, period),
       value,
-      growth: typeof previous === "number" && previous !== 0 ? (value - previous) / Math.abs(previous) : null,
-      barWidth: Math.max(1, Math.round((Math.abs(value) / maxAbs) * 24)),
-    };
-  });
+    }));
+  return buildRowsFromEntries(entries, metric, symbol);
 }
 
 function resolveMarketCap(financials: TickerFinancials | null): number | null {
@@ -111,21 +329,141 @@ function resolveMarketCap(financials: TickerFinancials | null): number | null {
     : null;
 }
 
-function valuationMetricValue(
+function timeFromDate(value: Date | string): number {
+  return value instanceof Date ? value.getTime() : Date.parse(value);
+}
+
+function priceAtOrBefore(priceHistory: PricePoint[], date: string): number | null {
+  const target = Date.parse(date);
+  if (!Number.isFinite(target)) return null;
+
+  let closest: { time: number; close: number } | null = null;
+  for (const point of priceHistory) {
+    if (!finiteNumber(point.close) || point.close <= 0) continue;
+    const time = timeFromDate(point.date);
+    if (!Number.isFinite(time) || time > target) continue;
+    if (!closest || time > closest.time) {
+      closest = { time, close: point.close };
+    }
+  }
+  return closest?.close ?? null;
+}
+
+function statementShares(statement: FinancialStatement): number | null {
+  const shares = statement.dilutedShares
+    ?? statement.basicShares
+    ?? statement.ordinarySharesNumber
+    ?? statement.shareIssued;
+  return finiteNumber(shares) && shares > 0 ? shares : null;
+}
+
+function statementEpsValue(statement: FinancialStatement): number | null {
+  if (finiteNumber(statement.eps) && statement.eps !== 0) return statement.eps;
+  const shares = statementShares(statement);
+  return finiteNumber(statement.netIncome) && shares ? statement.netIncome / shares : null;
+}
+
+function aggregateEps(statements: FinancialStatement[]): number | null {
+  if (statements.length === 0) return null;
+  const epsValues = statements.map(statementEpsValue);
+  if (epsValues.every((value): value is number => finiteNumber(value))) {
+    return epsValues.reduce((sum, value) => sum + value, 0);
+  }
+
+  const latestShares = statementShares(statements.at(-1)!);
+  const incomeValues = statements.map((statement) => statement.netIncome);
+  if (!latestShares || !incomeValues.every((value): value is number => finiteNumber(value))) {
+    return null;
+  }
+  return incomeValues.reduce((sum, value) => sum + value, 0) / latestShares;
+}
+
+function trailingEpsValue(
+  statements: FinancialStatement[],
+  index: number,
+  period: FundamentalPeriod,
+): number | null {
+  if (period === "annual") return statementEpsValue(statements[index]!);
+  if (index < 3) return null;
+  return aggregateEps(statements.slice(index - 3, index + 1));
+}
+
+function forwardEpsValue(
+  statements: FinancialStatement[],
+  index: number,
+  period: FundamentalPeriod,
+): number | null {
+  if (period === "annual") {
+    const nextStatement = statements[index + 1];
+    return nextStatement ? statementEpsValue(nextStatement) : null;
+  }
+  if (index + 4 >= statements.length) return null;
+  return aggregateEps(statements.slice(index + 1, index + 5));
+}
+
+function historicalMarketCap(
+  financials: TickerFinancials | null,
+  statement: FinancialStatement,
+): number | null {
+  const price = financials ? priceAtOrBefore(financials.priceHistory, statement.date) : null;
+  const shares = statementShares(statement);
+  if (price && shares) return price * shares;
+  return resolveMarketCap(financials);
+}
+
+function historicalEnterpriseValue(
+  financials: TickerFinancials | null,
+  statement: FinancialStatement,
+): number | null {
+  const marketCap = historicalMarketCap(financials, statement);
+  if (!marketCap) return financials?.fundamentals?.enterpriseValue ?? null;
+  const debt = finiteNumber(statement.totalDebt) ? statement.totalDebt : 0;
+  const cash = statement.cashCashEquivalentsAndShortTermInvestments
+    ?? statement.cashAndCashEquivalents
+    ?? 0;
+  return marketCap + debt - (finiteNumber(cash) ? cash : 0);
+}
+
+function currentValuationMetricValue(
   financials: TickerFinancials | null,
   metric: ValuationMetricKey,
-  statement: FinancialStatement | null,
 ): number | null {
   const fundamentals = financials?.fundamentals;
   if (metric === "trailingPE") return fundamentals?.trailingPE ?? null;
   if (metric === "forwardPE") return fundamentals?.forwardPE ?? null;
   if (metric === "pegRatio") return fundamentals?.pegRatio ?? null;
+  return null;
+}
+
+function valuationMetricValue(
+  financials: TickerFinancials | null,
+  metric: ValuationMetricKey,
+  statement: FinancialStatement | null,
+  context?: {
+    statements: FinancialStatement[];
+    statementIndex: number;
+    period: FundamentalPeriod;
+  },
+): number | null {
+  if (metric === "pegRatio" || statement === null) {
+    return currentValuationMetricValue(financials, metric);
+  }
 
-  const marketCap = resolveMarketCap(financials);
-  const enterpriseValue = fundamentals?.enterpriseValue ?? null;
+  if (metric === "trailingPE" || metric === "forwardPE") {
+    const price = financials ? priceAtOrBefore(financials.priceHistory, statement.date) : null;
+    const eps = context
+      ? metric === "trailingPE"
+        ? trailingEpsValue(context.statements, context.statementIndex, context.period)
+        : forwardEpsValue(context.statements, context.statementIndex, context.period)
+      : statementEpsValue(statement);
+    return price && eps && eps > 0 ? price / eps : null;
+  }
+
+  const marketCap = historicalMarketCap(financials, statement);
+  const enterpriseValue = historicalEnterpriseValue(financials, statement);
   const revenue = statement?.totalRevenue;
   const ebitda = statement?.ebitda;
-  const freeCashFlow = statement?.freeCashFlow;
+  const freeCashFlow = statement ? freeCashFlowValue(statement) : null;
 
   if (metric === "priceSales" && marketCap && revenue) return marketCap / revenue;
   if (metric === "evSales" && enterpriseValue && revenue) return enterpriseValue / revenue;
@@ -140,33 +478,32 @@ export function buildValuationGraphRows(
   symbol = "",
   period: FundamentalPeriod = "annual",
 ): FundamentalGraphRow[] {
-  const statementMetrics = new Set<ValuationMetricKey>(["priceSales", "evSales", "evEbitda", "priceFcf"]);
-  const sourceStatements = statementMetrics.has(metric)
-    ? selectedStatements(financials, period)
-    : [{ date: "Current" } as FinancialStatement];
-  const sorted = sourceStatements
-    .map((statement) => ({
-      statement,
-      value: valuationMetricValue(financials, metric, statement.date === "Current" ? null : statement),
+  const sourceStatements = metric === "pegRatio"
+    ? [{ date: "Current" } as FinancialStatement]
+    : selectedStatements(financials, period);
+  const entries = [...sourceStatements]
+    .sort((left, right) => left.date.localeCompare(right.date))
+    .map((statement, statementIndex, statements) => ({
+      date: statement.date,
+      category: statement.date === "Current" ? "Current" : periodCategory(statement.date, period),
+      value: valuationMetricValue(
+        financials,
+        metric,
+        statement.date === "Current" ? null : statement,
+        { statements, statementIndex, period },
+      ),
     }))
-    .filter((entry): entry is { statement: FinancialStatement; value: number } => (
-      typeof entry.value === "number" && Number.isFinite(entry.value)
-    ))
-    .sort((left, right) => left.statement.date.localeCompare(right.statement.date));
-  const maxAbs = Math.max(1, ...sorted.map((entry) => Math.abs(entry.value)));
+    .filter((entry): entry is GraphRowEntry => finiteNumber(entry.value));
+  const currentValue = currentValuationMetricValue(financials, metric);
+  if (finiteNumber(currentValue) && !entries.some((entry) => entry.date === "Current") && (
+    metric === "pegRatio"
+    || metric === "forwardPE"
+    || (metric === "trailingPE" && entries.length === 0)
+  )) {
+    entries.push({ date: "Current", category: "Current", value: currentValue });
+  }
 
-  return sorted.map((entry, index) => {
-    const previous = sorted[index - 1]?.value;
-    return {
-      key: [symbol, entry.statement.date, metric].filter(Boolean).join(":"),
-      symbol,
-      date: entry.statement.date,
-      category: entry.statement.date === "Current" ? "Current" : periodCategory(entry.statement.date, period),
-      value: entry.value,
-      growth: typeof previous === "number" && previous !== 0 ? (entry.value - previous) / Math.abs(previous) : null,
-      barWidth: Math.max(1, Math.round((Math.abs(entry.value) / maxAbs) * 24)),
-    };
-  });
+  return buildRowsFromEntries(entries, metric, symbol);
 }
 
 export function metricDefs(kind: GraphKind): ReadonlyArray<MetricDefinition> {
@@ -242,9 +579,23 @@ export function buildFundamentalColumns(width: number, multiSymbol: boolean): Fu
   return columns;
 }
 
+function categorySortKey(row: FundamentalGraphRow): string {
+  return row.date === "Current" ? "9999-12-31" : row.date;
+}
+
 export function buildGraphBarSeries(rows: FundamentalGraphRow[]): BarChartSeries[] {
   const symbols = [...new Set(rows.map((row) => row.symbol || ""))];
-  const categories = [...new Set(rows.map((row) => row.category))];
+  const categoryOrder = new Map<string, string>();
+  for (const row of rows) {
+    const sortKey = categorySortKey(row);
+    const previous = categoryOrder.get(row.category);
+    if (!previous || sortKey.localeCompare(previous) < 0) {
+      categoryOrder.set(row.category, sortKey);
+    }
+  }
+  const categories = [...categoryOrder.entries()]
+    .sort((left, right) => left[1].localeCompare(right[1]) || left[0].localeCompare(right[0]))
+    .map(([category]) => category);
   return symbols.map((symbol, index) => ({
     id: symbol || "value",
     label: symbol || "Value",

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph/settings.ts

@@ -1,7 +1,9 @@
-import type { PaneTemplateCreateOptions } from "../../../../../types/plugin";
-import { formatTickerListInput, parseTickerListInput } from "../../../../../tickers/list";
+import type { PaneSettingsDef, PaneTemplateCreateOptions } from "../../../../../types/plugin";
+import { formatTickerListInput, MAX_TICKER_LIST_SIZE, parseTickerListInput } from "../../../../../tickers/list";
 import type { GraphKind } from "./types";
 
+export const FUNDAMENTAL_GRAPH_PANE_ID = "fundamental-graph";
+
 export function symbolsFromPaneSettings(settings: Record<string, unknown> | undefined, fallbackSymbol: string | null): string[] {
   const symbols = settings?.symbols;
   if (Array.isArray(symbols)) {
@@ -26,6 +28,10 @@ export function graphKindFromSettings(settings: Record<string, unknown> | undefi
   return settings?.chartKind === "valuation" ? "valuation" : fallback;
 }
 
+export function graphShortcutForKind(kind: GraphKind): "GF" | "GE" {
+  return kind === "valuation" ? "GE" : "GF";
+}
+
 export function graphTemplateSymbols(
   activeTicker: string | null,
   options: Pick<PaneTemplateCreateOptions, "arg" | "values" | "symbols"> | undefined,
@@ -42,3 +48,18 @@ export function graphTemplateSymbols(
 export function graphTemplateTitle(shortcut: "GF" | "GE", symbols: string[]): string {
   return `${shortcut} ${formatTickerListInput(symbols)}`;
 }
+
+export function buildGraphPaneSettingsDef(): PaneSettingsDef {
+  return {
+    title: "Graph Pane Settings",
+    fields: [
+      {
+        key: "symbolsText",
+        label: "Tickers",
+        description: `Enter up to ${MAX_TICKER_LIST_SIZE} tickers separated by commas.`,
+        type: "text",
+        placeholder: "AMD, NVDA",
+      },
+    ],
+  };
+}

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph/types.ts

@@ -1,13 +1,17 @@
 import type { DataTableColumn } from "../../../../../components";
-import type { TickerFinancials } from "../../../../../types/financials";
+import type { FinancialStatement, TickerFinancials } from "../../../../../types/financials";
 
 export type FundamentalMetricKey =
   | "totalRevenue"
   | "grossProfit"
+  | "grossMargin"
   | "operatingIncome"
+  | "operatingMargin"
   | "netIncome"
+  | "netMargin"
   | "operatingCashFlow"
   | "freeCashFlow"
+  | "freeCashFlowMargin"
   | "totalAssets"
   | "totalDebt"
   | "totalEquity"
@@ -42,6 +46,9 @@ export type MetricDefinition<Key extends GraphMetricKey = GraphMetricKey> = {
   key: Key;
   label: string;
   format: (value: number) => string;
+  value?: Key extends FundamentalMetricKey
+    ? (statement: FinancialStatement) => number | null | undefined
+    : never;
 };
 
 export type SymbolFinancials = {

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph.tsx

@@ -12,6 +12,7 @@ import {
   isMetricForKind,
 } from "./fundamental-graph/model";
 import {
+  FUNDAMENTAL_GRAPH_PANE_ID,
   graphKindFromSettings,
   graphTemplateSymbols,
   graphTemplateTitle,
@@ -20,6 +21,7 @@ import {
 import type { FundamentalPeriod, GraphKind, GraphMetricKey } from "./fundamental-graph/types";
 
 export { buildFundamentalGraphRows, buildValuationGraphRows } from "./fundamental-graph/model";
+export { buildGraphPaneSettingsDef, FUNDAMENTAL_GRAPH_PANE_ID } from "./fundamental-graph/settings";
 
 export function FundamentalGraphPane({ focused, width, height }: PaneProps) {
   const pane = usePaneInstance();
@@ -99,7 +101,7 @@ export function createGraphPaneTemplate({
 }): PaneTemplateDef {
   return {
     id,
-    paneId: "fundamental-graph",
+    paneId: FUNDAMENTAL_GRAPH_PANE_ID,
     label,
     description,
     keywords: chartKind === "valuation"