gloomberb 0.9.3 → 0.9.4

package/src/renderers/electrobun/view/host/input.tsx

@@ -2,12 +2,14 @@
 /** @jsxImportSource react */
 import {
   forwardRef,
+  useCallback,
   useEffect,
   useImperativeHandle,
   useRef,
   useState,
   type CSSProperties,
   type KeyboardEvent,
+  type RefObject,
 } from "react";
 import type { InputRenderable, TextareaRenderable } from "../../../../ui/host";
 import { WEB_CELL_HEIGHT, WEB_CELL_WIDTH } from "../input-host";
@@ -79,6 +81,65 @@ function useEditableValue(props: Record<string, unknown>) {
   return { value, valueRef, setValue };
 }
 
+function useLatestRef<T>(value: T): RefObject<T> {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+function useSyncedEditableElement<T extends HTMLInputElement | HTMLTextAreaElement>({
+  elementRef,
+  propsRef,
+  valueRef,
+  handleValueChange,
+  active,
+}: {
+  elementRef: RefObject<T | null>;
+  propsRef: RefObject<Record<string, unknown>>;
+  valueRef: RefObject<string>;
+  handleValueChange: (nextValue: string) => void;
+  active: boolean;
+}): () => string {
+  const syncElementValue = useCallback(() => {
+    const nextValue = elementRef.current?.value;
+    if (typeof nextValue !== "string") return valueRef.current;
+    if (nextValue !== valueRef.current) {
+      handleValueChange(nextValue);
+    }
+    return nextValue;
+  }, [elementRef, handleValueChange, valueRef]);
+
+  useEffect(() => {
+    if (!active) return;
+    let animationFrame: number | null = null;
+    const syncDomValue = () => {
+      syncElementValue();
+      animationFrame = globalThis.requestAnimationFrame?.(syncDomValue) ?? null;
+    };
+    animationFrame = globalThis.requestAnimationFrame?.(syncDomValue) ?? null;
+    return () => {
+      if (animationFrame !== null) globalThis.cancelAnimationFrame?.(animationFrame);
+    };
+  }, [active, syncElementValue]);
+
+  useEffect(() => {
+    if (!active) return;
+    const commitBeforeOutsideMouseDown = (event: globalThis.MouseEvent) => {
+      const element = elementRef.current;
+      const target = event.target;
+      if (!element || (target instanceof Node && element.contains(target))) return;
+      const nextValue = syncElementValue();
+      callTextHandler(propsRef.current.onBlur, nextValue);
+    };
+    document.addEventListener("mousedown", commitBeforeOutsideMouseDown, true);
+    return () => {
+      document.removeEventListener("mousedown", commitBeforeOutsideMouseDown, true);
+    };
+  }, [active, elementRef, propsRef, syncElementValue]);
+
+  return syncElementValue;
+}
+
 type WebVisualCursor = TextareaRenderable["visualCursor"];
 
 function textareaColumnCount(props: Record<string, unknown>, element: HTMLTextAreaElement | null): number {
@@ -149,8 +210,10 @@ function textareaMetrics(
 
 export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(function WebInput(props, ref) {
   const elementRef = useRef<HTMLInputElement | null>(null);
+  const propsRef = useLatestRef(props);
   const { value, valueRef, setValue } = useEditableValue(props);
   const [cursorOffset, setCursorOffset] = useState(value.length);
+  const [domFocused, setDomFocused] = useState(false);
   const applyCursorOffset = (offset: number) => {
     setCursorOffset(offset);
     queueMicrotask(() => applyDomCursorOffset(elementRef.current, offset));
@@ -165,7 +228,7 @@ export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(fun
 
   useImperativeHandle(ref, () => ({
     editBuffer: {
-      getText: () => valueRef.current,
+      getText: () => elementRef.current?.value ?? valueRef.current,
       setText: (nextText: string) => setValue(nextText),
     },
     get cursorOffset() {
@@ -175,18 +238,25 @@ export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(fun
     focus: () => elementRef.current?.focus(),
   }), [applyCursorOffset, cursorOffset, setValue, valueRef]);
 
-  const handleValueChange = (nextValue: string) => {
+  const handleValueChange = useCallback((nextValue: string) => {
     setValue(nextValue);
     setCursorOffset(elementRef.current?.selectionStart ?? nextValue.length);
-    callTextHandler(props.onInput, nextValue);
-    callTextHandler(props.onChange, nextValue);
-    callTextHandler(props.onCursorChange, nextValue);
-  };
+    callTextHandler(propsRef.current.onInput, nextValue);
+    callTextHandler(propsRef.current.onChange, nextValue);
+    callTextHandler(propsRef.current.onCursorChange, nextValue);
+  }, [propsRef, setValue]);
+  const syncElementValue = useSyncedEditableElement({
+    elementRef,
+    propsRef,
+    valueRef,
+    handleValueChange,
+    active: props.focused === true || domFocused,
+  });
 
   const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
-    if (event.key === "Enter" && typeof props.onSubmit === "function") {
+    if (event.key === "Enter" && typeof propsRef.current.onSubmit === "function") {
       event.preventDefault();
-      (props.onSubmit as (value: string) => void)(valueRef.current);
+      (propsRef.current.onSubmit as (value: string) => void)(syncElementValue());
     }
   };
 
@@ -200,7 +270,16 @@ export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(fun
       autoComplete="off"
       spellCheck={false}
       placeholder={getStringProp(props, "placeholder")}
+      onInput={(event) => handleValueChange(event.currentTarget.value)}
       onChange={(event) => handleValueChange(event.currentTarget.value)}
+      onFocus={() => {
+        setDomFocused(true);
+        callTextHandler(propsRef.current.onFocus, elementRef.current?.value ?? valueRef.current);
+      }}
+      onBlur={() => {
+        setDomFocused(false);
+        callTextHandler(propsRef.current.onBlur, syncElementValue());
+      }}
       onKeyDown={handleKeyDown}
       onContextMenu={(event) => {
         if (!NATIVE_CONTEXT_MENU_SUPPORTED) return;
@@ -211,7 +290,7 @@ export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(fun
       }}
       onSelect={() => {
         setCursorOffset(elementRef.current?.selectionStart ?? valueRef.current.length);
-        callTextHandler(props.onCursorChange, valueRef.current);
+        callTextHandler(propsRef.current.onCursorChange, valueRef.current);
       }}
       style={textInputStyle(props, false)}
     />
@@ -220,8 +299,10 @@ export const WebInput = forwardRef<InputRenderable, Record<string, unknown>>(fun
 
 export const WebTextarea = forwardRef<TextareaRenderable, Record<string, unknown>>(function WebTextarea(props, ref) {
   const elementRef = useRef<HTMLTextAreaElement | null>(null);
+  const propsRef = useLatestRef(props);
   const { value, valueRef, setValue } = useEditableValue(props);
   const [cursorOffset, setCursorOffset] = useState(value.length);
+  const [domFocused, setDomFocused] = useState(false);
   const applyCursorOffset = (offset: number) => {
     setCursorOffset(offset);
     queueMicrotask(() => applyDomCursorOffset(elementRef.current, offset));
@@ -236,7 +317,7 @@ export const WebTextarea = forwardRef<TextareaRenderable, Record<string, unknown
 
   useImperativeHandle(ref, () => ({
     editBuffer: {
-      getText: () => valueRef.current,
+      getText: () => elementRef.current?.value ?? valueRef.current,
       setText: (nextText: string) => setValue(nextText),
     },
     get cursorOffset() {
@@ -271,18 +352,25 @@ export const WebTextarea = forwardRef<TextareaRenderable, Record<string, unknown
     clearLineHighlights: () => {},
   }), [applyCursorOffset, cursorOffset, props, setValue, valueRef]);
 
-  const handleValueChange = (nextValue: string) => {
+  const handleValueChange = useCallback((nextValue: string) => {
     setValue(nextValue);
     setCursorOffset(elementRef.current?.selectionStart ?? nextValue.length);
-    callTextHandler(props.onInput, nextValue);
-    callTextHandler(props.onChange, nextValue);
-    callTextHandler(props.onCursorChange, nextValue);
-  };
+    callTextHandler(propsRef.current.onInput, nextValue);
+    callTextHandler(propsRef.current.onChange, nextValue);
+    callTextHandler(propsRef.current.onCursorChange, nextValue);
+  }, [propsRef, setValue]);
+  const syncElementValue = useSyncedEditableElement({
+    elementRef,
+    propsRef,
+    valueRef,
+    handleValueChange,
+    active: props.focused === true || domFocused,
+  });
 
   const handleKeyDown = (event: KeyboardEvent<HTMLTextAreaElement>) => {
-    if (event.key === "Enter" && !event.shiftKey && typeof props.onSubmit === "function") {
+    if (event.key === "Enter" && !event.shiftKey && typeof propsRef.current.onSubmit === "function") {
       event.preventDefault();
-      (props.onSubmit as (value: string) => void)(valueRef.current);
+      (propsRef.current.onSubmit as (value: string) => void)(syncElementValue());
     }
   };
 
@@ -296,7 +384,16 @@ export const WebTextarea = forwardRef<TextareaRenderable, Record<string, unknown
       autoComplete="off"
       spellCheck={false}
       placeholder={getStringProp(props, "placeholder")}
+      onInput={(event) => handleValueChange(event.currentTarget.value)}
       onChange={(event) => handleValueChange(event.currentTarget.value)}
+      onFocus={() => {
+        setDomFocused(true);
+        callTextHandler(propsRef.current.onFocus, elementRef.current?.value ?? valueRef.current);
+      }}
+      onBlur={() => {
+        setDomFocused(false);
+        callTextHandler(propsRef.current.onBlur, syncElementValue());
+      }}
       onKeyDown={handleKeyDown}
       onContextMenu={(event) => {
         if (!NATIVE_CONTEXT_MENU_SUPPORTED) return;
@@ -307,7 +404,7 @@ export const WebTextarea = forwardRef<TextareaRenderable, Record<string, unknown
       }}
       onSelect={() => {
         setCursorOffset(elementRef.current?.selectionStart ?? valueRef.current.length);
-        callTextHandler(props.onCursorChange, valueRef.current);
+        callTextHandler(propsRef.current.onCursorChange, valueRef.current);
       }}
       style={textInputStyle(props, true)}
     />

package/src/renderers/electrobun/view/host/tabs.tsx

@@ -21,6 +21,7 @@ export function WebTabs({
   closeMode = "always",
   addLabel = "+",
   onAdd,
+  focused = false,
   palette,
 }: HostTabsProps) {
   const activeTabRef = useRef<HTMLButtonElement | null>(null);
@@ -112,16 +113,20 @@ export function WebTabs({
           paddingBlock: 0,
           paddingBottom: showUnderline ? 2 : 0,
           margin: 0,
-          border: 0,
+          border: "1px solid transparent",
           borderRadius: variant === "underline" ? 5 : 6,
           background: resolveTabBackground(active, hovered),
+          boxSizing: "border-box",
           font: "inherit",
           fontSize: tabFontSize,
           fontWeight: active ? 700 : 500,
           lineHeight: 1,
           textAlign: "center",
           whiteSpace: "nowrap",
-          transition: "background-color 110ms ease, color 110ms ease, box-shadow 110ms ease",
+          borderColor: active && focused && variant !== "pill"
+            ? `color-mix(in srgb, ${palette.activeUnderline} 35%, transparent)`
+            : "transparent",
+          transition: "background-color 110ms ease, border-color 110ms ease, color 110ms ease",
           cursor: disabled ? "default" : "pointer",
         } satisfies CssVars;
 

package/src/renderers/electrobun/view/styles.css

@@ -170,6 +170,17 @@ body.gloom-dragging {
 [data-gloom-role="status-bar"] span {
   line-height: var(--cell-h);
 }
+[data-gloom-role="pane-body"] {
+  overflow: hidden;
+}
+[data-gloom-role="pane-content"] {
+  overflow: hidden;
+}
+[data-gloom-role="pane-content"] > * {
+  min-width: 0;
+  min-height: 0;
+  max-height: 100%;
+}
 [data-gloom-role="pane-footer"] {
   flex: 0 0 var(--cell-h);
   height: var(--cell-h);

package/src/renderers/opentui/host.tsx

@@ -138,8 +138,14 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
     get isDestroyed() {
       return renderer.isDestroyed;
     },
+    get currentFocusedRenderable() {
+      return renderer.currentFocusedRenderable ?? null;
+    },
+    get currentFocusedEditor() {
+      return renderer.currentFocusedEditor ?? null;
+    },
     get keyInput() {
-      return renderer.keyInput;
+      return renderer.keyInput as unknown as NativeRendererHost["keyInput"];
     },
     on: (event, handler) => renderer.on(event, handler),
     off: (event, handler) => renderer.off(event, handler),
@@ -147,7 +153,17 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
     registerLifecyclePass: (renderable) => renderer.registerLifecyclePass(renderable as any),
     unregisterLifecyclePass: (renderable) => renderer.unregisterLifecyclePass(renderable as any),
     getSelection: () => renderer.getSelection(),
+    getCursorState: () => renderer.getCursorState(),
+    setCursorPosition: (x, y, visible = true) => renderer.setCursorPosition(x, y, visible),
+    addPostProcessFn: (processFn) => renderer.addPostProcessFn(processFn as any),
+    removePostProcessFn: (processFn) => renderer.removePostProcessFn(processFn as any),
     copyToClipboardOSC52: (text) => renderer.copyToClipboardOSC52(text),
+    captureMouseRenderable(renderable) {
+      const capture = (renderer as unknown as { setCapturedRenderable?: (target: unknown) => void }).setCapturedRenderable;
+      if (typeof capture === "function") {
+        capture.call(renderer, renderable);
+      }
+    },
     write(data) {
       if (renderer.isDestroyed) return false;
       const writer = (renderer as unknown as { writeOut?: (payload: string | Uint8Array) => void }).writeOut;

package/src/renderers/opentui/ui-host.tsx

@@ -1,11 +1,25 @@
 import { RGBA, StyledText as OpenTuiStyledText, SyntaxStyle, TextAttributes as OpenTuiTextAttributes } from "@opentui/core";
-import { createElement } from "react";
+import { createElement, forwardRef, type ReactNode } from "react";
 import "opentui-spinner/react";
 import { TextAttributes, type UiHost, type TextProps } from "../../ui/host";
 import { renderAsciiText } from "../../ui/ascii-font";
 import { OpenTuiImageSurface } from "./image/surface";
 import { OpenTuiChartSurface } from "./chart-surface";
 
+interface OpenTuiPrimitiveProps {
+  children?: ReactNode;
+  [key: string]: unknown;
+}
+
+function createOpenTuiPrimitive(tagName: string) {
+  return forwardRef<unknown, OpenTuiPrimitiveProps>(function OpenTuiPrimitive(
+    { children, ...props },
+    ref,
+  ) {
+    return createElement(tagName as any, { ...props, ref }, children as ReactNode);
+  });
+}
+
 function mapTextAttributes(appAttributes: number | undefined, props?: TextProps): number | undefined {
   const flags = typeof appAttributes === "number" ? appAttributes : 0;
   let attributes = 0;
@@ -37,41 +51,59 @@ function mapTextContent(content: unknown): unknown {
       fg: mapColor(chunk.fg),
       bg: mapColor(chunk.bg),
       attributes: mapTextAttributes(chunk.attributes as number | undefined),
-    })));
+    })) as any);
   }
   return content;
 }
 
+const OpenTuiBox = createOpenTuiPrimitive("box");
+const OpenTuiScrollBox = createOpenTuiPrimitive("scrollbox");
+const OpenTuiInput = createOpenTuiPrimitive("input");
+const OpenTuiTextarea = createOpenTuiPrimitive("textarea");
+const OpenTuiSpinnerMark = createOpenTuiPrimitive("spinner");
+
+const OpenTuiText = forwardRef<unknown, TextProps>(function OpenTuiText({ children, ...props }, ref) {
+  const textProps = stripTextProps(props);
+  return createElement("text" as any, {
+    ...textProps,
+    ref,
+    content: mapTextContent(textProps.content),
+    attributes: mapTextAttributes(props.attributes as number | undefined, props),
+  }, children as ReactNode);
+});
+
+const OpenTuiSpan = forwardRef<unknown, TextProps>(function OpenTuiSpan({ children, ...props }, ref) {
+  return createElement("span" as any, {
+    ...stripTextProps(props),
+    ref,
+    attributes: mapTextAttributes(props.attributes as number | undefined, props),
+  }, children as ReactNode);
+});
+
+const OpenTuiStrong = forwardRef<unknown, TextProps>(function OpenTuiStrong({ children, ...props }, ref) {
+  return createElement("strong" as any, { ...stripTextProps(props), ref }, children as ReactNode);
+});
+
+const OpenTuiUnderline = forwardRef<unknown, TextProps>(function OpenTuiUnderline({ children, ...props }, ref) {
+  return createElement("u" as any, { ...stripTextProps(props), ref }, children as ReactNode);
+});
+
 export const openTuiUiHost: UiHost = {
   kind: "opentui",
   capabilities: {
     nativeCharts: true,
   },
-  Box: ({ children, ...props }) => <box {...props}>{children}</box>,
-  Text: ({ children, ...props }) => {
-    const textProps = stripTextProps(props);
-    return (
-      <text
-        {...textProps}
-        content={mapTextContent(textProps.content)}
-        attributes={mapTextAttributes(props.attributes as number | undefined, props)}
-      >
-        {children}
-      </text>
-    );
-  },
-  Span: ({ children, ...props }) => createElement("span" as any, {
-    ...stripTextProps(props),
-    attributes: mapTextAttributes(props.attributes as number | undefined, props),
-  }, children),
-  Strong: ({ children, ...props }) => createElement("strong" as any, stripTextProps(props), children),
-  Underline: ({ children, ...props }) => createElement("u" as any, stripTextProps(props), children),
-  ScrollBox: ({ children, ...props }) => <scrollbox {...props}>{children}</scrollbox>,
-  Input: ({ children, ...props }) => createElement("input" as any, props, children),
-  Textarea: ({ children, ...props }) => createElement("textarea" as any, props, children),
+  Box: OpenTuiBox as UiHost["Box"],
+  Text: OpenTuiText as UiHost["Text"],
+  Span: OpenTuiSpan as UiHost["Span"],
+  Strong: OpenTuiStrong as UiHost["Strong"],
+  Underline: OpenTuiUnderline as UiHost["Underline"],
+  ScrollBox: OpenTuiScrollBox as UiHost["ScrollBox"],
+  Input: OpenTuiInput as UiHost["Input"],
+  Textarea: OpenTuiTextarea as UiHost["Textarea"],
   ChartSurface: OpenTuiChartSurface,
   ImageSurface: OpenTuiImageSurface,
-  SpinnerMark: ({ children, ...props }) => createElement("spinner" as any, props, children),
+  SpinnerMark: OpenTuiSpinnerMark as UiHost["SpinnerMark"],
   AsciiText: ({ text, font = "tiny", color, fg, bg, backgroundColor, selectable = false, ...props }) => {
     const resolvedColor = color ?? fg;
     const resolvedBackground = backgroundColor ?? bg;

package/src/sources/provider-router/batches.ts

@@ -11,7 +11,12 @@ import { normalizeTickerFinancialsPriceHistory } from "../../utils/price-history
 import { isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import { resolveTickerFinancialsQuoteState } from "../../market-data/quotes/resolution";
 import { selectCachedResource } from "./cache";
-import { quoteWithFreshnessExchange, type CachedFinancialsSelection } from "./financials";
+import {
+  hasDeepStatementHistory,
+  hasDetailedStatementRows,
+  quoteWithFreshnessExchange,
+  type CachedFinancialsSelection,
+} from "./financials";
 import type { ProviderRouterCoreDeps } from "./route-types";
 
 export interface ProviderRouterBatchDeps extends ProviderRouterCoreDeps {
@@ -31,6 +36,10 @@ export interface ProviderRouterBatchDeps extends ProviderRouterCoreDeps {
 export class ProviderRouterBatchRoutes {
   constructor(private readonly deps: ProviderRouterBatchDeps) {}
 
+  private needsSingleFinancialsRoute(value: TickerFinancials): boolean {
+    return !(hasDetailedStatementRows(value) && hasDeepStatementHistory(value));
+  }
+
   async getQuotesBatch(
     targets: QuoteSubscriptionTarget[],
     options: { forceRefresh?: boolean } = {},
@@ -105,6 +114,7 @@ export class ProviderRouterBatchRoutes {
   ): Promise<TickerFinancialsBatchResult[]> {
     const forceRefresh = options.forceRefresh === true;
     const results = new Array<TickerFinancialsBatchResult | null>(targets.length).fill(null);
+    const batchFallbacks = new Array<TickerFinancials | null>(targets.length).fill(null);
     const misses: Array<{ index: number; target: CachedFinancialsTarget }> = [];
 
     targets.forEach((target, index) => {
@@ -139,6 +149,8 @@ export class ProviderRouterBatchRoutes {
           const entityKey = this.deps.getEntityKey(entry.target.symbol, entry.target.instrument ?? undefined);
           const variantKey = this.deps.getTickerVariantCandidates(entry.target.exchange)[0] ?? "";
           this.deps.cacheResource("financials", entityKey, variantKey, sourceKey, value, this.deps.resolveProviderPolicy("financials", batchProvider));
+          batchFallbacks[entry.index] = value;
+          if (this.needsSingleFinancialsRoute(value)) continue;
           results[entry.index] = { target: entry.target, financials: value };
         }
       }
@@ -153,7 +165,9 @@ export class ProviderRouterBatchRoutes {
         });
         results[index] = { target, financials };
       } catch (error) {
-        results[index] = { target, financials: null, error };
+        results[index] = batchFallbacks[index]
+          ? { target, financials: batchFallbacks[index] }
+          : { target, financials: null, error };
       }
     }));
 

package/src/sources/provider-router/financial-routes.ts

@@ -19,6 +19,7 @@ import { withBrokerTimeout } from "./brokers";
 import {
   deriveMarketCapFromShares,
   hasMeaningfulProfile,
+  hasShallowStatementHistory,
   mergeCachedFinancialRecords,
   mergeFinancials,
   quoteWithFreshnessExchange,
@@ -86,6 +87,10 @@ export class ProviderRouterFinancialRoutes {
       if (isOptionTicker && !cached.value.quote) {
         return quoteOnlyFinancials(cached.value);
       }
+      if (!cached.stale && hasMeaningfulProfile(cached.value) && hasShallowStatementHistory(cached.value)) {
+        const providerResult = await this.deps.primaryRoutes.fetchProviderFinancials(ticker, exchange, context);
+        return mergeFinancials(cached.value, providerResult?.value ?? null) ?? cached.value;
+      }
       if (!cached.stale && hasMeaningfulProfile(cached.value)) {
         return cached.value;
       }

package/src/sources/provider-router/financials.ts

@@ -1,6 +1,7 @@
 import type { CachedResourceRecord } from "../../data/resource-store";
 import type { AnalystResearchData, CorporateActionsData, FinancialStatement, Quote, TickerFinancials } from "../../types/financials";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
+import { mergeFinancialStatementRows } from "../../utils/financial-statements";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../../utils/price-history";
 import { isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import {
@@ -122,33 +123,20 @@ export function hasDetailedStatementRows(data: TickerFinancials | null | undefin
   return rows.some((row) => DETAILED_STATEMENT_KEYS.some((key) => typeof row[key] === "number"));
 }
 
-function mergeStatementRows(
-  primaryRows: FinancialStatement[],
-  fallbackRows: FinancialStatement[],
-): FinancialStatement[] {
-  if (primaryRows.length === 0) return fallbackRows;
-  if (fallbackRows.length === 0) return primaryRows;
-
-  const fallbackByDate = new Map(fallbackRows.map((row) => [row.date, row]));
-  const primaryDates = new Set(primaryRows.map((row) => row.date));
-  const mergedRows = primaryRows.map((row) => ({
-    ...fallbackByDate.get(row.date),
-    ...row,
-    date: row.date,
-  }));
-
-  for (const row of fallbackRows) {
-    if (!primaryDates.has(row.date)) mergedRows.push(row);
-  }
+export function hasDeepStatementHistory(data: TickerFinancials | null | undefined): boolean {
+  if (!data) return false;
+  return data.annualStatements.length >= 5 || data.quarterlyStatements.length >= 8;
+}
 
-  return mergedRows.sort((left, right) => left.date.localeCompare(right.date));
+export function hasShallowStatementHistory(data: TickerFinancials | null | undefined): boolean {
+  return hasStatementRows(data) && !hasDeepStatementHistory(data);
 }
 
 export function mergeMissingStatementArrays(primary: TickerFinancials, fallback: TickerFinancials): TickerFinancials {
   return {
     ...primary,
-    annualStatements: mergeStatementRows(primary.annualStatements, fallback.annualStatements),
-    quarterlyStatements: mergeStatementRows(primary.quarterlyStatements, fallback.quarterlyStatements),
+    annualStatements: mergeFinancialStatementRows(primary.annualStatements, fallback.annualStatements),
+    quarterlyStatements: mergeFinancialStatementRows(primary.quarterlyStatements, fallback.quarterlyStatements),
   };
 }
 
@@ -216,8 +204,8 @@ export function mergeFinancials(primary: TickerFinancials | null, fallback: Tick
     profile: mergeDefinedObject(primary.profile, fallback.profile),
     fundamentals: mergeDefinedObject(primary.fundamentals, fallback.fundamentals),
     priceHistory: normalizePriceHistory(dominant.priceHistory.length > 0 ? dominant.priceHistory : secondary.priceHistory),
-    annualStatements: mergeStatementRows(primary.annualStatements, fallback.annualStatements),
-    quarterlyStatements: mergeStatementRows(primary.quarterlyStatements, fallback.quarterlyStatements),
+    annualStatements: mergeFinancialStatementRows(primary.annualStatements, fallback.annualStatements),
+    quarterlyStatements: mergeFinancialStatementRows(primary.quarterlyStatements, fallback.quarterlyStatements),
   });
 }