@calliopelabs/ui 0.14.0 → 0.18.0

package/dist/workbench/FileList.js

@@ -0,0 +1,160 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ArrowDownIcon, ArrowUpIcon } from "lucide-react";
+import * as React from "react";
+import { cn } from "../lib/cn.js";
+import { useUI } from "../provider/UIProvider.js";
+import { startFileDrag, useFileDrop } from "./dnd.js";
+import { FileIcon } from "./FileIcon.js";
+import { formatBytes } from "./model.js";
+import { modeOf, useSelectionModel } from "./selection.js";
+import { typeahead } from "./typeahead.js";
+const COLUMNS = ["name", "size", "modified"];
+const WIDTH = {
+    name: "min-w-0 flex-1",
+    size: "w-20 shrink-0 justify-end text-right",
+    modified: "hidden w-44 shrink-0 @lg:flex",
+};
+const defaultFormat = (value) => {
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime())
+        ? ""
+        : date.toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" });
+};
+/**
+ * A directory as a sortable table, on the WAI-ARIA grid pattern: one tab
+ * stop, arrows move between cells, selection follows the focus (Ctrl or Cmd
+ * with an arrow moves without selecting, Shift extends), Home and End, Page
+ * Up and Down, Enter opens, Cmd/Ctrl+A selects all, Escape clears, and
+ * typing finds a name. Rows drag onto folders.
+ */
+export function FileList({ label, items, selection, onSelectionChange, onOpen, onDelete, onRename, onMove, sort, onSortChange, formatDate = defaultFormat, className, }) {
+    const { messages } = useUI();
+    const t = messages.workbench;
+    const order = React.useMemo(() => items.map((i) => i.path), [items]);
+    const model = useSelectionModel(order, selection, onSelectionChange);
+    // Focus: row -1 is the header; columns index COLUMNS.
+    const [focus, setFocus] = React.useState({ row: 0, col: 0 });
+    const cells = React.useRef(new Map());
+    const pending = React.useRef(false);
+    const search = React.useRef({ text: "", at: 0 });
+    const headerRow = onSortChange ? -1 : 0;
+    const row = Math.min(Math.max(focus.row, headerRow), items.length - 1);
+    const col = focus.col;
+    React.useLayoutEffect(() => {
+        if (!pending.current)
+            return;
+        pending.current = false;
+        cells.current.get(`${row}:${col}`)?.focus();
+    });
+    const move = (next) => {
+        pending.current = true;
+        setFocus({
+            row: Math.min(Math.max(next.row, headerRow), items.length - 1),
+            col: Math.min(Math.max(next.col, 0), COLUMNS.length - 1),
+        });
+    };
+    const selected = () => items.filter((i) => selection.has(i.path));
+    const onKeyDown = (event) => {
+        const meta = event.metaKey || event.ctrlKey;
+        const go = (target) => {
+            event.preventDefault();
+            const clamped = Math.min(Math.max(target, headerRow), items.length - 1);
+            move({ row: clamped, col });
+            const item = items[clamped];
+            if (item && !meta)
+                model.select(item.path, event.shiftKey ? "range" : "replace");
+        };
+        switch (event.key) {
+            case "ArrowDown":
+                return go(row + 1);
+            case "ArrowUp":
+                return go(row - 1);
+            case "PageDown":
+                return go(row + 10);
+            case "PageUp":
+                return go(row - 10);
+            case "ArrowRight":
+                event.preventDefault();
+                return move({ row, col: col + 1 });
+            case "ArrowLeft":
+                event.preventDefault();
+                return move({ row, col: col - 1 });
+            case "Home":
+                if (meta)
+                    return go(0);
+                event.preventDefault();
+                return move({ row, col: 0 });
+            case "End":
+                if (meta)
+                    return go(items.length - 1);
+                event.preventDefault();
+                return move({ row, col: COLUMNS.length - 1 });
+        }
+        if (row < 0)
+            return;
+        const item = items[row];
+        if (!item)
+            return;
+        if (event.key === "Enter") {
+            event.preventDefault();
+            onOpen(item);
+        }
+        else if (event.key === " ") {
+            event.preventDefault();
+            model.select(item.path, meta ? "toggle" : event.shiftKey ? "range" : "replace");
+        }
+        else if (meta && event.key.toLowerCase() === "a") {
+            event.preventDefault();
+            model.selectAll();
+        }
+        else if (event.key === "Escape" && selection.size > 0) {
+            event.preventDefault();
+            model.clear();
+        }
+        else if (onDelete && (event.key === "Delete" || (meta && event.key === "Backspace"))) {
+            const targets = selected();
+            if (targets.length) {
+                event.preventDefault();
+                onDelete(targets);
+            }
+        }
+        else if (onRename && event.key === "F2") {
+            event.preventDefault();
+            onRename(item);
+        }
+        else {
+            const next = typeahead(search.current, event, items.map((i) => i.name), row);
+            if (next !== null)
+                go(next);
+        }
+    };
+    const cellRef = (r, c) => (el) => {
+        if (el)
+            cells.current.set(`${r}:${c}`, el);
+        else
+            cells.current.delete(`${r}:${c}`);
+    };
+    const tabIndex = (r, c) => (r === row && c === col ? 0 : -1);
+    const header = { name: t.name, size: t.size, modified: t.modified };
+    return (_jsxs("div", { role: "grid", "aria-label": label, "aria-multiselectable": true, "aria-rowcount": items.length + 1, onKeyDown: onKeyDown, className: cn("@container flex min-w-0 flex-col text-sm", className), children: [_jsx("div", { role: "row", "aria-rowindex": 1, className: "sticky top-0 z-10 flex items-center gap-2 border-b bg-muted/60 px-3 text-xs font-medium text-muted-foreground backdrop-blur-sm", children: COLUMNS.map((key, c) => {
+                    const active = sort?.key === key;
+                    const ariaSort = active ? (sort.dir === "asc" ? "ascending" : "descending") : undefined;
+                    return (_jsx("div", { role: "columnheader", "aria-sort": ariaSort, className: cn("flex h-8 items-center", WIDTH[key]), children: onSortChange ? (_jsxs("button", { type: "button", ref: cellRef(-1, c), tabIndex: tabIndex(-1, c), onFocus: () => setFocus({ row: -1, col: c }), onClick: () => onSortChange({
+                                key,
+                                dir: active && sort.dir === "asc" ? "desc" : "asc",
+                            }), className: "inline-flex items-center gap-1 rounded-lg outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring/50", children: [header[key], active &&
+                                    (sort.dir === "asc" ? (_jsx(ArrowUpIcon, { "aria-hidden": true, className: "size-3" })) : (_jsx(ArrowDownIcon, { "aria-hidden": true, className: "size-3" })))] })) : (header[key]) }, key));
+                }) }), items.map((item, r) => (_jsx(FileRow, { item: item, index: r, selected: selection.has(item.path), onMove: onMove, dragPaths: selection.has(item.path) ? order.filter((p) => selection.has(p)) : [item.path], dragLabel: (n) => (n === 1 ? item.name : t.itemCount(n)), onClick: (event) => {
+                    setFocus({ row: r, col });
+                    model.select(item.path, modeOf(event));
+                }, onDoubleClick: () => onOpen(item), onContextMenu: () => {
+                    // Right-clicking outside the selection selects the item, as file managers do.
+                    if (!selection.has(item.path))
+                        model.select(item.path, "replace");
+                }, children: COLUMNS.map((key, c) => (_jsx("div", { role: "gridcell", ref: cellRef(r, c), tabIndex: tabIndex(r, c), onFocus: () => setFocus({ row: r, col: c }), className: cn("flex h-8 items-center gap-2 rounded-lg outline-none focus-visible:ring-2 focus-visible:ring-ring/50", WIDTH[key], key !== "name" && "text-xs text-muted-foreground"), children: key === "name" ? (_jsxs(_Fragment, { children: [_jsx(FileIcon, { name: item.name, kind: item.kind }), _jsx("span", { className: "truncate", children: item.name })] })) : key === "size" ? (item.kind === "file" && item.size != null ? (formatBytes(item.size)) : (_jsx("span", { "aria-label": t.noSize, children: "\u2013" }))) : item.modified ? (_jsx("span", { className: "truncate", children: formatDate(item.modified) })) : null }, key))) }, item.path)))] }));
+}
+function FileRow({ item, index, selected, onMove, dragPaths, dragLabel, onClick, onDoubleClick, onContextMenu, children, }) {
+    const drop = useFileDrop(item.kind === "directory" ? item.path : null, onMove);
+    return (_jsx("div", { role: "row", "data-path": item.path, "aria-rowindex": index + 2, "aria-selected": selected, draggable: Boolean(onMove), onDragStart: onMove ? (event) => startFileDrag(event, dragPaths, dragLabel(dragPaths.length)) : undefined, ...drop.props, onClick: onClick, onDoubleClick: onDoubleClick, onContextMenu: onContextMenu, className: cn("flex cursor-default items-center gap-2 px-3 select-none hover:bg-accent/60", selected && "bg-accent text-accent-foreground hover:bg-accent", drop.over && "bg-primary/10 ring-2 ring-primary ring-inset"), children: children }));
+}

package/dist/workbench/FilePreview.d.ts

@@ -0,0 +1,66 @@
+import * as React from "react";
+/** What the host read from the file. `previewKindFor(name, mime)` picks the kind. */
+export type FilePreviewContent = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "markdown";
+    text: string;
+}
+/** Pretty-printed when it parses; shown as written otherwise (JSON Lines). */
+ | {
+    kind: "json";
+    text: string;
+}
+/** Parsed here; the first row is the header unless `header` is false. `delimiter` "\t" for TSV. */
+ | {
+    kind: "csv";
+    text: string;
+    delimiter?: string;
+    header?: boolean;
+}
+/** Rows the server already parsed (a Parquet or Excel sample). */
+ | {
+    kind: "table";
+    columns: readonly string[];
+    rows: readonly Record<string, unknown>[];
+} | {
+    kind: "image";
+    src: string;
+    alt?: string;
+}
+/** Nothing to show: the type and size only. */
+ | {
+    kind: "binary";
+};
+export interface FilePreviewProps {
+    /** The file's name, the panel's title. */
+    name: string;
+    size?: number | null;
+    mimeType?: string | null;
+    /** Undefined while loading. */
+    content?: FilePreviewContent;
+    error?: string | {
+        message: string;
+    } | null;
+    onRetry?: () => void;
+    /** Part of the file only: the rows or bytes shown, and the whole when known. */
+    truncated?: boolean | {
+        shown: number;
+        total?: number | null;
+    };
+    /** Draws markdown. The package ships no markdown parser; without one the source shows as text. */
+    renderMarkdown?: (text: string) => React.ReactNode;
+    /** Shows a close button. */
+    onClose?: () => void;
+    /** Buttons in the header: download, open. */
+    actions?: React.ReactNode;
+    className?: string;
+}
+/**
+ * A file's contents in a side panel: CSV and tables in the library's
+ * DataTable (search, sort, paging), JSON pretty-printed, images, markdown
+ * through the host's renderer, and text. It reads nothing itself: the host
+ * fetches the bytes and hands over the content.
+ */
+export declare function FilePreview({ name, size, mimeType, content, error, onRetry, truncated, renderMarkdown, onClose, actions, className, }: FilePreviewProps): React.JSX.Element;

package/dist/workbench/FilePreview.js

@@ -0,0 +1,108 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FileQuestionIcon, XIcon } from "lucide-react";
+import * as React from "react";
+import { DataTable } from "../data/DataTable.js";
+import { useLocalTable } from "../data/use-local-table.js";
+import { cn } from "../lib/cn.js";
+import { Button } from "../primitives/Button.js";
+import { useUI } from "../provider/UIProvider.js";
+import { EmptyState } from "../states/EmptyState.js";
+import { ErrorState } from "../states/ErrorState.js";
+import { LoadingState } from "../states/LoadingState.js";
+import { FileIcon } from "./FileIcon.js";
+import { formatBytes, parseDelimited } from "./model.js";
+function TablePreview({ name, columns, rows, }) {
+    const { messages } = useUI();
+    const t = messages.workbench;
+    const controller = useLocalTable(rows, {
+        searchText: (row) => row.cells.join(" "),
+        pageSize: 50,
+        sortBy: Object.fromEntries(columns.map((_, i) => [String(i), (row) => row.cells[i] ?? ""])),
+    });
+    const tableColumns = columns.map((header, i) => ({
+        id: String(i),
+        header: header || t.column(i + 1),
+        sortKey: String(i),
+        cellClassName: "max-w-64 truncate",
+        cell: (row) => row.cells[i] ?? "",
+    }));
+    return (_jsx(DataTable, { label: name, controller: controller, columns: tableColumns, getRowId: (row) => row.id, empty: { title: t.noRows }, density: "compact" }));
+}
+function stringify(value) {
+    if (value == null)
+        return "";
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+/**
+ * A file's contents in a side panel: CSV and tables in the library's
+ * DataTable (search, sort, paging), JSON pretty-printed, images, markdown
+ * through the host's renderer, and text. It reads nothing itself: the host
+ * fetches the bytes and hands over the content.
+ */
+export function FilePreview({ name, size, mimeType, content, error, onRetry, truncated, renderMarkdown, onClose, actions, className, }) {
+    const { messages } = useUI();
+    const t = messages.workbench;
+    const table = React.useMemo(() => {
+        if (content?.kind === "csv") {
+            const parsed = parseDelimited(content.text, content.delimiter);
+            const header = content.header !== false;
+            const width = Math.max(0, ...parsed.map((r) => r.length));
+            const columns = header ? (parsed[0] ?? []) : Array.from({ length: width }, () => "");
+            const body = header ? parsed.slice(1) : parsed;
+            return { columns, rows: body.map((cells, i) => ({ id: String(i), cells })) };
+        }
+        if (content?.kind === "table")
+            return {
+                columns: content.columns,
+                rows: content.rows.map((row, i) => ({
+                    id: String(i),
+                    cells: content.columns.map((c) => stringify(row[c])),
+                })),
+            };
+        return null;
+    }, [content]);
+    const json = React.useMemo(() => {
+        if (content?.kind !== "json")
+            return null;
+        try {
+            return JSON.stringify(JSON.parse(content.text), null, 2);
+        }
+        catch {
+            return content.text;
+        }
+    }, [content]);
+    const errorMessage = typeof error === "string" ? error : error?.message;
+    let body;
+    if (error) {
+        body = (_jsx(ErrorState, { title: t.previewFailed, error: errorMessage || t.previewFailed, onRetry: onRetry, retryLabel: t.retry }));
+    }
+    else if (!content) {
+        body = _jsx(LoadingState, { label: t.previewLoading, rows: 4 });
+    }
+    else if (table) {
+        body = _jsx(TablePreview, { name: name, columns: table.columns, rows: table.rows });
+    }
+    else if (content.kind === "image") {
+        body = (_jsx("img", { src: content.src, alt: content.alt ?? name, className: "mx-auto max-h-full max-w-full rounded-lg object-contain" }));
+    }
+    else if (content.kind === "markdown" && renderMarkdown) {
+        body = _jsx("div", { className: "text-sm", children: renderMarkdown(content.text) });
+    }
+    else if (content.kind === "binary") {
+        body = (_jsx(EmptyState, { icon: _jsx(FileQuestionIcon, { "aria-hidden": true, className: "size-6" }), title: t.noPreview, description: [mimeType, size != null ? formatBytes(size) : null]
+                .filter(Boolean)
+                .join(" · ") }));
+    }
+    else {
+        body = (_jsx("pre", { 
+            // Long text scrolls the panel: focusable so a keyboard can reach and scroll it.
+            // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+            tabIndex: 0, "aria-label": t.contentsOf(name), className: "rounded-lg font-mono text-xs leading-relaxed break-words whitespace-pre-wrap outline-none focus-visible:ring-2 focus-visible:ring-ring/50", children: json ?? (content.kind === "text" || content.kind === "markdown" ? content.text : "") }));
+    }
+    const partial = truncated &&
+        (typeof truncated === "object"
+            ? t.showing(truncated.shown, truncated.total ?? null)
+            : t.partial);
+    return (_jsxs("section", { "aria-label": t.previewOf(name), "data-slot": "file-preview", className: cn("flex min-h-0 min-w-0 flex-col bg-background", className), children: [_jsxs("header", { className: "flex min-h-11 items-center gap-2 border-b px-3 py-1.5", children: [_jsx(FileIcon, { name: name, kind: "file" }), _jsx("h2", { className: "min-w-0 flex-1 truncate text-sm font-medium", title: name, children: name }), size != null && (_jsx("span", { className: "shrink-0 text-xs text-muted-foreground", children: formatBytes(size) })), actions, onClose && (_jsx(Button, { variant: "ghost", size: "icon", className: "size-7", "aria-label": t.closePreview, onClick: onClose, children: _jsx(XIcon, { "aria-hidden": true }) }))] }), _jsx("div", { className: "min-h-0 flex-1 overflow-auto p-3", children: body }), partial && _jsx("p", { className: "border-t px-3 py-1.5 text-xs text-muted-foreground", children: partial })] }));
+}

package/dist/workbench/FileTree.d.ts

@@ -0,0 +1,37 @@
+import * as React from "react";
+import { type MoveHandler } from "./dnd.js";
+import { type FileBranch, type FileItem } from "./model.js";
+export interface FileTreeProps {
+    /** Names the tree. Defaults to "Folders". */
+    label?: string;
+    /** The top level. */
+    root: FileBranch;
+    /** Each loaded directory's children, by path. A directory missing here has not been asked for. */
+    branches?: Readonly<Record<string, FileBranch>>;
+    /** A directory opened with no branch yet: fetch it and put a `loading`, then `ready`, branch in `branches`. */
+    onLoad?: (path: string) => void;
+    /** Re-fetch after an error. `""` is the root. */
+    onRetry?: (path: string) => void;
+    /** Open directories. Controlled when given. */
+    expanded?: ReadonlySet<string>;
+    defaultExpanded?: Iterable<string>;
+    onExpandedChange?: (expanded: Set<string>) => void;
+    /** The current directory, drawn as selected. */
+    selectedPath?: string | null;
+    /** A node chosen by click, Enter or Space. */
+    onSelect?: (item: FileItem) => void;
+    /** Files as well as directories. Off by default: a folder tree. */
+    showFiles?: boolean;
+    /** Drag and drop between nodes; directories (and the tree's background, the root) are targets. */
+    onMove?: MoveHandler;
+    /** A node's context-menu items (`ContextMenuItem`s). */
+    contextMenu?: (item: FileItem) => React.ReactNode;
+    className?: string;
+}
+/**
+ * A lazy file tree on the WAI-ARIA tree pattern: one tab stop, arrows move
+ * and open, Home and End jump, typing a letter finds the next name. The
+ * host owns the data: it answers `onLoad` with a branch per directory, so
+ * the tree fetches nothing and works over any backend.
+ */
+export declare function FileTree({ label, root, branches, onLoad, onRetry, expanded: expandedProp, defaultExpanded, onExpandedChange, selectedPath, onSelect, showFiles, onMove, contextMenu, className, }: FileTreeProps): React.JSX.Element;

package/dist/workbench/FileTree.js

@@ -0,0 +1,218 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ChevronRightIcon, RotateCwIcon } from "lucide-react";
+import * as React from "react";
+import { cn } from "../lib/cn.js";
+import { ContextMenu, ContextMenuContent, ContextMenuTrigger } from "../primitives/ContextMenu.js";
+import { Button } from "../primitives/Button.js";
+import { Skeleton } from "../primitives/Skeleton.js";
+import { useUI } from "../provider/UIProvider.js";
+import { startFileDrag, useFileDrop } from "./dnd.js";
+import { FileIcon } from "./FileIcon.js";
+import { parentPath } from "./model.js";
+import { typeahead } from "./typeahead.js";
+/**
+ * A lazy file tree on the WAI-ARIA tree pattern: one tab stop, arrows move
+ * and open, Home and End jump, typing a letter finds the next name. The
+ * host owns the data: it answers `onLoad` with a branch per directory, so
+ * the tree fetches nothing and works over any backend.
+ */
+export function FileTree({ label, root, branches = {}, onLoad, onRetry, expanded: expandedProp, defaultExpanded, onExpandedChange, selectedPath = null, onSelect, showFiles = false, onMove, contextMenu, className, }) {
+    const { messages } = useUI();
+    const t = messages.workbench;
+    const [ownExpanded, setOwnExpanded] = React.useState(() => new Set(defaultExpanded ?? []));
+    const expanded = expandedProp ?? ownExpanded;
+    const [focusKey, setFocusKey] = React.useState(null);
+    const [menuItem, setMenuItem] = React.useState(null);
+    const nodes = React.useRef(new Map());
+    const pendingFocus = React.useRef(null);
+    const requested = React.useRef(new Set());
+    const search = React.useRef({ text: "", at: 0 });
+    const rootDrop = useFileDrop("", onMove);
+    const shown = React.useCallback((items) => showFiles ? items : items.filter((item) => item.kind === "directory"), [showFiles]);
+    const rows = React.useMemo(() => {
+        const out = [];
+        const walk = (items, level) => {
+            const list = shown(items);
+            list.forEach((item, i) => {
+                const branch = branches[item.path];
+                const leaf = item.kind !== "directory" ||
+                    (branch?.state === "ready" && shown(branch.items).length === 0);
+                const open = !leaf && expanded.has(item.path);
+                out.push({
+                    type: "item",
+                    key: item.path,
+                    item,
+                    level,
+                    size: list.length,
+                    pos: i + 1,
+                    open,
+                    leaf,
+                });
+                if (!open)
+                    return;
+                if (branch?.state === "ready")
+                    walk(branch.items, level + 1);
+                else if (branch?.state === "error")
+                    out.push({
+                        type: "error",
+                        key: `error:${item.path}`,
+                        path: item.path,
+                        level: level + 1,
+                        message: branch.message,
+                    });
+                else
+                    out.push({
+                        type: "loading",
+                        key: `loading:${item.path}`,
+                        path: item.path,
+                        level: level + 1,
+                    });
+            });
+        };
+        if (root.state === "ready")
+            walk(root.items, 1);
+        return out;
+    }, [root, branches, expanded, shown]);
+    // Ask for each open directory's children once; a branch arriving clears the request.
+    React.useEffect(() => {
+        for (const path of requested.current)
+            if (branches[path])
+                requested.current.delete(path);
+        for (const row of rows) {
+            if (row.type !== "loading" || branches[row.path] || requested.current.has(row.path))
+                continue;
+            requested.current.add(row.path);
+            onLoad?.(row.path);
+        }
+    }, [rows, branches, onLoad]);
+    React.useLayoutEffect(() => {
+        if (pendingFocus.current === null)
+            return;
+        nodes.current.get(pendingFocus.current)?.focus();
+        pendingFocus.current = null;
+    });
+    const setExpanded = (next) => {
+        if (!expandedProp)
+            setOwnExpanded(next);
+        onExpandedChange?.(next);
+    };
+    const toggle = (path, open) => {
+        if (expanded.has(path) === open)
+            return;
+        const next = new Set(expanded);
+        if (open)
+            next.add(path);
+        else
+            next.delete(path);
+        setExpanded(next);
+    };
+    const tabKey = (focusKey !== null && rows.some((r) => r.key === focusKey) && focusKey) ||
+        (selectedPath !== null && rows.some((r) => r.key === selectedPath) && selectedPath) ||
+        rows[0]?.key;
+    const focusRow = (key) => {
+        if (key === undefined)
+            return;
+        setFocusKey(key);
+        pendingFocus.current = key;
+    };
+    const activate = (row) => {
+        if (row.type === "error")
+            onRetry?.(row.path);
+        else if (row.type === "item") {
+            onSelect?.(row.item);
+            if (row.item.kind === "directory" && !row.leaf)
+                toggle(row.item.path, true);
+        }
+    };
+    const onKeyDown = (event) => {
+        const index = rows.findIndex((r) => r.key === tabKey);
+        const row = rows[index];
+        if (!row)
+            return;
+        const handled = () => {
+            event.preventDefault();
+            event.stopPropagation();
+        };
+        switch (event.key) {
+            case "ArrowDown":
+                handled();
+                focusRow(rows[Math.min(rows.length - 1, index + 1)]?.key);
+                return;
+            case "ArrowUp":
+                handled();
+                focusRow(rows[Math.max(0, index - 1)]?.key);
+                return;
+            case "Home":
+                handled();
+                focusRow(rows[0]?.key);
+                return;
+            case "End":
+                handled();
+                focusRow(rows[rows.length - 1]?.key);
+                return;
+            case "ArrowRight":
+                handled();
+                if (row.type !== "item" || row.leaf)
+                    return;
+                if (!row.open)
+                    toggle(row.item.path, true);
+                else
+                    focusRow(rows[index + 1]?.key);
+                return;
+            case "ArrowLeft": {
+                handled();
+                if (row.type === "item" && row.open) {
+                    toggle(row.item.path, false);
+                    return;
+                }
+                const parent = row.type === "item" ? parentPath(row.item.path) : row.path;
+                if (parent !== "" && rows.some((r) => r.key === parent))
+                    focusRow(parent);
+                return;
+            }
+            case "Enter":
+            case " ":
+                handled();
+                activate(row);
+                return;
+            default: {
+                const names = rows.map((r) => (r.type === "item" ? r.item.name : ""));
+                const next = typeahead(search.current, event, names, index);
+                if (next !== null) {
+                    handled();
+                    focusRow(rows[next]?.key);
+                }
+            }
+        }
+    };
+    if (root.state !== "ready" || rows.length === 0) {
+        return (_jsx("div", { className: cn("p-2 text-sm text-muted-foreground", className), ...rootDrop.props, children: root.state === "loading" ? (_jsx("div", { role: "status", "aria-label": t.loading, className: "flex flex-col gap-2 p-1", children: Array.from({ length: 5 }, (_, i) => (_jsx(Skeleton, { className: cn("h-4", i % 2 ? "w-2/3" : "w-4/5") }, i))) })) : root.state === "error" ? (_jsxs("div", { role: "alert", className: "flex flex-col items-start gap-2 p-1", children: [_jsx("p", { className: "[overflow-wrap:anywhere]", children: root.message || t.loadFailed }), onRetry && (_jsx(Button, { size: "sm", variant: "outline", onClick: () => onRetry(""), children: t.retry }))] })) : (_jsx("p", { className: "p-1", children: showFiles ? t.empty : t.noFolders })) }));
+    }
+    const tree = (_jsx("ul", { role: "tree", "aria-label": label ?? t.folders, onKeyDown: onKeyDown, ...rootDrop.props, className: cn("flex min-h-full flex-col gap-px p-1 text-sm outline-none", rootDrop.over && "bg-primary/5", className), children: rows.map((row) => row.type === "item" ? (_jsx(TreeNode, { row: row, nodeRef: (el) => {
+                if (el)
+                    nodes.current.set(row.key, el);
+                else
+                    nodes.current.delete(row.key);
+            }, tabbable: row.key === tabKey, selected: row.item.path === selectedPath, onFocus: () => setFocusKey(row.key), onActivate: () => activate(row), onToggle: () => toggle(row.item.path, !row.open), onContextMenu: () => setMenuItem(row.item), onMove: onMove, dragLabel: row.item.name }, row.key)) : (_jsx("li", { ref: (el) => {
+                if (el)
+                    nodes.current.set(row.key, el);
+                else
+                    nodes.current.delete(row.key);
+            }, role: "treeitem", "aria-level": row.level, "aria-selected": false, "aria-disabled": row.type === "loading" || undefined, "aria-busy": row.type === "loading" || undefined, tabIndex: row.key === tabKey ? 0 : -1, onFocus: () => setFocusKey(row.key), onClick: () => activate(row), style: { paddingInlineStart: `${row.level * 0.75 + 0.75}rem` }, className: cn("flex h-7 items-center gap-1.5 rounded-lg pr-2 text-xs text-muted-foreground outline-none focus-visible:ring-2 focus-visible:ring-ring/50", row.type === "error" && "cursor-pointer text-danger-fg hover:bg-accent"), children: row.type === "loading" ? (t.loading) : (_jsxs(_Fragment, { children: [_jsx(RotateCwIcon, { "aria-hidden": true, className: "size-3" }), _jsx("span", { className: "truncate", children: t.retryFolder })] })) }, row.key))) }));
+    if (!contextMenu)
+        return tree;
+    return (_jsxs(ContextMenu, { onOpenChange: (open) => {
+            if (!open)
+                setMenuItem(null);
+        }, children: [_jsx(ContextMenuTrigger, { asChild: true, children: tree }), menuItem && _jsx(ContextMenuContent, { children: contextMenu(menuItem) })] }));
+}
+function TreeNode({ row, nodeRef, tabbable, selected, onFocus, onActivate, onToggle, onContextMenu, onMove, dragLabel, }) {
+    const { item, level, size, pos, open, leaf } = row;
+    const drop = useFileDrop(item.kind === "directory" ? item.path : null, onMove);
+    return (_jsxs("li", { ref: nodeRef, role: "treeitem", "aria-level": level, "aria-setsize": size, "aria-posinset": pos, "aria-expanded": leaf ? undefined : open, "aria-selected": selected, tabIndex: tabbable ? 0 : -1, draggable: Boolean(onMove), onDragStart: onMove ? (event) => startFileDrag(event, [item.path], dragLabel) : undefined, ...drop.props, onFocus: onFocus, onClick: onActivate, onContextMenu: onContextMenu, style: { paddingInlineStart: `${(level - 1) * 0.75 + 0.25}rem` }, className: cn("flex h-7 shrink-0 cursor-default items-center gap-1 rounded-lg pr-2 outline-none select-none hover:bg-accent focus-visible:ring-2 focus-visible:ring-ring/50", selected && "bg-accent font-medium text-accent-foreground", drop.over && "bg-primary/10 ring-2 ring-primary"), children: [_jsx("span", { "aria-hidden": true, onClick: (event) => {
+                    event.stopPropagation();
+                    if (!leaf)
+                        onToggle();
+                }, className: cn("inline-flex size-4 shrink-0 items-center justify-center rounded text-muted-foreground", leaf && "invisible"), children: _jsx(ChevronRightIcon, { className: cn("size-3 transition-transform", open && "rotate-90") }) }), _jsx(FileIcon, { name: item.name, kind: item.kind, open: open }), _jsx("span", { className: "truncate", children: item.name })] }));
+}

package/dist/workbench/GridCell.d.ts

@@ -0,0 +1,19 @@
+import type * as React from "react";
+import { type ColumnType, type GridColumnMeta } from "./grid-model.js";
+export interface ColumnTypeIconProps {
+    type: ColumnType;
+    className?: string;
+}
+/** A column type's glyph, named by the type. Identity, not status: it takes no colour. */
+export declare function ColumnTypeIcon({ type, className }: ColumnTypeIconProps): React.JSX.Element;
+export interface ColumnKeyIconsProps {
+    column: Pick<GridColumnMeta, "primaryKey" | "foreignKey" | "references">;
+}
+/** A column's primary and foreign key marks, each named. */
+export declare function ColumnKeyIcons({ column }: ColumnKeyIconsProps): React.JSX.Element;
+export interface GridCellValueProps {
+    value: unknown;
+    className?: string;
+}
+/** How one value reads in a cell: NULL, empty text and binary are marked so they never pass for data. */
+export declare function GridCellValue({ value, className }: GridCellValueProps): React.JSX.Element;