@meridianlabs/inspect-scout-viewer 0.4.6 → 0.4.7

package/lib/app/transcripts/columnFilter/useColumnFilterPopover.d.ts

@@ -0,0 +1,22 @@
+import { SimpleCondition } from '../../../query/types';
+import { FilterType } from '../../../state/store';
+import { useColumnFilter } from './useColumnFilter';
+export interface UseColumnFilterPopoverParams {
+    columnId: string;
+    filterType: FilterType;
+    condition: SimpleCondition | null;
+    onChange: (condition: SimpleCondition | null) => void;
+}
+export interface UseColumnFilterPopoverReturn {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    operator: ReturnType<typeof useColumnFilter>["operator"];
+    setOperator: ReturnType<typeof useColumnFilter>["setOperator"];
+    operatorOptions: ReturnType<typeof useColumnFilter>["operatorOptions"];
+    value: ReturnType<typeof useColumnFilter>["value"];
+    setValue: ReturnType<typeof useColumnFilter>["setValue"];
+    isValueDisabled: ReturnType<typeof useColumnFilter>["usesValue"];
+    commitAndClose: () => void;
+    cancelAndClose: () => void;
+}
+export declare function useColumnFilterPopover({ columnId, filterType, condition, onChange, }: UseColumnFilterPopoverParams): UseColumnFilterPopoverReturn;

package/lib/app/transcripts/columnSizing/defaultStrategy.d.ts

@@ -0,0 +1,2 @@
+import { SizingStrategy } from './types';
+export declare const defaultStrategy: SizingStrategy;

package/lib/app/transcripts/columnSizing/fitContentStrategy.d.ts

@@ -0,0 +1,2 @@
+import { SizingStrategy } from './types';
+export declare const fitContentStrategy: SizingStrategy;

package/lib/app/transcripts/columnSizing/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './utils';
+export * from './strategies';
+export * from './useColumnSizing';

package/lib/app/transcripts/columnSizing/strategies.d.ts

@@ -0,0 +1,10 @@
+import { ColumnSizingStrategyKey, SizingStrategy } from './types';
+/**
+ * Registry of all available sizing strategies.
+ */
+export declare const sizingStrategies: Record<ColumnSizingStrategyKey, SizingStrategy>;
+/**
+ * Get a sizing strategy by key.
+ * Falls back to default strategy if key is not found.
+ */
+export declare function getSizingStrategy(key: ColumnSizingStrategyKey): SizingStrategy;

package/lib/app/transcripts/columnSizing/types.d.ts

@@ -0,0 +1,47 @@
+import { ColumnSizingState } from '@tanstack/react-table';
+import { TranscriptInfo } from '../../../types/api-types';
+import { TranscriptColumn } from '../columns';
+/**
+ * Size constraints for a column.
+ */
+export interface ColumnSizeConstraints {
+    /** Default size in pixels */
+    size: number;
+    /** Minimum allowed size in pixels */
+    minSize: number;
+    /** Maximum allowed size in pixels */
+    maxSize: number;
+}
+/** Default minimum column size in pixels */
+export declare const DEFAULT_MIN_SIZE = 40;
+/** Default maximum column size in pixels */
+export declare const DEFAULT_MAX_SIZE = 600;
+/** Default column size in pixels when not specified */
+export declare const DEFAULT_SIZE = 150;
+/**
+ * Context provided to sizing strategies for computing column sizes.
+ */
+export interface SizingStrategyContext {
+    /** The table element for DOM measurements (may be null) */
+    tableElement: HTMLTableElement | null;
+    /** Column definitions */
+    columns: TranscriptColumn[];
+    /** Current data for content measurement */
+    data: TranscriptInfo[];
+    /** Pre-computed constraints for each column */
+    constraints: Map<string, ColumnSizeConstraints>;
+}
+/**
+ * Interface for column sizing strategies.
+ * Each strategy computes column sizes differently.
+ */
+export interface SizingStrategy {
+    /** Compute sizes for all columns */
+    computeSizes(context: SizingStrategyContext): ColumnSizingState;
+}
+/**
+ * Available sizing strategy keys.
+ * - "default": Uses the column's defined `size` property
+ * - "fit-content": Measures content and sizes columns to fit within min/max constraints
+ */
+export type ColumnSizingStrategyKey = "default" | "fit-content";

package/lib/app/transcripts/columnSizing/useColumnSizing.d.ts

@@ -0,0 +1,34 @@
+import { ColumnSizingState, OnChangeFn } from '@tanstack/react-table';
+import { TranscriptInfo } from '../../../types/api-types';
+import { TranscriptColumn } from '../columns';
+import { ColumnSizingStrategyKey } from './types';
+interface UseColumnSizingOptions {
+    /** Column definitions */
+    columns: TranscriptColumn[];
+    /** Reference to the table element for DOM measurement */
+    tableRef: React.RefObject<HTMLTableElement | null>;
+    /** Current data for content measurement */
+    data: TranscriptInfo[];
+}
+interface UseColumnSizingResult {
+    /** Current column sizing state */
+    columnSizing: ColumnSizingState;
+    /** Handler for column sizing changes with min/max enforcement */
+    handleColumnSizingChange: OnChangeFn<ColumnSizingState>;
+    /** Current sizing strategy key */
+    sizingStrategy: ColumnSizingStrategyKey;
+    /** Set the sizing strategy */
+    setSizingStrategy: (strategy: ColumnSizingStrategyKey) => void;
+    /** Apply auto-sizing based on current strategy (preserves manually resized columns) */
+    applyAutoSizing: () => void;
+    /** Reset a single column to its auto-calculated size */
+    resetColumnSize: (columnId: string) => void;
+    /** Reset all column sizing and clear manual resize tracking */
+    clearColumnSizing: () => void;
+}
+/**
+ * Hook for managing column sizing with min/max constraints and auto-sizing.
+ * Manually resized columns are preserved during auto-sizing operations.
+ */
+export declare function useColumnSizing({ columns, tableRef, data, }: UseColumnSizingOptions): UseColumnSizingResult;
+export {};

package/lib/app/transcripts/columnSizing/utils.d.ts

@@ -0,0 +1,14 @@
+import { TranscriptColumn } from '../columns';
+import { ColumnSizeConstraints } from './types';
+/**
+ * Extract size constraints from column definitions.
+ */
+export declare function getColumnConstraints(columns: TranscriptColumn[]): Map<string, ColumnSizeConstraints>;
+/**
+ * Clamp a size value to min/max constraints.
+ */
+export declare function clampSize(size: number, constraints: ColumnSizeConstraints): number;
+/**
+ * Get the column ID from a column definition.
+ */
+export declare function getColumnId(column: TranscriptColumn): string;

package/lib/app/transcripts/columns.d.ts

@@ -0,0 +1,30 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { FilterType } from '../../state/store';
+import { TranscriptInfo } from '../../types/api-types';
+export type TranscriptColumn = ColumnDef<TranscriptInfo> & {
+    meta?: {
+        align?: "left" | "center" | "right";
+        filterable?: boolean;
+        filterType?: FilterType;
+    };
+    /** Returns string for tooltip display */
+    titleValue?: (value: unknown) => string;
+    /** Returns string representation for column width measurement. Return null to skip content measurement. */
+    textValue?: (value: unknown) => string | null;
+    /** Minimum column width in pixels */
+    minSize?: number;
+    /** Maximum column width in pixels */
+    maxSize?: number;
+};
+export declare const DEFAULT_COLUMN_ORDER: Array<keyof TranscriptInfo>;
+export declare const DEFAULT_VISIBLE_COLUMNS: Array<keyof TranscriptInfo>;
+/**
+ * Get columns for the TranscriptsGrid.
+ * @param visibleColumnKeys - Optional list of column keys to display. If not provided, returns all columns in default order.
+ * @returns Array of column definitions in the order specified or default order.
+ */
+export declare function getTranscriptColumns(visibleColumnKeys?: Array<keyof TranscriptInfo>): TranscriptColumn[];
+/**
+ * Extract title value for tooltip from a cell.
+ */
+export declare function getCellTitleValue(cell: any, columnDef: TranscriptColumn): string;

package/lib/app/transcripts/constants.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Infinite Scroll Tuning
+ *
+ * Goal: user never hits bottom while waiting for next page.
+ *
+ * Formula: threshold >= scroll_speed × fetch_duration
+ *
+ * Assumptions:
+ *   row_height = 29px
+ *   fetch_duration = 300-1000ms (variable with fixed overhead)
+ *   max_scroll_speed = 1500px/s (typical fast scroller)
+ *
+ * Check at typical speed (1500px/s):
+ *   runway_time = 2000px / 1500px/s = 1333ms
+ *   worst_case_fetch = 1000ms
+ *   margin = 333ms ✓
+ *
+ * Check at extreme speed (5000px/s):
+ *   runway_time = 2000px / 5000px/s = 400ms
+ *   median_fetch = ~350ms
+ *   margin = 50ms (tight but ok) ✓
+ *
+ * Why large pageSize? Fetch duration is mostly fixed overhead, so larger
+ * pages = fewer fetches = fewer stall opportunities. 500 rows gives ~9.7s
+ * of scrolling per page at 1500px/s.
+ *
+ * Note: If threshold > pageSize_px, the next page is prefetched immediately
+ * after the current page loads. This is fine for maximum smoothness.
+ */
+export declare const TRANSCRIPTS_INFINITE_SCROLL_CONFIG: {
+    /** Number of rows to fetch per page (500 rows = 14,500px at 29px/row) */
+    readonly pageSize: 500;
+    /** Distance from bottom (in px) at which to trigger fetch (~69 rows) */
+    readonly threshold: 2000;
+};

package/lib/components/AutocompleteInput.d.ts

@@ -0,0 +1,17 @@
+import { FC } from 'react';
+export interface AutocompleteInputProps {
+    id: string;
+    value: string;
+    onChange: (value: string) => void;
+    onCommit?: () => void;
+    onCancel?: () => void;
+    disabled?: boolean;
+    placeholder?: string;
+    suggestions: Array<string | number | boolean | null>;
+    autoFocus?: boolean;
+    maxSuggestions?: number;
+    charactersBeforeSuggesting?: number;
+    maxSuggestionWidth?: number;
+    className?: string;
+}
+export declare const AutocompleteInput: FC<AutocompleteInputProps>;

package/lib/components/Modal.d.ts

@@ -0,0 +1,10 @@
+import { FC, ReactNode } from 'react';
+interface ModalProps {
+    show: boolean;
+    onHide: () => void;
+    title: string;
+    children: ReactNode;
+    footer?: ReactNode;
+}
+export declare const Modal: FC<ModalProps>;
+export {};

package/lib/components/ToolButton.d.ts

@@ -1,6 +1,6 @@
 import { ButtonHTMLAttributes, ReactNode } from 'react';
 interface ToolButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    label: string | ReactNode;
+    label?: string | ReactNode;
     classes?: string;
     icon?: string;
     latched?: boolean;

package/lib/components/ToolDropdownButton.d.ts

@@ -3,6 +3,9 @@ interface ToolDropdownButtonProps extends ButtonHTMLAttributes<HTMLButtonElement
     label: string | ReactNode;
     icon?: string;
     items: Record<string, () => void>;
+    dropdownAlign?: "left" | "right";
+    dropdownClassName?: string | string[];
+    subtle?: boolean;
 }
 export declare const ToolDropdownButton: import('react').ForwardRefExoticComponent<ToolDropdownButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
 export {};

package/lib/components/icons.d.ts

@@ -95,6 +95,7 @@ export declare const ApplicationIcons: {
     pendingTask: string;
     pendingTaskSubtle: string;
     play: string;
+    "play-circle": string;
     previous: string;
     refresh: string;
     refuse: string;
@@ -126,6 +127,7 @@ export declare const ApplicationIcons: {
     subtask: string;
     success: string;
     successSubtle: string;
+    threeDots: string;
     transcript: string;
     tree: {
         open: string;
@@ -135,4 +137,5 @@ export declare const ApplicationIcons: {
     usage: string;
     wrap: string;
     x: string;
+    xLarge: string;
 };

package/lib/components/transcript/TranscriptViewNodes.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { EventNode, EventType } from './types';
+interface TranscriptViewNodesProps {
+    id: string;
+    eventNodes: EventNode[];
+    defaultCollapsedIds: Record<string, boolean>;
+    nodeFilter?: (node: EventNode<EventType>[]) => EventNode<EventType>[];
+    scrollRef?: React.RefObject<HTMLDivElement | null>;
+    initialEventId?: string | null;
+    className?: string | string[];
+}
+export declare const TranscriptViewNodes: FC<TranscriptViewNodesProps>;
+export {};

package/lib/index.d.ts

@@ -1,4 +1,6 @@
 export { App } from './App';
 export { apiScoutServer } from './api/api-scout-server';
+export { apiScoutServerV1 } from './api/api-scout-server-v1';
+export type { HeaderProvider } from './api/api-scout-server-v1';
 export type { ScanApi } from './api/api.ts';
 export { ApiProvider, StoreProvider, createStore } from './state/store';