The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
/**
* A data grid with IDEA's result-view extras, shared by console results and
* the table editor: the header's local filter (values of the loaded rows),
* client-side sorting when the caller does not sort on the server, and the
* Record / Value / Aggregates side panel following the selection.
*/
import { writeClipboardText } from "@/platform/clipboard";
import { useMemo, useRef, useState, type KeyboardEvent, type RefObject } from "react";
import clsx from "clsx";
import { Button, Checkbox, Icon, IconButton, Input, Popup, SearchField, Select, Tabs, T, type MenuItem } from "@/ui";
import { EXPORT_FORMATS, exportData, type ExportData, type ExportFormat } from "./export";
import { Grid, type CopyFormat, type GridColumn, type GridProps, type GridRange } from "./Grid";
import type { Cell } from "./model";
import {
aggregates,
cellMatcher,
distinctValues,
findCells,
formatNumber,
rowMatches,
toggleFilterValue,
visibleRows,
type LocalFilter,
type LocalSort,
type SearchOptions,
} from "./resultView";
import { openDialog } from "./store";
import { hasLineBreak } from "./cellPreview";
import {
initialJsonText,
isJsonColumn,
isJsonValue,
jsonErrorOf,
JSON_INLINE_LIMIT,
type JsonError,
} from "./jsonValue";
import { JsonValueEditor, JsonValueWindow, type JsonEditorApi } from "./JsonValueEditor";
import styles from "./Database.module.css";
import { tx } from "@/platform/i18n";
export type DataPanel = "record" | "value" | "aggregates";
/** The Export button's menu: the Export Data dialog (with the toolbar's extractor), then IDEA's quick Copy as… extractors. */
export function exportMenu(data: ExportData, source: string, format?: ExportFormat): MenuItem[] {
return [
{ label: "Export Data…", icon: "export", run: () => openDialog({ kind: "export", data, source, format }) },
{ kind: "separator" },
...EXPORT_FORMATS.map((f): MenuItem => ({
label: tx`Copy as ${f.label}`,
icon: "copy",
run: () => void writeClipboardText(exportData(f.id, data)),
})),
];
}
/** IDEA's extractor drop-down at the right of a data toolbar ("CSV ▾"). */
export function ExtractorSelect({ value, onChange }: { value: ExportFormat; onChange: (f: ExportFormat) => void }) {
return (
<Select
aria-label="Data extractor"
value={value}
options={EXPORT_FORMATS.map((f) => ({ value: f.id, label: f.label }))}
onChange={(v) => onChange(v as ExportFormat)}
/>
);
}
/** The copy format plain ⌘C uses under a toolbar extractor (cell copies stay cell-shaped). */
export const copyFormatOf = (extractor: ExportFormat): CopyFormat =>
extractor === "csv" ? "csv" : extractor === "onerow" ? "onerow" : "tsv";
/** The Record / Value / Aggregates panel's toggle (IDEA's "Show Value Editor"). */
export function PanelToggle({ panel, onChange }: { panel: DataPanel | null; onChange: (p: DataPanel | null) => void }) {
return (
<IconButton
icon="split"
title={panel ? "Hide Record / Value / Aggregates" : "Show Record / Value / Aggregates"}
aria-pressed={!!panel}
onClick={() => onChange(panel ? null : "record")}
/>
);
}
/** Local filter and sort of the column set `key`. */
interface Shaping {
key: string;
filter: LocalFilter;
sort: LocalSort | null;
}
export interface DataViewProps extends Pick<
GridProps,
"rowState" | "isModified" | "editable" | "onEdit" | "onResetCell" | "driver" | "sort" | "onSort" | "rowMenu"
> {
columns: readonly GridColumn[];
rowCount: number;
value: (row: number, col: number) => Cell;
/** Rows from here on (the table editor's added rows) are never filtered or sorted. */
fixedRows?: number;
firstRowNumber?: number;
/** The side panel shown (`null`: hidden). */
panel: DataPanel | null;
onPanelChange: (panel: DataPanel | null) => void;
/** Plain ⌘C's copy format (the toolbar's extractor; TSV by default). */
copyFormat?: CopyFormat;
/** The search bar is shown (the toolbar's search button, ⌘F in the grid). */
searchOpen?: boolean;
onSearchOpenChange?: (open: boolean) => void;
revealColumn?: GridProps["revealColumn"];
"aria-label"?: string;
}
const NO_SEARCH: SearchOptions = { caseSensitive: false, wholeWord: false, regex: false };
interface SearchState {
query: string;
options: SearchOptions;
/** Show only the rows with a match (IDEA's Filter rows). */
filterRows: boolean;
/** Index of the current match. */
current: number;
}
export function DataView(props: DataViewProps) {
const { columns, rowCount, value, fixedRows = rowCount, panel, onPanelChange } = props;
const columnKey = columns.map((c) => c.name).join("\u0000");
// Filter and sort belong to a column set: another one (a re-run query) starts without them.
const [shaping, setShaping] = useState<Shaping>({ key: columnKey, filter: new Map(), sort: null });
const current: Shaping = shaping.key === columnKey ? shaping : { key: columnKey, filter: new Map(), sort: null };
const { filter, sort: localSort } = current;
const setFilter = (f: LocalFilter | ((prev: LocalFilter) => LocalFilter)) =>
setShaping({ ...current, filter: typeof f === "function" ? f(current.filter) : f });
const setLocalSort = (s: (prev: LocalSort | null) => LocalSort | null) =>
setShaping({ ...current, sort: s(current.sort) });
const [range, setRange] = useState<GridRange | null>(null);
const [filterAt, setFilterAt] = useState<{ col: number; anchor: HTMLElement } | null>(null);
const local = !props.onSort;
// Display row → loaded row; `null` keeps the identity (no filter, no local sort).
const shaped = useMemo(
() =>
filter.size || (local && localSort)
? visibleRows(rowCount, value, filter, local ? localSort : null, fixedRows)
: null,
[rowCount, value, filter, local, localSort, fixedRows],
);
// Search covers the loaded rows only (the page shown).
const { searchOpen = false, onSearchOpenChange } = props;
const [search, setSearch] = useState<SearchState>({ query: "", options: NO_SEARCH, filterRows: false, current: 0 });
const searchInput = useRef<HTMLInputElement>(null);
const matcher = useMemo(
() => (searchOpen ? cellMatcher(search.query, search.options) : null),
[searchOpen, search.query, search.options],
);
const test = typeof matcher === "function" ? matcher : null;
const order = useMemo(() => {
if (!test || !search.filterRows) return shaped;
const base = shaped ?? Array.from({ length: rowCount }, (_, i) => i);
return base.filter((r) => rowMatches(r, columns.length, value, test));
}, [shaped, test, search.filterRows, rowCount, columns.length, value]);
const at = (r: number) => (order ? order[r]! : r);
const shown = order ? order.length : rowCount;
const matches = useMemo(
() => (test ? findCells(order ?? Array.from({ length: rowCount }, (_, i) => i), columns.length, value, test) : []),
[test, order, rowCount, columns.length, value],
);
const matchSet = useMemo(() => new Set(matches.map((m) => `${m.row}:${m.col}`)), [matches]);
const currentMatch = matches.length ? matches[Math.min(search.current, matches.length - 1)]! : null;
const step = (by: number) =>
matches.length &&
setSearch((s) => ({
...s,
current: (Math.min(s.current, matches.length - 1) + by + matches.length) % matches.length,
}));
const openSearch = () => {
onSearchOpenChange?.(true);
requestAnimationFrame(() => {
searchInput.current?.focus();
searchInput.current?.select();
});
};
const onSort = local
? (column: string) => {
const col = columns.findIndex((c) => c.name === column);
// asc → desc → none, like the table editor's.
setLocalSort((s) =>
s?.column !== col ? { column: col, descending: false } : !s.descending ? { ...s, descending: true } : null,
);
}
: props.onSort;
const sort = local
? localSort
? [{ column: columns[localSort.column]?.name ?? "", descending: localSort.descending }]
: []
: props.sort;
return (
<div className={styles.dataView}>
<div className={styles.dataMain}>
{searchOpen && (
<GridSearchBar
inputRef={searchInput}
search={search}
onChange={(p) => setSearch((s) => ({ ...s, ...p, current: 0 }))}
count={matches.length}
active={currentMatch ? Math.min(search.current, matches.length - 1) : -1}
invalid={matcher === "invalid"}
onNext={() => step(1)}
onPrevious={() => step(-1)}
onClose={() => onSearchOpenChange?.(false)}
/>
)}
<div className={clsx(styles.fill, styles.gridHost)}>
<Grid
isMatch={test ? (r, c) => matchSet.has(`${r}:${c}`) : undefined}
currentMatch={currentMatch}
onFind={onSearchOpenChange && openSearch}
revealColumn={props.revealColumn}
aria-label={props["aria-label"]}
columns={columns}
rowCount={shown}
value={(r, c) => value(at(r), c)}
rowState={props.rowState && ((r) => props.rowState!(at(r)))}
isModified={props.isModified && ((r, c) => props.isModified!(at(r), c))}
editable={props.editable}
onResetCell={props.onResetCell && ((r, c) => props.onResetCell!(at(r), c))}
onEdit={props.onEdit && ((r, c, v) => props.onEdit!(at(r), c, v))}
driver={props.driver}
sort={sort}
onSort={onSort}
rowMenu={props.rowMenu && ((rows) => props.rowMenu!(rows.map(at)))}
rowNumber={(r) => (props.firstRowNumber ?? 1) + at(r)}
copyFormat={props.copyFormat}
onSelectionChange={setRange}
onFilter={(col, anchor) => setFilterAt({ col, anchor })}
filtered={(col) => filter.has(col)}
/>
{filter.size > 0 && (
<div className={styles.filterPill} role="status">
{tx`${shown} of ${rowCount} rows`}
<button type="button" className={styles.filterPillClear} onClick={() => setFilter(new Map())}>
<T>Clear local filter</T>
</button>
</div>
)}
</div>
</div>
{filterAt && (
<FilterPopup
anchor={filterAt.anchor}
column={columns[filterAt.col]?.name ?? ""}
values={distinctValues(Math.min(rowCount, fixedRows), value, filterAt.col)}
checked={filter.get(filterAt.col) ?? null}
onToggle={(all, v, on) => setFilter((f) => toggleFilterValue(f, filterAt.col, all, v, on))}
onClear={() =>
setFilter((f) => {
const next = new Map(f);
next.delete(filterAt.col);
return next;
})
}
onClearAll={() => setFilter(new Map())}
onClose={() => setFilterAt(null)}
/>
)}
{panel && (
<SidePanel
panel={panel}
onPanelChange={onPanelChange}
columns={columns}
range={range}
value={(r, c) => value(at(r), c)}
editable={!!props.editable && !!props.onEdit && !!range && props.rowState?.(at(range.lead.row)) !== "deleted"}
onEdit={(r, c, v) => props.onEdit?.(at(r), c, v)}
/>
)}
</div>
);
}
/** IDEA's search bar above the grid: Match Case / Words / Regex, n/m, previous / next, Filter rows. */
function GridSearchBar(props: {
inputRef: RefObject<HTMLInputElement | null>;
search: SearchState;
onChange: (patch: Partial<Omit<SearchState, "current">>) => void;
count: number;
/** Zero-based current match; -1 when there is none. */
active: number;
invalid: boolean;
onNext: () => void;
onPrevious: () => void;
onClose: () => void;
}) {
const { search, count, invalid, active, inputRef, onChange, onNext, onPrevious, onClose } = props;
const none = !!search.query && !invalid && count === 0;
const toggle = (key: keyof SearchOptions) =>
onChange({ options: { ...search.options, [key]: !search.options[key] } });
const onKeyDown = (e: KeyboardEvent<HTMLDivElement>) => {
if (e.key === "Escape") {
e.preventDefault();
e.stopPropagation();
onClose();
} else if (e.key === "Enter" || e.key === "F3") {
e.preventDefault();
if (e.shiftKey) onPrevious();
else onNext();
} else if (e.altKey && !e.metaKey && !e.ctrlKey) {
const key =
e.code === "KeyC" ? "caseSensitive" : e.code === "KeyW" ? "wholeWord" : e.code === "KeyX" ? "regex" : null;
if (key) {
e.preventDefault();
toggle(key);
}
}
};
return (
<div className={styles.gridSearch} role="search" aria-label={tx("Search in results")} onKeyDown={onKeyDown}>
<SearchField
ref={inputRef}
autoFocus
className={styles.gridSearchField}
value={search.query}
onChange={(query) => onChange({ query })}
placeholder="Search in results"
aria-label="Search in results"
invalid={invalid || none}
toggles={[
{
id: "case",
icon: "case",
title: "Match Case",
shortcut: "⌥C",
pressed: search.options.caseSensitive,
onToggle: () => toggle("caseSensitive"),
},
{
id: "word",
icon: "word",
title: "Words",
shortcut: "⌥W",
pressed: search.options.wholeWord,
onToggle: () => toggle("wholeWord"),
},
{
id: "regex",
icon: "regex",
title: "Regex",
shortcut: "⌥X",
pressed: search.options.regex,
onToggle: () => toggle("regex"),
},
]}
/>
<span className={clsx(styles.gridSearchCount, (invalid || none) && styles.gridSearchNone)} aria-live="polite">
{invalid ? tx("Bad regex") : !search.query ? "" : count === 0 ? tx("0 results") : `${active + 1}/${count}`}
</span>
<IconButton
icon="arrow-up"
title="Previous Occurrence"
shortcut="⇧↵"
size="small"
disabled={count === 0}
onClick={onPrevious}
/>
<IconButton
icon="arrow-down"
title="Next Occurrence"
shortcut="↵"
size="small"
disabled={count === 0}
onClick={onNext}
/>
<Checkbox
checked={search.filterRows}
onChange={(filterRows) => onChange({ filterRows })}
label={tx("Filter rows")}
/>
<span className={styles.spacer} />
<IconButton icon="close" title="Close" shortcut="⎋" size="small" onClick={onClose} />
</div>
);
}
function FilterPopup(props: {
anchor: HTMLElement;
column: string;
values: Array<{ value: Cell; count: number }>;
checked: ReadonlySet<Cell> | null;
onToggle: (all: Cell[], v: Cell, on: boolean) => void;
onClear: () => void;
onClearAll: () => void;
onClose: () => void;
}) {
const [query, setQuery] = useState("");
const all = props.values.map((v) => v.value);
const q = query.trim().toLowerCase();
const list = q ? props.values.filter((v) => (v.value ?? "<null>").toLowerCase().includes(q)) : props.values;
return (
<Popup
open
anchor={props.anchor}
placement="bottom-start"
onClose={props.onClose}
aria-label={tx`Local filter of ${props.column}`}
className={styles.filterPopup}
trapFocus
>
<Input
autoFocus
aria-label="Search values"
placeholder={tx`Values of ${props.column}`}
value={query}
onChange={(e) => setQuery(e.target.value)}
/>
<div className={styles.filterValues} role="group" aria-label={tx("Values")}>
{list.map(({ value: v, count }) => (
<div key={v ?? "\u0000null"} className={styles.filterValue}>
<Checkbox
checked={props.checked ? props.checked.has(v) : true}
onChange={(on) => props.onToggle(all, v, on)}
label={v === null ? <span className={styles.null}><null></span> : v}
/>
<span className={styles.filterCount}>{count}</span>
</div>
))}
{!list.length && (
<div className={styles.filterEmpty}>
<T>No matching values</T>
</div>
)}
</div>
<div className={styles.filterButtons}>
<Button size="small" disabled={!props.checked} onClick={props.onClear}>
<T>Clear Filter</T>
</Button>
<Button size="small" onClick={props.onClearAll}>
<T>Clear Local Filter For All Columns</T>
</Button>
</div>
</Popup>
);
}
const AGGREGATE_ROWS: ReadonlyArray<[label: string, key: keyof ReturnType<typeof aggregates>]> = [
["Count", "count"],
["Distinct", "distinct"],
["Nulls", "nulls"],
["Sum", "sum"],
["Avg", "avg"],
["Median", "median"],
["Min", "min"],
["Max", "max"],
];
function SidePanel(props: {
panel: DataPanel;
onPanelChange: (p: DataPanel | null) => void;
columns: readonly GridColumn[];
range: GridRange | null;
value: (row: number, col: number) => Cell;
editable: boolean;
onEdit: (row: number, col: number, v: Cell) => void;
}) {
const { range, value, columns } = props;
return (
<aside className={styles.sidePanel} aria-label={tx("Value panel")}>
<div className={styles.sidePanelHead}>
<Tabs
variant="compact"
aria-label="Value panel"
activeId={props.panel}
onSelect={(id) => props.onPanelChange(id as DataPanel)}
items={[
{ id: "record", label: "Record" },
{ id: "value", label: "Value" },
{ id: "aggregates", label: "Aggregates" },
]}
/>
<span className={styles.spacer} />
<IconButton icon="close" title="Hide" size="small" onClick={() => props.onPanelChange(null)} />
</div>
<div className={styles.sidePanelBody}>
{!range ? (
<div className={styles.filterEmpty}>
<T>Select a cell</T>
</div>
) : props.panel === "record" ? (
<RecordView key={range.lead.row} {...props} row={range.lead.row} />
) : props.panel === "value" ? (
<ValueView
// A committed value (here or in the grid) starts the editor over.
key={`${range.lead.row}:${range.lead.col}\u0000${value(range.lead.row, range.lead.col) ?? "\u0001"}`}
column={columns[range.lead.col] ?? { name: "", type: "" }}
cell={value(range.lead.row, range.lead.col)}
editable={props.editable}
onCommit={(v) => props.onEdit(range.lead.row, range.lead.col, v)}
/>
) : (
<AggregatesView range={range} value={value} />
)}
</div>
</aside>
);
}
/** One field per column of the lead row; edits apply on Enter / leaving the field. */
function RecordView(props: {
columns: readonly GridColumn[];
row: number;
value: (row: number, col: number) => Cell;
editable: boolean;
onEdit: (row: number, col: number, v: Cell) => void;
}) {
return (
<div className={styles.recordFields}>
{props.columns.map((c, i) => (
<RecordField
// A new value (another row, an edit elsewhere) starts the field over.
key={`${c.name}\u0000${props.value(props.row, i) ?? "\u0001"}`}
column={c}
cell={props.value(props.row, i)}
editable={props.editable}
onCommit={(v) => props.onEdit(props.row, i, v)}
/>
))}
</div>
);
}
function RecordField(props: { column: GridColumn; cell: Cell; editable: boolean; onCommit: (v: Cell) => void }) {
const [text, setText] = useState(props.cell ?? "");
const commit = () => {
if (text !== (props.cell ?? "") || (props.cell === null && text !== "")) props.onCommit(text);
};
const c = props.column;
return (
<label className={styles.recordField}>
<span className={styles.recordLabel}>
<Icon name={c.primaryKey ? "db-column-key" : c.foreignKey ? "db-column-fk" : "db-column"} size={16} />
{c.name}
{c.type && c.type !== "NULL" && <span className={styles.treeType}>{c.type}</span>}
</span>
{hasLineBreak(props.cell ?? "") ? (
// A single-line field would drop the line breaks on the first edit.
<textarea
className={styles.recordText}
rows={Math.min(8, (props.cell ?? "").split(/\r\n|\r|\n/).length)}
value={text}
readOnly={!props.editable}
spellCheck={false}
onChange={(e) => setText(e.target.value)}
onBlur={commit}
/>
) : (
<Input
mono
value={text}
readOnly={!props.editable}
placeholder={props.cell === null ? "<null>" : undefined}
onChange={(e) => setText(e.target.value)}
onBlur={commit}
onKeyDown={(e) => {
if (e.key === "Enter") commit();
}}
/>
)}
</label>
);
}
/** The Value panel's editor: plain text, or the JSON code editor for JSON cells (#2333). */
function ValueView(props: { column: GridColumn; cell: Cell; editable: boolean; onCommit: (v: Cell) => void }) {
const name = props.column.name;
const [json] = useState(() => isJsonValue(props.column.type, props.cell));
const validate = isJsonColumn(props.column.type);
// JSON opens pretty-printed; the panel applies what the editor shows.
const [initial] = useState(() => (json ? initialJsonText(props.cell ?? "") : (props.cell ?? "")));
const [text, setText] = useState(initial);
const [error, setError] = useState<JsonError | null>(() =>
props.cell !== null && validate && initial.length <= JSON_INLINE_LIMIT ? jsonErrorOf(initial) : null,
);
const [pending, setPending] = useState(json && initial.length > JSON_INLINE_LIMIT);
const editor = useRef<JsonEditorApi | null>(null);
const dirty = text !== initial;
const commit = () => {
if (props.editable && dirty && !error && !pending) props.onCommit(text);
};
const [windowOpen, setWindowOpen] = useState(false);
return (
<div className={styles.valueView}>
{json ? (
<>
<JsonValueEditor
initial={initial}
validate={validate}
emptyIsNull={props.cell === null}
readOnly={!props.editable}
ariaLabel={tx`Value of ${name}`}
onChange={(t, e, busy) => {
setText(t);
setError(e);
setPending(busy);
}}
onReady={(api) => (editor.current = api)}
onSubmit={commit}
onOpenWindow={() => setWindowOpen(true)}
/>
{error && (
<div className={styles.valueError} role="status">
{error.message}
</div>
)}
<div className={styles.filterButtons}>
<Button
size="small"
disabled={!props.editable || !!error || pending}
onClick={() => editor.current?.reformat()}
>
<T>Reformat</T>
</Button>
<Button size="small" onClick={() => setWindowOpen(true)}>
<T>Open in Window</T>
</Button>
</div>
</>
) : (
<textarea
className={styles.valueText}
aria-label={tx`Value of ${name}`}
value={text}
readOnly={!props.editable}
placeholder={props.cell === null ? "<null>" : undefined}
spellCheck={false}
onChange={(e) => setText(e.target.value)}
onKeyDown={(e) => {
if (e.key === "Enter" && (e.metaKey || e.ctrlKey) && dirty) props.onCommit(text);
}}
/>
)}
{props.editable && (
<div className={styles.filterButtons}>
<Button size="small" disabled={!dirty || !!error || pending} onClick={commit}>
<T>Apply</T>
</Button>
<Button
size="small"
onClick={() => {
if (props.cell !== null) props.onCommit(null);
}}
>
<T>Set NULL</T>
</Button>
</div>
)}
{windowOpen && (
<JsonValueWindow
title={tx`Value of ${name}`}
initial={text}
baseline={initial}
validate={validate}
emptyIsNull={props.cell === null}
readOnly={!props.editable}
onClose={() => setWindowOpen(false)}
onApply={(t) => {
props.onCommit(t);
setWindowOpen(false);
}}
onSetNull={() => {
props.onCommit(null);
setWindowOpen(false);
}}
/>
)}
</div>
);
}
function AggregatesView({ range, value }: { range: GridRange; value: (row: number, col: number) => Cell }) {
const cells: Cell[] = [];
for (let r = range.top; r <= range.bottom; r++)
for (let c = range.left; c <= range.right; c++) cells.push(value(r, c));
const a = aggregates(cells);
const show = (v: number | string | null) => (v === null ? "—" : typeof v === "number" ? formatNumber(v) : v);
return (
<table className={styles.aggregates}>
<tbody>
{AGGREGATE_ROWS.map(([label, key]) => (
<tr key={key}>
<th scope="row">{label}</th>
<td>{show(a[key])}</td>
</tr>
))}
</tbody>
</table>
);
}