gloomberb 0.11.2 → 0.12.0

package/src/plugins/builtin/research-search/saved-view.tsx

@@ -0,0 +1,171 @@
+import { useCallback, useMemo, useState } from "react";
+import {
+  DataTableView,
+  type DataTableCell,
+  type DataTableColumn,
+  type DataTableKeyEvent,
+} from "../../../components";
+import { colors } from "../../../theme/colors";
+import { isPlainKey } from "../../../utils/keyboard";
+import type { CloudSavedSearch } from "../../../api-client";
+import { describeFilters, formatHitDate } from "./model";
+
+type SavedColumnId = "name" | "filters" | "alert" | "last" | "hits";
+
+interface SavedColumn extends DataTableColumn {
+  id: SavedColumnId;
+}
+
+function buildSavedColumns(width: number): SavedColumn[] {
+  const alertWidth = 6;
+  const lastWidth = 10;
+  const hitsWidth = 6;
+  const remaining = Math.max(24, width - (alertWidth + lastWidth + hitsWidth + 8));
+  const nameWidth = Math.max(12, Math.round(remaining * 0.5));
+  return [
+    { id: "name", label: "SAVED SEARCH", width: nameWidth, align: "left" },
+    { id: "filters", label: "FILTERS", width: Math.max(10, remaining - nameWidth), align: "left" },
+    { id: "alert", label: "ALERT", width: alertWidth, align: "left" },
+    { id: "last", label: "LAST HIT", width: lastWidth, align: "left" },
+    { id: "hits", label: "HITS", width: hitsWidth, align: "right" },
+  ];
+}
+
+interface SavedSort {
+  columnId: SavedColumnId;
+  direction: "asc" | "desc";
+}
+
+function sortValue(search: CloudSavedSearch, columnId: SavedColumnId): string | number {
+  switch (columnId) {
+    case "last":
+      return search.lastMatchAt ? Date.parse(search.lastMatchAt) : 0;
+    case "hits":
+      return search.matchCount;
+    case "alert":
+      return search.alertEnabled ? 1 : 0;
+    case "filters":
+      return describeFilters(search.filters).toLowerCase();
+    default:
+      return (search.name || search.query).toLowerCase();
+  }
+}
+
+export function SavedSearchesView({
+  searches,
+  selectedId,
+  onSelect,
+  onRun,
+  onToggleAlert,
+  onDelete,
+  focused,
+  width,
+  height,
+  emptyTitle,
+}: {
+  searches: CloudSavedSearch[];
+  selectedId: string | null;
+  onSelect: (id: string) => void;
+  onRun: (search: CloudSavedSearch) => void;
+  onToggleAlert: (search: CloudSavedSearch) => void;
+  onDelete: (search: CloudSavedSearch) => void;
+  focused: boolean;
+  width: number;
+  height: number;
+  emptyTitle: string;
+}) {
+  const [sort, setSort] = useState<SavedSort>({ columnId: "last", direction: "desc" });
+  const columns = useMemo(() => buildSavedColumns(width), [width]);
+  const rows = useMemo(() => [...searches].sort((left, right) => {
+    const a = sortValue(left, sort.columnId);
+    const b = sortValue(right, sort.columnId);
+    if (a === b) return 0;
+    return (a < b ? -1 : 1) * (sort.direction === "asc" ? 1 : -1);
+  }), [searches, sort]);
+
+  const renderCell = useCallback((
+    search: CloudSavedSearch,
+    column: SavedColumn,
+    _index: number,
+    rowState: { selected: boolean },
+  ): DataTableCell => {
+    const selectedColor = rowState.selected ? colors.selectedText : undefined;
+    switch (column.id) {
+      case "name":
+        return { text: search.name || search.query, color: selectedColor ?? colors.text };
+      case "filters":
+        return {
+          text: describeFilters(search.filters) || "\u2014",
+          color: selectedColor ?? colors.textDim,
+        };
+      case "alert":
+        return {
+          text: search.alertEnabled ? "on" : "off",
+          color: selectedColor ?? (search.alertEnabled ? colors.positive : colors.textMuted),
+          // The cell is the switch, so alerts can be flipped without the keyboard.
+          onMouseDown: (event: any) => {
+            event.preventDefault?.();
+            event.stopPropagation?.();
+            onToggleAlert(search);
+          },
+        };
+      case "last":
+        return {
+          text: search.lastMatchAt ? formatHitDate(search.lastMatchAt) : "\u2014",
+          color: selectedColor ?? colors.textDim,
+        };
+      case "hits":
+        return {
+          text: search.matchCount > 0 ? String(search.matchCount) : "\u2014",
+          color: selectedColor ?? colors.textDim,
+        };
+    }
+  }, [onToggleAlert]);
+
+  const handleKeyDown = useCallback((event: DataTableKeyEvent) => {
+    const selected = searches.find((search) => search.id === selectedId);
+    if (!selected) return false;
+    if (isPlainKey(event, "a")) {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      onToggleAlert(selected);
+      return true;
+    }
+    if (isPlainKey(event, "d")) {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      onDelete(selected);
+      return true;
+    }
+    return false;
+  }, [onDelete, onToggleAlert, searches, selectedId]);
+
+  return (
+    <DataTableView<CloudSavedSearch, SavedColumn>
+      focused={focused}
+      rootWidth={width}
+      rootHeight={height}
+      columns={columns}
+      items={rows}
+      selection={{
+        kind: "id",
+        selectedId,
+        getId: (search) => search.id,
+        onChange: onSelect,
+      }}
+      onActivate={onRun}
+      onRootKeyDown={handleKeyDown}
+      sortColumnId={sort.columnId}
+      sortDirection={sort.direction}
+      onHeaderClick={(columnId) => setSort((current) => (
+        current.columnId === columnId
+          ? { columnId, direction: current.direction === "asc" ? "desc" : "asc" }
+          : { columnId: columnId as SavedColumnId, direction: columnId === "name" ? "asc" : "desc" }
+      ))}
+      getItemKey={(search) => search.id}
+      renderCell={renderCell}
+      showHorizontalScrollbar={false}
+      emptyStateTitle={emptyTitle}
+    />
+  );
+}

package/src/plugins/builtin/research-search/snippet-text.tsx

@@ -0,0 +1,35 @@
+import { Box, Text, TextAttributes } from "../../../ui";
+import { colors } from "../../../theme/colors";
+import type { SnippetSegment } from "./snippet";
+
+/**
+ * Renders one line of text where matched terms are styled instead of shown as
+ * literal `<mark>` tags. Marked runs are foreground-only so a selected table row
+ * keeps its own background.
+ */
+export function SnippetText({
+  segments,
+  color = colors.text,
+  dimColor,
+  backgroundColor,
+}: {
+  segments: readonly SnippetSegment[];
+  color?: string;
+  /** Overrides the unmatched-run color, e.g. to dim context around a match. */
+  dimColor?: string;
+  backgroundColor?: string;
+}) {
+  return (
+    <Box flexDirection="row" height={1} overflow="hidden" backgroundColor={backgroundColor}>
+      {segments.map((segment, index) => (
+        <Text
+          key={index}
+          fg={segment.marked ? colors.warning : dimColor ?? color}
+          attributes={segment.marked ? TextAttributes.BOLD : TextAttributes.NONE}
+        >
+          {segment.text}
+        </Text>
+      ))}
+    </Box>
+  );
+}

package/src/plugins/builtin/research-search/snippet.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import {
+  highlightTerms,
+  parseMarkedSnippet,
+  snippetMatchTerms,
+  snippetPlainText,
+  truncateSegments,
+} from "./snippet";
+
+describe("parseMarkedSnippet", () => {
+  test("splits matched runs and joins fragments on one line", () => {
+    expect(parseMarkedSnippet("we saw <mark>margin</mark> pressure \u2026 and\nmore <mark>margin</mark> talk")).toEqual([
+      { text: "we saw ", marked: false },
+      { text: "margin", marked: true },
+      { text: " pressure \u2026 and more ", marked: false },
+      { text: "margin", marked: true },
+      { text: " talk", marked: false },
+    ]);
+  });
+
+  test("keeps text visible when tags are unbalanced", () => {
+    expect(parseMarkedSnippet("cut off at <mark>guidance")).toEqual([
+      { text: "cut off at ", marked: false },
+      { text: "guidance", marked: true },
+    ]);
+    expect(parseMarkedSnippet("stray</mark> closer")).toEqual([
+      { text: "stray closer", marked: false },
+    ]);
+  });
+
+  test("treats nested marks as one highlight", () => {
+    expect(parseMarkedSnippet("<mark>free <mark>cash</mark> flow</mark> grew")).toEqual([
+      { text: "free cash flow", marked: true },
+      { text: " grew", marked: false },
+    ]);
+  });
+
+  test("decodes entities once, so escaped markup stays literal", () => {
+    expect(snippetPlainText("AT&amp;T and &amp;lt;mark&amp;gt; and &#39;quoted&#39;")).toBe(
+      "AT&T and &lt;mark&gt; and 'quoted'",
+    );
+  });
+
+  test("collects distinct matched terms", () => {
+    expect(snippetMatchTerms("<mark>Margin</mark> and <mark>margin</mark> and <mark>FCF</mark>"))
+      .toEqual(["margin", "fcf"]);
+  });
+});
+
+describe("truncateSegments", () => {
+  test("clips inside the run that overflows and marks the cut", () => {
+    const segments = parseMarkedSnippet("alpha <mark>bravo</mark> charlie");
+    expect(truncateSegments(segments, 9)).toEqual([
+      { text: "alpha ", marked: false },
+      { text: "br", marked: true },
+      { text: "\u2026", marked: false },
+    ]);
+  });
+
+  test("returns the segments untouched when they already fit", () => {
+    const segments = parseMarkedSnippet("<mark>fits</mark>");
+    expect(truncateSegments(segments, 10)).toBe(segments);
+  });
+});
+
+describe("highlightTerms", () => {
+  test("matches case-insensitively and prefers the longest term", () => {
+    expect(highlightTerms("Free cash flow and cash", ["cash", "free cash flow"])).toEqual([
+      { text: "Free cash flow", marked: true },
+      { text: " and ", marked: false },
+      { text: "cash", marked: true },
+    ]);
+  });
+
+  test("leaves text intact when no term is usable", () => {
+    expect(highlightTerms("plain body", [])).toEqual([{ text: "plain body", marked: false }]);
+  });
+});

package/src/plugins/builtin/research-search/snippet.ts

@@ -0,0 +1,134 @@
+import { truncateTextSegments } from "../../../utils/format";
+
+export interface SnippetSegment {
+  text: string;
+  /** Inside a `<mark>` the server put around a matched term. */
+  marked: boolean;
+}
+
+const MARK_TAG = /<(\/?)mark\s*>/gi;
+const ENTITY = /&(?:#(\d+)|#x([0-9a-f]+)|(amp|lt|gt|quot|apos|nbsp));/gi;
+
+const NAMED_ENTITIES: Record<string, string> = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: "\"",
+  apos: "'",
+  nbsp: " ",
+};
+
+/**
+ * Decodes in one pass so `&amp;lt;` yields the literal `&lt;` rather than being
+ * decoded twice into `<`.
+ */
+function decodeEntities(value: string): string {
+  return value.replace(ENTITY, (match, decimal?: string, hex?: string, name?: string) => {
+    if (decimal) return codePoint(Number.parseInt(decimal, 10)) ?? match;
+    if (hex) return codePoint(Number.parseInt(hex, 16)) ?? match;
+    return NAMED_ENTITIES[(name ?? "").toLowerCase()] ?? match;
+  });
+}
+
+function codePoint(value: number): string | null {
+  if (!Number.isFinite(value) || value < 0 || value > 0x10ffff) return null;
+  try {
+    return String.fromCodePoint(value);
+  } catch {
+    return null;
+  }
+}
+
+/** Snippets are rendered on one line, so every run of whitespace becomes a space. */
+function flatten(value: string): string {
+  return value.replace(/\s+/g, " ");
+}
+
+function pushSegment(segments: SnippetSegment[], text: string, marked: boolean): void {
+  if (!text) return;
+  const last = segments[segments.length - 1];
+  if (last && last.marked === marked) {
+    last.text += text;
+    return;
+  }
+  segments.push({ text, marked });
+}
+
+/**
+ * Splits a server snippet into plain and matched runs.
+ *
+ * The server is the only writer of these tags, but a snippet is cut out of
+ * arbitrary document text: a truncated fragment can end mid-tag, and an
+ * unbalanced `</mark>` must not swallow the words around it. Unclosed marks run
+ * to the end, stray closers are dropped, and nested marks stay one highlight.
+ */
+export function parseMarkedSnippet(snippet: string): SnippetSegment[] {
+  const segments: SnippetSegment[] = [];
+  let depth = 0;
+  let cursor = 0;
+
+  MARK_TAG.lastIndex = 0;
+  for (let match = MARK_TAG.exec(snippet); match; match = MARK_TAG.exec(snippet)) {
+    pushSegment(segments, flatten(decodeEntities(snippet.slice(cursor, match.index))), depth > 0);
+    depth = match[1] === "/" ? Math.max(0, depth - 1) : depth + 1;
+    cursor = match.index + match[0].length;
+  }
+  pushSegment(segments, flatten(decodeEntities(snippet.slice(cursor))), depth > 0);
+
+  const first = segments[0];
+  if (first) first.text = first.text.replace(/^ +/, "");
+  const last = segments[segments.length - 1];
+  if (last) last.text = last.text.replace(/ +$/, "");
+  return segments.filter((segment) => segment.text.length > 0);
+}
+
+export function snippetPlainText(snippet: string): string {
+  return parseMarkedSnippet(snippet).map((segment) => segment.text).join("");
+}
+
+/** Distinct matched terms, so a document view can highlight them outside the snippet. */
+export function snippetMatchTerms(snippet: string): string[] {
+  const terms = new Set<string>();
+  for (const segment of parseMarkedSnippet(snippet)) {
+    const term = segment.marked ? segment.text.trim() : "";
+    if (term) terms.add(term.toLowerCase());
+  }
+  return [...terms];
+}
+
+/**
+ * Fits segments into a cell. Table cells normally get `fitTableCellText`, but a
+ * highlighted snippet is many text nodes, so the clipping happens here instead.
+ */
+export function truncateSegments(segments: SnippetSegment[], width: number): SnippetSegment[] {
+  return truncateTextSegments(segments, width, (ellipsis) => ({ text: ellipsis, marked: false }));
+}
+
+/** Splits plain text on the matched terms so a full chunk can show the same highlights. */
+export function highlightTerms(text: string, terms: readonly string[]): SnippetSegment[] {
+  const usable = terms.filter((term) => term.length > 0);
+  if (usable.length === 0) return [{ text, marked: false }];
+
+  const pattern = new RegExp(
+    `(${usable.map(escapeRegExp).sort((a, b) => b.length - a.length).join("|")})`,
+    "gi",
+  );
+  const segments: SnippetSegment[] = [];
+  let cursor = 0;
+  for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
+    // A zero-width match would loop forever on the same index.
+    if (match[0].length === 0) {
+      pattern.lastIndex += 1;
+      continue;
+    }
+    pushSegment(segments, text.slice(cursor, match.index), false);
+    pushSegment(segments, match[0], true);
+    cursor = match.index + match[0].length;
+  }
+  pushSegment(segments, text.slice(cursor), false);
+  return segments.filter((segment) => segment.text.length > 0);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/plugins/builtin/scanner/flow-model.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import type { ScannerFlowEvent } from "../../../api-client";
-import { DEFAULT_FLOW_FILTERS, filterFlowEvents, type FlowFilters } from "./flow-model";
+import { DEFAULT_FLOW_FILTERS, filterFlowEvents, flowEmptyState, type FlowFilters } from "./flow-model";
 
 const NOW = Date.parse("2026-03-02T15:00:00Z");
 
@@ -83,3 +83,13 @@ describe("client-side flow filters", () => {
       .toEqual(["today", "in-7"]);
   });
 });
+
+describe("flow empty state", () => {
+  test("blames the filters only when the feed actually sent prints", () => {
+    expect(flowEmptyState(12, 0, "live").title).toBe("12 prints hidden by filters.");
+    expect(flowEmptyState(1, 0, "live").title).toBe("1 print hidden by filters.");
+    // An empty tape is not a filter problem, whatever the filters are set to.
+    expect(flowEmptyState(0, 0, "live").title).toBe("No prints on the tape yet.");
+    expect(flowEmptyState(0, 0, "closed").hint).toContain("next session");
+  });
+});

package/src/plugins/builtin/scanner/flow-model.ts

@@ -1,4 +1,4 @@
-import type { ScannerFlowEvent } from "../../../api-client";
+import type { ScannerFlowEvent, ScannerStatus } from "../../../api-client";
 
 export type FlowMinPremium = "50000" | "250000" | "1000000";
 export type FlowSide = "calls" | "puts" | "both";
@@ -101,6 +101,34 @@ export function filterFlowEvents(
   });
 }
 
+/**
+ * An empty table has two unrelated causes, and blaming the filters for a tape
+ * the server never sent sends people to tune filters that were never the
+ * problem. Say which one happened.
+ */
+export function flowEmptyState(
+  received: number,
+  visible: number,
+  status: ScannerStatus | undefined,
+): { title: string; hint: string } {
+  if (received > visible) {
+    return {
+      title: `${received - visible} ${received - visible === 1 ? "print" : "prints"} hidden by filters.`,
+      hint: "Loosen the premium, expiry, or universe filter.",
+    };
+  }
+  if (status === "closed") {
+    return {
+      title: "No prints on the tape.",
+      hint: "Options are closed; the tape fills again at the next session.",
+    };
+  }
+  return {
+    title: "No prints on the tape yet.",
+    hint: "Large sweeps, blocks, and premium prints appear here as they cross.",
+  };
+}
+
 export function formatFlowPremium(premium: number): string {
   if (premium >= 1e9) return `$${(premium / 1e9).toFixed(1)}B`;
   if (premium >= 1e6) return `$${(premium / 1e6).toFixed(1)}M`;

package/src/plugins/builtin/scanner/flow-pane.tsx

@@ -1,10 +1,11 @@
 import { useCallback, useMemo, useState } from "react";
 import { Box, TextAttributes } from "../../../ui";
 import {
-  Button,
   DataTableView,
+  SelectButton,
   type DataTableCell,
   type DataTableColumn,
+  type SelectButtonOption,
 } from "../../../components";
 import { ScannerWaitingState } from "./waiting";
 import { useAppSelector, usePaneSettingValue } from "../../../state/app/context";
@@ -20,6 +21,7 @@ import {
   DEFAULT_FLOW_FILTERS,
   FLOW_FILTER_OPTIONS,
   filterFlowEvents,
+  flowEmptyState,
   formatFlowExpiry,
   formatFlowPremium,
   formatFlowSide,
@@ -35,28 +37,33 @@ import {
   type FlowVolOi,
 } from "./flow-model";
 
-/** Cycles a select-style pane setting, so every filter is reachable without the settings dialog. */
-function FilterChip<T extends string>({
+/** Every filter is reachable from the pane body, not just the settings dialog. */
+function FlowFilter<T extends string>({
+  id,
   label,
   value,
   options,
+  defaultValue,
   onChange,
 }: {
+  id: string;
   label: string;
   value: T;
-  options: readonly { value: T; label: string; short: string }[];
+  options: readonly SelectButtonOption<T>[];
+  defaultValue: T;
   onChange: (value: T) => void;
 }) {
-  const current = options.find((option) => option.value === value) ?? options[0]!;
   return (
-    <Button
-      label={`${label} ${current.short}`}
-      variant="ghost"
-      onPress={() => {
-        const index = options.findIndex((option) => option.value === value);
-        onChange(options[(index + 1 + options.length) % options.length]!.value);
-      }}
-    />
+    <Box marginRight={2}>
+      <SelectButton
+        label={label}
+        value={value}
+        options={options}
+        emphasized={value !== defaultValue}
+        onChange={onChange}
+        idPrefix={`flow-filter-${id}`}
+      />
+    </Box>
   );
 }
 
@@ -145,6 +152,11 @@ function FlowPane({ focused, width, height }: PaneProps) {
     [feed.payload?.events, filters, watchlist],
   );
 
+  const emptyState = useMemo(
+    () => flowEmptyState(feed.payload?.events.length ?? 0, events.length, feed.payload?.status),
+    [events.length, feed.payload?.events.length, feed.payload?.status],
+  );
+
   useScannerStatusFooter("flow", feed, focused);
 
   const columns = useMemo(() => buildColumns(width), [width]);
@@ -160,13 +172,57 @@ function FlowPane({ focused, width, height }: PaneProps) {
 
   return (
     <Box flexDirection="column" width={width} height={height}>
-      <Box height={1} flexDirection="row" overflow="hidden">
-        <FilterChip label="Prem" value={minPremium} options={FLOW_FILTER_OPTIONS.minPremium} onChange={setMinPremium} />
-        <FilterChip label="Side" value={side} options={FLOW_FILTER_OPTIONS.side} onChange={setSide} />
-        <FilterChip label="Kind" value={kind} options={FLOW_FILTER_OPTIONS.kind} onChange={setKind} />
-        <FilterChip label="V/OI" value={volOi} options={FLOW_FILTER_OPTIONS.volOi} onChange={setVolOi} />
-        <FilterChip label="Exp" value={expiry} options={FLOW_FILTER_OPTIONS.expiry} onChange={setExpiry} />
-        <FilterChip label="Univ" value={universe} options={FLOW_FILTER_OPTIONS.universe} onChange={setUniverse} />
+      {/* paddingLeft matches the table's own left inset, so the filter row and
+          the TIME column start on the same cell. */}
+      <Box height={1} flexDirection="row" overflow="hidden" paddingLeft={1}>
+        <FlowFilter
+          id="premium"
+          label="Prem"
+          value={minPremium}
+          options={FLOW_FILTER_OPTIONS.minPremium}
+          defaultValue={DEFAULT_FLOW_FILTERS.minPremium}
+          onChange={setMinPremium}
+        />
+        <FlowFilter
+          id="side"
+          label="Side"
+          value={side}
+          options={FLOW_FILTER_OPTIONS.side}
+          defaultValue={DEFAULT_FLOW_FILTERS.side}
+          onChange={setSide}
+        />
+        <FlowFilter
+          id="kind"
+          label="Kind"
+          value={kind}
+          options={FLOW_FILTER_OPTIONS.kind}
+          defaultValue={DEFAULT_FLOW_FILTERS.kind}
+          onChange={setKind}
+        />
+        <FlowFilter
+          id="voloi"
+          label="V/OI"
+          value={volOi}
+          options={FLOW_FILTER_OPTIONS.volOi}
+          defaultValue={DEFAULT_FLOW_FILTERS.volOi}
+          onChange={setVolOi}
+        />
+        <FlowFilter
+          id="expiry"
+          label="Exp"
+          value={expiry}
+          options={FLOW_FILTER_OPTIONS.expiry}
+          defaultValue={DEFAULT_FLOW_FILTERS.expiry}
+          onChange={setExpiry}
+        />
+        <FlowFilter
+          id="universe"
+          label="Univ"
+          value={universe}
+          options={FLOW_FILTER_OPTIONS.universe}
+          defaultValue={DEFAULT_FLOW_FILTERS.universe}
+          onChange={setUniverse}
+        />
       </Box>
       <DataTableView<ScannerFlowEvent>
         focused={focused}
@@ -187,8 +243,8 @@ function FlowPane({ focused, width, height }: PaneProps) {
         onActivate={(event) => pinTicker(event.underlying, { floating: true, paneType: TICKER_RESEARCH_PANE_ID })}
         renderCell={(event, column, _index, rowState) => renderCell(event, column, rowState)}
         emptyContent={feed.payload ? undefined : <ScannerWaitingState />}
-        emptyStateTitle="No prints match these filters."
-        emptyStateHint="Loosen the premium, expiry, or universe filter."
+        emptyStateTitle={emptyState.title}
+        emptyStateHint={emptyState.hint}
       />
     </Box>
   );

package/src/plugins/builtin/scanner/index.ts

@@ -72,6 +72,7 @@ export const scannerModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 76, height: 26 },
+      tableExport: true,
       settings: hiloSettings(),
     },
     {
@@ -82,6 +83,7 @@ export const scannerModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 88, height: 28 },
+      tableExport: true,
       settings: flowSettings(),
     },
   ],

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

@@ -355,6 +355,7 @@ export const secModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 100, height: 32 },
+      tableExport: true,
     },
   ],
 

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

@@ -320,6 +320,7 @@ export const sectorsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 82, height: 18 },
+      tableExport: true,
       settings: (context) => ({
         title: "Sector Performance Settings",
         values: {