gloomberb 0.12.0 → 0.13.2

package/src/plugins/builtin/short-interest/headless.ts

@@ -0,0 +1,111 @@
+import type {
+  HeadlessPaneColumn,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatCompact, formatNumber } from "../../../utils/format";
+import { fetchShortInterest } from "./client";
+import {
+  buildRows,
+  sortRows,
+  type SortPreference,
+} from "./model";
+import type { ShortInterestRecord } from "./types";
+
+const SHORT_INTEREST_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "settlementDate", header: "Date" },
+  {
+    key: "sharesShort",
+    header: "Shares Short",
+    align: "right",
+    format: (value) => formatCompact(Number(value)),
+  },
+  {
+    key: "daysToCover",
+    header: "Days to Cover",
+    align: "right",
+    format: (value) => value == null ? "-" : formatNumber(Number(value), 2),
+  },
+  {
+    key: "averageDailyVolume",
+    header: "Avg Daily Vol",
+    align: "right",
+    format: (value) => value == null ? "-" : formatCompact(Number(value)),
+  },
+  {
+    key: "shortPercentFloat",
+    header: "% Float",
+    align: "right",
+    format: (value) => value == null ? "-" : `${formatNumber(Number(value), 2)}%`,
+  },
+];
+
+export interface ShortInterestHeadlessDependencies {
+  loadRecords(
+    symbol: string,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<ShortInterestRecord[]>;
+}
+
+const defaultDependencies: ShortInterestHeadlessDependencies = {
+  loadRecords: (symbol, _args, ctx) => fetchShortInterest(symbol, ctx.apiClient),
+};
+
+export function createShortInterestHeadless(
+  dependencies: ShortInterestHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "US equity ticker.",
+    },
+    options: [
+      {
+        key: "order",
+        description: "Settlement date order.",
+        type: "enum",
+        values: [{ value: "newest" }, { value: "oldest" }],
+        defaultValue: "newest",
+      },
+      {
+        key: "limit",
+        aliases: ["count", "rows"],
+        description: "Maximum settlement rows.",
+        type: "integer",
+        defaultValue: 24,
+        minimum: 1,
+        maximum: 100,
+      },
+    ],
+    columns: SHORT_INTEREST_COLUMNS,
+    describe: (args) => `Short Interest | ${args.symbols[0]}`,
+    async load(args, ctx) {
+      const symbol = args.symbols[0]!;
+      const records = await dependencies.loadRecords(symbol, args, ctx);
+      const preference: SortPreference = {
+        columnId: "settlementDate",
+        direction: args.options.order === "oldest" ? "asc" : "desc",
+      };
+      const limit = Number(args.options.limit);
+      const rows = sortRows(buildRows(records), preference)
+        .slice(0, limit)
+        .map((row) => ({
+          settlementDate: row.settlementDate,
+          sharesShort: row.record.sharesShort,
+          daysToCover: row.record.shortRatio,
+          averageDailyVolume: row.record.averageDailyVolume,
+          shortPercentFloat: row.record.shortPercentFloat,
+        }));
+      return {
+        rows,
+        metadata: { symbol, order: args.options.order },
+      };
+    },
+  };
+}
+
+export const shortInterestHeadless = createShortInterestHeadless();

package/src/plugins/builtin/short-interest/index.tsx

@@ -5,8 +5,11 @@ import {
   resetShortInterestHealth,
   YAHOO_SHORT_INTEREST_CONNECTION_ID,
 } from "./client";
+import { shortInterestHeadless } from "./headless";
 import { ShortInterestView } from "./pane";
 
+export { shortInterestHeadless } from "./headless";
+
 let disposeConnection: (() => void) | null = null;
 
 export const shortInterestModule: PluginModule = {
@@ -50,14 +53,17 @@ export const shortInterestModule: PluginModule = {
   ],
 
   paneTemplates: [
-    createTickerSurfacePaneTemplate({
-      id: "short-interest-pane",
-      paneId: "short-interest",
-      label: "Short Interest",
-      // Yahoo's key-statistics module only carries the current and prior settlement dates.
-      description: "Bi-monthly short interest settlements from FINRA with days to cover and average daily volume.",
-      keywords: ["short", "interest", "si", "shorts", "borrow", "days", "cover"],
-      shortcut: "SI",
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "short-interest-pane",
+        paneId: "short-interest",
+        label: "Short Interest",
+        // Yahoo's key-statistics module only carries the current and prior settlement dates.
+        description: "Bi-monthly short interest settlements from FINRA with days to cover and average daily volume.",
+        keywords: ["short", "interest", "si", "shorts", "borrow", "days", "cover"],
+        shortcut: "SI",
+      }),
+      headless: shortInterestHeadless,
+    },
   ],
 };

package/src/plugins/builtin/thirteenf/data.ts

@@ -45,35 +45,37 @@ export async function loadBrowserRows(
   tab: ThirteenFBrowserTab,
   query: string,
   signal?: AbortSignal,
-  options: { forceRefresh?: boolean; offset?: number } = {},
+  options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
 ): Promise<BrowserLoadResult> {
   const now = new Date();
   const from = dateYearsAgo(2, now);
   const to = todayIso(now);
   const quarter = latestLikely13FQuarter(now);
   const offset = Math.max(0, options.offset ?? 0);
+  const browserLimit = Math.max(1, options.limit ?? BROWSER_PAGE_LIMIT);
+  const latestLimit = Math.max(1, options.limit ?? LATEST_FILINGS_PAGE_LIMIT);
   const apiOptions = { forceRefresh: options.forceRefresh };
   const pageApiOptions = { forceRefresh: options.forceRefresh, offset };
 
   if (tab === "performance") {
-    const topFunds = await listTopThirteenFFunds(quarter, BROWSER_PAGE_LIMIT, signal, pageApiOptions);
+    const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions);
     const funds: ThirteenFFund[] = topFunds.map((fund) => ({ cik: fund.cik, name: fund.name }));
-    const forms = await loadLatestFormsForFunds(funds.slice(0, FORM_ENRICHMENT_LIMIT), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh });
+    const forms = await loadLatestFormsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh });
     return {
       rows: buildBrowserRows({ topFunds, forms, source: "performance" }),
       quarter,
       period: topFunds[0]?.periodOfReport,
-      hasMore: topFunds.length >= BROWSER_PAGE_LIMIT,
+      hasMore: topFunds.length >= browserLimit,
       nextOffset: offset + topFunds.length,
     };
   }
 
   if (tab === "latest") {
-    const filings = await listThirteenFFilings(recentIso(21, now), to, LATEST_FILINGS_PAGE_LIMIT, signal, pageApiOptions);
+    const filings = await listThirteenFFilings(recentIso(21, now), to, latestLimit, signal, pageApiOptions);
     return {
       rows: buildBrowserRows({ latestFilings: filings, source: "latest" }),
       period: filings[0]?.periodOfReport,
-      hasMore: filings.length >= LATEST_FILINGS_PAGE_LIMIT,
+      hasMore: filings.length >= latestLimit,
       nextOffset: offset + filings.length,
     };
   }
@@ -97,7 +99,7 @@ export async function loadBrowserRows(
     try {
       const holders = await lookupThirteenFHoldersByCusip(cusip, periodOfReport, signal, apiOptions);
       const forms = new Map<string, ThirteenFFormSummary>();
-      const pageCiks = holders.ciks.slice(offset, offset + BROWSER_PAGE_LIMIT);
+      const pageCiks = holders.ciks.slice(offset, offset + browserLimit);
       const funds = await Promise.all(pageCiks.map(async (cik): Promise<ThirteenFFund> => {
         const fundForms = await listThirteenFForms(cik, from, to, 1, signal, apiOptions);
         if (fundForms[0]) forms.set(cik, fundForms[0]);
@@ -136,10 +138,10 @@ export async function loadBrowserRows(
       nextOffset: offset + 1,
     };
   }
-  const funds = await searchThirteenFFunds(trimmed, BROWSER_PAGE_LIMIT, signal, pageApiOptions);
+  const funds = await searchThirteenFFunds(trimmed, browserLimit, signal, pageApiOptions);
   const [forms, topFunds] = await Promise.all([
-    loadLatestFormsForFunds(funds.slice(0, FORM_ENRICHMENT_LIMIT), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh }),
-    listTopThirteenFFunds(quarter, BROWSER_PAGE_LIMIT, signal, { forceRefresh: options.forceRefresh }).catch(() => []),
+    loadLatestFormsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh }),
+    listTopThirteenFFunds(quarter, browserLimit, signal, { forceRefresh: options.forceRefresh }).catch(() => []),
   ]);
   const topByCik = new Map(topFunds.map((fund) => [fund.cik, fund]));
   const matchedTopFunds = funds
@@ -153,7 +155,7 @@ export async function loadBrowserRows(
       source: "funds",
     }),
     quarter,
-    hasMore: funds.length >= BROWSER_PAGE_LIMIT,
+    hasMore: funds.length >= browserLimit,
     nextOffset: offset + funds.length,
   };
 }

package/src/plugins/builtin/thirteenf/headless.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createThirteenFHeadless } from "./headless";
+import type { FundDetailData } from "./types";
+
+const detail: FundDetailData = {
+  cik: "0001067983",
+  name: "Berkshire Hathaway",
+  forms: [
+    {
+      url: "https://www.sec.gov/latest",
+      accessionNumber: "latest",
+      submissionType: "13F-HR",
+      periodOfReport: "2026-06-30",
+      filedAsOfDate: "2026-08-14",
+      cik: "0001067983",
+      companyName: "Berkshire Hathaway",
+      tableValueTotal: 300,
+      tableEntryTotal: 2,
+      isAmendment: false,
+    },
+    {
+      url: "https://www.sec.gov/previous",
+      accessionNumber: "previous",
+      submissionType: "13F-HR",
+      periodOfReport: "2026-03-31",
+      filedAsOfDate: "2026-05-15",
+      cik: "0001067983",
+      companyName: "Berkshire Hathaway",
+      tableValueTotal: 200,
+      tableEntryTotal: 1,
+      isAmendment: false,
+    },
+  ],
+  latestForm: null,
+  previousForm: null,
+  latestHoldings: [],
+  previousHoldings: [],
+};
+detail.latestForm = detail.forms[0]!;
+detail.previousForm = detail.forms[1]!;
+detail.latestHoldings = [
+  {
+    accessionNumber: "latest",
+    cik: detail.cik,
+    issuer: "Apple Inc",
+    titleOfClass: "COM",
+    cusip: "037833100",
+    ticker: "AAPL",
+    value: 300,
+    shares: 3,
+    shareType: "SH",
+    investmentDiscretion: "DFND",
+    votingAuthoritySole: 3,
+    votingAuthorityShared: 0,
+    votingAuthorityNone: 0,
+    putCall: "",
+  },
+];
+detail.previousHoldings = [{ ...detail.latestHoldings[0]!, accessionNumber: "previous", value: 200, shares: 2 }];
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-thirteenf"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(view: string, limit = 50): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "1067983",
+    argument: "1067983",
+    symbols: [],
+    options: { view, limit },
+  };
+}
+
+describe("13F headless model", () => {
+  test("projects browser rows and switches to fund holdings", async () => {
+    const headless = createThirteenFHeadless({
+      loadBrowser: async () => ({
+        rows: [
+          { id: "one", cik: detail.cik, name: detail.name, estQuarterReturn: 8.2, source: "performance" },
+          { id: "two", cik: "0000000002", name: "Second Fund", estQuarterReturn: 4.1, source: "performance" },
+        ],
+        quarter: "2026Q2",
+      }),
+      loadDetail: async () => detail,
+    });
+
+    const browser = await headless.load(args("performance", 1), context());
+    expect(browser.rows).toEqual([expect.objectContaining({
+      cik: detail.cik,
+      name: detail.name,
+      estQuarterReturn: 8.2,
+    })]);
+
+    const holdings = await headless.load(args("holdings", 5), context());
+    expect(holdings.rows).toEqual([expect.objectContaining({
+      ticker: "AAPL",
+      value: 300,
+      sharesChange: 1,
+      action: "add",
+      actionLabel: "Add",
+    })]);
+    expect(holdings.metadata).toMatchObject({ view: "holdings", fund: detail.name });
+  });
+});

package/src/plugins/builtin/thirteenf/headless.ts

@@ -0,0 +1,286 @@
+import type {
+  HeadlessPaneColumn,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { normalizeCik } from "./api";
+import {
+  loadBrowserRows,
+  loadFundDetail,
+  type BrowserLoadResult,
+} from "./data";
+import {
+  DEFAULT_BROWSER_SORT,
+  DEFAULT_HOLDING_SORT,
+  DEFAULT_TIMELINE_SORT,
+  buildFundHoldingRows,
+  buildTimelineRows,
+  inferBrowserTabFromQuery,
+  isCikQuery,
+  positionType,
+  sortBrowserRows,
+  sortHoldingRows,
+  sortTimelineRows,
+} from "./model";
+import {
+  actionLabel,
+  formatChangeShares,
+  formatMoneyCompact,
+  formatPercentMaybe,
+  formatRawPercentMaybe,
+  formatShares,
+  formatShortDate,
+} from "./format";
+import type {
+  FundDetailData,
+  ThirteenFBrowserTab,
+} from "./types";
+
+const BROWSER_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "name", header: "Fund" },
+  { key: "cik", header: "CIK" },
+  { key: "periodOfReport", header: "Period" },
+  {
+    key: "estQuarterReturn",
+    header: "Est 13F",
+    align: "right",
+    format: (value) => formatRawPercentMaybe(value == null ? null : Number(value)),
+  },
+  {
+    key: "tableValueTotal",
+    header: "Value",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  { key: "tableEntryTotal", header: "Rows", align: "right" },
+  {
+    key: "filedAsOfDate",
+    header: "Filed",
+    format: (value) => formatShortDate(typeof value === "string" ? value : null),
+  },
+];
+
+const HOLDING_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "ticker", header: "Ticker" },
+  { key: "type", header: "Type" },
+  { key: "issuer", header: "Issuer" },
+  {
+    key: "value",
+    header: "Value",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  {
+    key: "estimatedPnl",
+    header: "Est P&L",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  {
+    key: "weight",
+    header: "Weight",
+    align: "right",
+    format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
+  },
+  {
+    key: "shares",
+    header: "Shares",
+    align: "right",
+    format: (value) => formatShares(value == null ? null : Number(value)),
+  },
+  {
+    key: "sharesChange",
+    header: "QoQ",
+    align: "right",
+    format: (value) => formatChangeShares(value == null ? null : Number(value)),
+  },
+  { key: "actionLabel", header: "Action" },
+];
+
+const FILING_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "periodOfReport", header: "Period" },
+  {
+    key: "filedAsOfDate",
+    header: "Filed",
+    format: (value) => formatShortDate(typeof value === "string" ? value : null),
+  },
+  {
+    key: "tableValueTotal",
+    header: "Value",
+    align: "right",
+    format: (value) => formatMoneyCompact(value == null ? null : Number(value)),
+  },
+  { key: "tableEntryTotal", header: "Rows", align: "right" },
+  {
+    key: "valueChangePercent",
+    header: "Value%",
+    align: "right",
+    format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
+  },
+  { key: "submissionType", header: "Form" },
+];
+
+type HeadlessThirteenFView =
+  | "auto"
+  | "performance"
+  | "funds"
+  | "by-ticker"
+  | "latest"
+  | "holdings"
+  | "filings";
+
+export interface ThirteenFHeadlessDependencies {
+  loadBrowser(
+    tab: ThirteenFBrowserTab,
+    query: string,
+    limit: number,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<BrowserLoadResult>;
+  loadDetail(
+    cik: string,
+    name: string,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<FundDetailData>;
+}
+
+const defaultDependencies: ThirteenFHeadlessDependencies = {
+  loadBrowser: (tab, query, limit, _args, ctx) => loadBrowserRows(
+    tab,
+    query,
+    ctx.signal,
+    { limit },
+  ),
+  loadDetail: (cik, name, _args, ctx) => loadFundDetail(cik, name, ctx.signal),
+};
+
+function browserTab(view: HeadlessThirteenFView, query: string): ThirteenFBrowserTab {
+  if (view === "performance" || view === "funds" || view === "latest") return view;
+  if (view === "by-ticker") return "byTicker";
+  return inferBrowserTabFromQuery(query);
+}
+
+async function resolveFund(
+  query: string,
+  limit: number,
+  args: HeadlessPaneLoadArgs,
+  ctx: HeadlessPaneContext,
+  dependencies: ThirteenFHeadlessDependencies,
+): Promise<{ cik: string; name: string }> {
+  if (!query) throw new Error("13F holdings and filings require a fund name or CIK.");
+  if (isCikQuery(query)) return { cik: normalizeCik(query), name: query };
+  const result = await dependencies.loadBrowser("funds", query, Math.min(limit, 25), args, ctx);
+  const exact = result.rows.find((row) => row.name.toLocaleLowerCase() === query.toLocaleLowerCase());
+  const fund = exact ?? result.rows[0];
+  if (!fund) throw new Error(`No 13F fund found for "${query}".`);
+  return { cik: fund.cik, name: fund.name };
+}
+
+export function createThirteenFHeadless(
+  dependencies: ThirteenFHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "free-text",
+      placeholder: "fund, ticker, or CIK",
+      description: "Optional fund name, ticker, CIK, or latest keyword.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "view",
+        description: "Fund browser mode or detail tab.",
+        type: "enum",
+        values: [
+          { value: "auto" },
+          { value: "performance" },
+          { value: "funds" },
+          { value: "by-ticker", aliases: ["ticker", "byTicker"] },
+          { value: "latest" },
+          { value: "holdings" },
+          { value: "filings" },
+        ],
+        defaultValue: "auto",
+      },
+      {
+        key: "limit",
+        aliases: ["count", "rows"],
+        description: "Maximum rows.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    describe: (args) => `13F Funds | ${String(args.options.view)}`,
+    async load(args, ctx) {
+      const query = typeof args.argument === "string" ? args.argument.trim() : "";
+      const requestedView = String(args.options.view) as HeadlessThirteenFView;
+      const view = requestedView === "auto" && isCikQuery(query) ? "holdings" : requestedView;
+      const limit = Number(args.options.limit);
+
+      if (view === "holdings" || view === "filings") {
+        const fund = await resolveFund(query, limit, args, ctx, dependencies);
+        const detail = await dependencies.loadDetail(fund.cik, fund.name, args, ctx);
+        if (view === "filings") {
+          const rows = sortTimelineRows(buildTimelineRows(detail.forms), DEFAULT_TIMELINE_SORT)
+            .slice(0, limit)
+            .map((row) => ({ ...row }));
+          return {
+            columns: FILING_COLUMNS,
+            rows,
+            metadata: {
+              view,
+              cik: detail.cik,
+              fund: detail.name,
+              latestPeriod: detail.latestForm?.periodOfReport ?? null,
+            },
+          };
+        }
+        const rows = sortHoldingRows(
+          buildFundHoldingRows(detail).filter((row) => row.value != null),
+          DEFAULT_HOLDING_SORT,
+        )
+          .slice(0, limit)
+          .map((row) => ({
+            ...row,
+            type: positionType(row),
+            actionLabel: actionLabel(row.action),
+          }));
+        return {
+          columns: HOLDING_COLUMNS,
+          rows,
+          metadata: {
+            view,
+            cik: detail.cik,
+            fund: detail.name,
+            latestPeriod: detail.latestForm?.periodOfReport ?? null,
+            previousPeriod: detail.previousForm?.periodOfReport ?? null,
+          },
+        };
+      }
+
+      const tab = browserTab(view, query);
+      const result = await dependencies.loadBrowser(tab, query, limit, args, ctx);
+      return {
+        columns: BROWSER_COLUMNS,
+        rows: sortBrowserRows(result.rows, DEFAULT_BROWSER_SORT)
+          .slice(0, limit)
+          .map((row) => ({ ...row })),
+        ...(result.warning ? { errors: [result.warning] } : {}),
+        metadata: {
+          view: tab,
+          query: query || null,
+          period: result.period ?? null,
+          quarter: result.quarter ?? null,
+          hasMore: result.hasMore ?? false,
+        },
+      };
+    },
+  };
+}
+
+export const thirteenFHeadless = createThirteenFHeadless();

package/src/plugins/builtin/thirteenf/index.tsx

@@ -11,6 +11,9 @@ import {
   attachThirteenFApiPersistence,
   resetThirteenFApiPersistence,
 } from "./api";
+import { thirteenFHeadless } from "./headless";
+
+export { thirteenFHeadless } from "./headless";
 
 function queryFromOptions(options?: PaneTemplateCreateOptions): string {
   return (options?.arg ?? options?.values?.query ?? "").trim();
@@ -55,6 +58,7 @@ export const thirteenFModule: PluginModule = {
         argKind: "text",
         argOptional: true,
       },
+      headless: thirteenFHeadless,
       createInstance(_context: PaneTemplateContext, options?: PaneTemplateCreateOptions) {
         const query = queryFromOptions(options);
         const browserMode = inferBrowserTabFromQuery(query);

package/src/plugins/builtin/thirteenf/model.ts

@@ -615,6 +615,19 @@ export function selectedIndexById<T extends { id: string }>(rows: T[], selectedI
   return index >= 0 ? index : rows.length > 0 ? 0 : -1;
 }
 
+export function positionType(row: {
+  putCall: string;
+  titleOfClass: string;
+  shareType: string;
+}): string {
+  const putCall = row.putCall.trim().toUpperCase();
+  if (putCall === "PUT" || putCall === "CALL") return putCall;
+  const title = row.titleOfClass.trim().toUpperCase();
+  if (title) return title;
+  const shareType = row.shareType.trim().toUpperCase();
+  return shareType || "--";
+}
+
 export function isCikQuery(query: string): boolean {
   return CIK_RE.test(query.trim());
 }