@calliopelabs/ui 0.14.0 → 0.18.0

package/dist/workbench/grid-selection.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The grid's selection model, as pure data (from Loadr's grid).
+ *
+ * Coordinates are *view* coordinates: `row` indexes the visible (filtered and
+ * sorted) row order, `col` indexes the visible columns. The grid maps them back
+ * to source rows when it copies or edits. Keeping the model out of the
+ * component is what lets 50k-row selection behaviour be tested without a DOM.
+ */
+export interface CellRef {
+    row: number;
+    col: number;
+}
+/** A rectangle, anchored where the drag or shift-click started. */
+export interface SelectionRange {
+    anchor: CellRef;
+    focus: CellRef;
+}
+export interface SelectionState {
+    /** Additive ranges, in the order the user made them. */
+    ranges: SelectionRange[];
+    /** The cell the keyboard acts on. Null when nothing is selected. */
+    active: CellRef | null;
+}
+export declare const EMPTY_SELECTION: SelectionState;
+export interface Bounds {
+    minRow: number;
+    maxRow: number;
+    minCol: number;
+    maxCol: number;
+}
+/** Is this cell inside any range? */
+export declare function isSelected(state: SelectionState, row: number, col: number): boolean;
+/** Total cells covered, counting an overlap once. */
+export declare function selectionSize(state: SelectionState): number;
+/** The bounding box of everything selected, or null when nothing is. */
+export declare function selectionBounds(state: SelectionState): Bounds | null;
+/** Plain click: one cell, everything else dropped. */
+export declare function selectCell(cell: CellRef): SelectionState;
+/**
+ * Shift-click or shift-arrow: stretch the newest range from its anchor.
+ *
+ * With nothing selected yet this behaves like a plain click, which is what
+ * every spreadsheet does when you shift-click into an empty grid.
+ */
+export declare function extendSelection(state: SelectionState, cell: CellRef): SelectionState;
+/**
+ * Cmd/Ctrl-click: add the cell as its own range, or remove it if it was
+ * already the whole of one. Clicking inside a bigger range leaves that range
+ * alone and just moves the active cell, which is how Excel behaves.
+ */
+export declare function toggleCell(state: SelectionState, cell: CellRef): SelectionState;
+/** Column header click. Additive keeps the existing ranges (cmd-click). */
+export declare function selectColumn(state: SelectionState, col: number, rowCount: number, additive?: boolean): SelectionState;
+/** Row-number click. */
+export declare function selectRow(state: SelectionState, row: number, colCount: number, additive?: boolean): SelectionState;
+/** Shift-click on a row number: every row between the anchor row and this one. */
+export declare function extendRowSelection(state: SelectionState, row: number, colCount: number): SelectionState;
+export declare function selectAll(rowCount: number, colCount: number): SelectionState;
+/** True when every row of `col` is inside the selection. */
+export declare function isColumnSelected(state: SelectionState, col: number, rowCount: number): boolean;
+/** True when every column of `row` is inside the selection. */
+export declare function isRowSelected(state: SelectionState, row: number, colCount: number): boolean;
+/**
+ * Move the active cell, clamped to the grid.
+ *
+ * `extend` stretches the current range instead of starting a new one, which is
+ * what shift-arrow does.
+ */
+export declare function moveActive(state: SelectionState, to: CellRef, rowCount: number, colCount: number, extend: boolean): SelectionState;

package/dist/workbench/grid-selection.js

@@ -0,0 +1,183 @@
+/**
+ * The grid's selection model, as pure data (from Loadr's grid).
+ *
+ * Coordinates are *view* coordinates: `row` indexes the visible (filtered and
+ * sorted) row order, `col` indexes the visible columns. The grid maps them back
+ * to source rows when it copies or edits. Keeping the model out of the
+ * component is what lets 50k-row selection behaviour be tested without a DOM.
+ */
+export const EMPTY_SELECTION = { ranges: [], active: null };
+function rangeBounds(range) {
+    return {
+        minRow: Math.min(range.anchor.row, range.focus.row),
+        maxRow: Math.max(range.anchor.row, range.focus.row),
+        minCol: Math.min(range.anchor.col, range.focus.col),
+        maxCol: Math.max(range.anchor.col, range.focus.col),
+    };
+}
+function contains(range, row, col) {
+    const b = rangeBounds(range);
+    return row >= b.minRow && row <= b.maxRow && col >= b.minCol && col <= b.maxCol;
+}
+/** Is this cell inside any range? */
+export function isSelected(state, row, col) {
+    for (const range of state.ranges) {
+        if (contains(range, row, col))
+            return true;
+    }
+    return false;
+}
+/** Total cells covered, counting an overlap once. */
+export function selectionSize(state) {
+    if (state.ranges.length === 0)
+        return 0;
+    const [only] = state.ranges;
+    if (state.ranges.length === 1 && only) {
+        const b = rangeBounds(only);
+        return (b.maxRow - b.minRow + 1) * (b.maxCol - b.minCol + 1);
+    }
+    const seen = new Set();
+    for (const range of state.ranges) {
+        const b = rangeBounds(range);
+        for (let r = b.minRow; r <= b.maxRow; r++) {
+            for (let c = b.minCol; c <= b.maxCol; c++)
+                seen.add(`${r}:${c}`);
+        }
+    }
+    return seen.size;
+}
+/** The bounding box of everything selected, or null when nothing is. */
+export function selectionBounds(state) {
+    if (state.ranges.length === 0)
+        return null;
+    let out = null;
+    for (const range of state.ranges) {
+        const b = rangeBounds(range);
+        out = out
+            ? {
+                minRow: Math.min(out.minRow, b.minRow),
+                maxRow: Math.max(out.maxRow, b.maxRow),
+                minCol: Math.min(out.minCol, b.minCol),
+                maxCol: Math.max(out.maxCol, b.maxCol),
+            }
+            : b;
+    }
+    return out;
+}
+/** Plain click: one cell, everything else dropped. */
+export function selectCell(cell) {
+    return { ranges: [{ anchor: cell, focus: cell }], active: cell };
+}
+/**
+ * Shift-click or shift-arrow: stretch the newest range from its anchor.
+ *
+ * With nothing selected yet this behaves like a plain click, which is what
+ * every spreadsheet does when you shift-click into an empty grid.
+ */
+export function extendSelection(state, cell) {
+    if (state.ranges.length === 0)
+        return selectCell(cell);
+    const ranges = state.ranges.slice();
+    const last = ranges[ranges.length - 1];
+    if (!last)
+        return selectCell(cell);
+    ranges[ranges.length - 1] = { anchor: last.anchor, focus: cell };
+    return { ranges, active: cell };
+}
+/**
+ * Cmd/Ctrl-click: add the cell as its own range, or remove it if it was
+ * already the whole of one. Clicking inside a bigger range leaves that range
+ * alone and just moves the active cell, which is how Excel behaves.
+ */
+export function toggleCell(state, cell) {
+    const exact = state.ranges.findIndex((r) => r.anchor.row === cell.row &&
+        r.anchor.col === cell.col &&
+        r.focus.row === cell.row &&
+        r.focus.col === cell.col);
+    if (exact >= 0) {
+        const ranges = state.ranges.filter((_, i) => i !== exact);
+        return { ranges, active: ranges[ranges.length - 1]?.focus ?? null };
+    }
+    return { ranges: [...state.ranges, { anchor: cell, focus: cell }], active: cell };
+}
+/** Column header click. Additive keeps the existing ranges (cmd-click). */
+export function selectColumn(state, col, rowCount, additive = false) {
+    if (rowCount === 0)
+        return additive ? state : EMPTY_SELECTION;
+    const range = {
+        anchor: { row: 0, col },
+        focus: { row: rowCount - 1, col },
+    };
+    return {
+        ranges: additive ? [...state.ranges, range] : [range],
+        active: { row: 0, col },
+    };
+}
+/** Row-number click. */
+export function selectRow(state, row, colCount, additive = false) {
+    if (colCount === 0)
+        return additive ? state : EMPTY_SELECTION;
+    const range = {
+        anchor: { row, col: 0 },
+        focus: { row, col: colCount - 1 },
+    };
+    return {
+        ranges: additive ? [...state.ranges, range] : [range],
+        active: { row, col: 0 },
+    };
+}
+/** Shift-click on a row number: every row between the anchor row and this one. */
+export function extendRowSelection(state, row, colCount) {
+    if (state.ranges.length === 0)
+        return selectRow(state, row, colCount);
+    const ranges = state.ranges.slice();
+    const last = ranges[ranges.length - 1];
+    if (!last)
+        return selectRow(state, row, colCount);
+    ranges[ranges.length - 1] = {
+        anchor: { row: last.anchor.row, col: 0 },
+        focus: { row, col: Math.max(colCount - 1, 0) },
+    };
+    return { ranges, active: { row, col: 0 } };
+}
+export function selectAll(rowCount, colCount) {
+    if (rowCount === 0 || colCount === 0)
+        return EMPTY_SELECTION;
+    return {
+        ranges: [{ anchor: { row: 0, col: 0 }, focus: { row: rowCount - 1, col: colCount - 1 } }],
+        active: { row: 0, col: 0 },
+    };
+}
+/** True when every row of `col` is inside the selection. */
+export function isColumnSelected(state, col, rowCount) {
+    if (rowCount === 0)
+        return false;
+    return state.ranges.some((r) => {
+        const b = rangeBounds(r);
+        return b.minCol <= col && b.maxCol >= col && b.minRow === 0 && b.maxRow >= rowCount - 1;
+    });
+}
+/** True when every column of `row` is inside the selection. */
+export function isRowSelected(state, row, colCount) {
+    if (colCount === 0)
+        return false;
+    return state.ranges.some((r) => {
+        const b = rangeBounds(r);
+        return b.minRow <= row && b.maxRow >= row && b.minCol === 0 && b.maxCol >= colCount - 1;
+    });
+}
+/**
+ * Move the active cell, clamped to the grid.
+ *
+ * `extend` stretches the current range instead of starting a new one, which is
+ * what shift-arrow does.
+ */
+export function moveActive(state, to, rowCount, colCount, extend) {
+    if (rowCount === 0 || colCount === 0)
+        return EMPTY_SELECTION;
+    const cell = {
+        row: Math.min(Math.max(to.row, 0), rowCount - 1),
+        col: Math.min(Math.max(to.col, 0), colCount - 1),
+    };
+    return extend ? extendSelection(state, cell) : selectCell(cell);
+}

package/dist/workbench/grid-stats.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Column and selection statistics, and the column profile (from Loadr's grid
+ * and profile view). Pure.
+ *
+ * One pass, no sorting of the whole column: at 50k rows the grid computes these
+ * on a header menu opening or a selection change, so the cost has to stay linear
+ * and allocation-light.
+ */
+export interface ColumnStats {
+    /** Values looked at, including NULLs. */
+    count: number;
+    nulls: number;
+    distinct: number;
+    min?: number | string;
+    max?: number | string;
+    sum?: number;
+    avg?: number;
+    /** True when every non-NULL value was a number. */
+    numeric: boolean;
+}
+export declare function computeStats(values: readonly unknown[]): ColumnStats;
+export interface NumericSummary {
+    count: number;
+    sum: number;
+    avg: number;
+    min: number;
+    max: number;
+}
+/**
+ * Sum/avg over whatever in the selection parses as a number.
+ *
+ * Unlike `computeStats` this does coerce numeric strings, because a selection
+ * spans columns and a numeric column arriving as text should still add up.
+ */
+export declare function numericSummary(values: readonly unknown[]): NumericSummary | null;
+export declare function formatStatValue(value: number | string | undefined): string;
+/** What the profile infers a column holds. */
+export type ProfileKind = "numeric" | "text" | "boolean" | "date" | "null";
+/** One column of a profile. */
+export interface ColumnProfile {
+    name: string;
+    kind: ProfileKind;
+    count: number;
+    nulls: number;
+    distinct: number;
+    min?: number | string;
+    max?: number | string;
+    mean?: number;
+    median?: number;
+    /** The most frequent values, most frequent first, as a share of the non-NULL values. */
+    top: {
+        value: string;
+        count: number;
+        share: number;
+    }[];
+}
+/** A column's profile: counts, range, mean and median (numeric), and the top values. */
+export declare function profileColumn(name: string, values: readonly unknown[], topCount?: number): ColumnProfile;

package/dist/workbench/grid-stats.js

@@ -0,0 +1,185 @@
+/**
+ * Column and selection statistics, and the column profile (from Loadr's grid
+ * and profile view). Pure.
+ *
+ * One pass, no sorting of the whole column: at 50k rows the grid computes these
+ * on a header menu opening or a selection change, so the cost has to stay linear
+ * and allocation-light.
+ */
+function asNumber(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+export function computeStats(values) {
+    let nulls = 0;
+    let numericCount = 0;
+    let nonNull = 0;
+    let sum = 0;
+    let numMin = Number.POSITIVE_INFINITY;
+    let numMax = Number.NEGATIVE_INFINITY;
+    let strMin;
+    let strMax;
+    const distinct = new Set();
+    for (const value of values) {
+        if (value === null || value === undefined) {
+            nulls++;
+            continue;
+        }
+        nonNull++;
+        const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+        distinct.add(text);
+        const num = typeof value === "number" && Number.isFinite(value) ? value : null;
+        if (num !== null) {
+            numericCount++;
+            sum += num;
+            if (num < numMin)
+                numMin = num;
+            if (num > numMax)
+                numMax = num;
+        }
+        else {
+            if (strMin === undefined || text < strMin)
+                strMin = text;
+            if (strMax === undefined || text > strMax)
+                strMax = text;
+        }
+    }
+    const numeric = nonNull > 0 && numericCount === nonNull;
+    const stats = {
+        count: nulls + nonNull,
+        nulls,
+        distinct: distinct.size,
+        numeric,
+    };
+    if (numeric) {
+        stats.min = numMin;
+        stats.max = numMax;
+        stats.sum = sum;
+        stats.avg = sum / numericCount;
+    }
+    else {
+        stats.min = strMin;
+        stats.max = strMax;
+    }
+    return stats;
+}
+/**
+ * Sum/avg over whatever in the selection parses as a number.
+ *
+ * Unlike `computeStats` this does coerce numeric strings, because a selection
+ * spans columns and a numeric column arriving as text should still add up.
+ */
+export function numericSummary(values) {
+    let count = 0;
+    let sum = 0;
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        const num = asNumber(value);
+        if (num === null)
+            continue;
+        count++;
+        sum += num;
+        if (num < min)
+            min = num;
+        if (num > max)
+            max = num;
+    }
+    if (count === 0)
+        return null;
+    return { count, sum, avg: sum / count, min, max };
+}
+export function formatStatValue(value) {
+    if (value === undefined)
+        return "";
+    if (typeof value === "number") {
+        return Number.isInteger(value)
+            ? value.toLocaleString()
+            : value.toLocaleString(undefined, { maximumFractionDigits: 4 });
+    }
+    return value.length > 40 ? `${value.slice(0, 40)}\u2026` : value;
+}
+function profileKind(values) {
+    let total = 0;
+    let nums = 0;
+    let bools = 0;
+    let dates = 0;
+    for (const v of values) {
+        if (v === null || v === undefined)
+            continue;
+        total++;
+        if (typeof v === "number")
+            nums++;
+        else if (typeof v === "boolean")
+            bools++;
+        else if (typeof v === "string") {
+            if (/^\d{4}-\d{2}-\d{2}/.test(v))
+                dates++;
+            else if (asNumber(v) !== null)
+                nums++;
+        }
+    }
+    if (total === 0)
+        return "null";
+    if (bools / total > 0.8)
+        return "boolean";
+    if (dates / total > 0.8)
+        return "date";
+    if (nums / total > 0.8)
+        return "numeric";
+    return "text";
+}
+/** A column's profile: counts, range, mean and median (numeric), and the top values. */
+export function profileColumn(name, values, topCount = 5) {
+    const kind = profileKind(values);
+    const freq = new Map();
+    let nulls = 0;
+    for (const v of values) {
+        if (v === null || v === undefined) {
+            nulls++;
+            continue;
+        }
+        const text = typeof v === "object" ? JSON.stringify(v) : String(v);
+        freq.set(text, (freq.get(text) ?? 0) + 1);
+    }
+    const nonNull = values.length - nulls;
+    const profile = {
+        name,
+        kind,
+        count: values.length,
+        nulls,
+        distinct: freq.size,
+        top: [...freq.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, topCount)
+            .map(([value, count]) => ({ value, count, share: nonNull > 0 ? count / nonNull : 0 })),
+    };
+    if (kind === "numeric") {
+        const nums = [];
+        for (const v of values) {
+            const n = asNumber(v);
+            if (n !== null)
+                nums.push(n);
+        }
+        nums.sort((a, b) => a - b);
+        if (nums.length > 0) {
+            const mid = Math.floor(nums.length / 2);
+            profile.min = nums[0];
+            profile.max = nums[nums.length - 1];
+            profile.mean = nums.reduce((s, n) => s + n, 0) / nums.length;
+            profile.median =
+                nums.length % 2 === 0 ? ((nums[mid - 1] ?? 0) + (nums[mid] ?? 0)) / 2 : nums[mid];
+        }
+    }
+    else if (kind === "text" || kind === "date") {
+        const keys = [...freq.keys()].sort();
+        profile.min = keys[0];
+        profile.max = keys[keys.length - 1];
+    }
+    return profile;
+}

package/dist/workbench/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `@calliopelabs/ui/workbench`: the pieces of an IDE-style tool that more
+ * than one Calliope AI product draws. Opt-in, like `./agent`: an app that
+ * has no file browser never loads it. Everything is host-driven: data comes
+ * in as props, every change goes out through a callback, nothing fetches.
+ * Styles come from the package preset (`@calliopelabs/ui/preset.css`).
+ */
+export { canDrop, fileExtension, formatBytes, isWithin, joinPath, parentPath, parseDelimited, pathSegments, previewKindFor, sortFiles, type FileBranch, type FileItem, type FileKind, type FileSort, type FileSortKey, type FileView, type PreviewKind, type UploadState, } from "./model.js";
+export { FILE_DRAG_TYPE, type MoveHandler } from "./dnd.js";
+export { FileIcon, type FileIconProps } from "./FileIcon.js";
+export { FileTree, type FileTreeProps } from "./FileTree.js";
+export { FileList, type FileListProps, type FileViewProps } from "./FileList.js";
+export { FileGrid, type FileGridProps } from "./FileGrid.js";
+export { FileBrowser, type FileBrowserProps } from "./FileBrowser.js";
+export { UploadDropzone, type UploadDropzoneProps, type UploadItem, type UploadRejection, } from "./UploadDropzone.js";
+export { FilePreview, type FilePreviewContent, type FilePreviewProps } from "./FilePreview.js";
+export { formatShortcut, isMacPlatform, matchesShortcut, parseShortcut, shortcutKeys, type KeyChord, } from "./keys.js";
+export { KeyboardShortcutsDialog, ShortcutKeys, useRegisteredShortcuts, useShortcuts, type KeyboardShortcutsDialogProps, type ShortcutDefinition, type ShortcutEntry, type ShortcutKeysProps, } from "./Shortcuts.js";
+export { fuzzyScore, rankItems, type PaletteMatchable } from "./palette.js";
+export { CommandPalette, type CommandPaletteProps, type PaletteItem } from "./CommandPalette.js";
+export { MenuBar, type MenuBarProps, type MenuEntry, type WorkbenchMenu } from "./MenuBar.js";
+export { ActivityBar, type ActivityBarProps, type ActivityItem } from "./ActivityBar.js";
+export { EditorGroup, EditorTabs, editorTabId, type EditorGroupProps, type EditorTab, type EditorTabsProps, } from "./EditorTabs.js";
+export { Pane, PaneGroup, resolvePaneSizes, type PaneGroupProps, type PaneProps, type PaneSize, } from "./PaneGroup.js";
+export { BottomPanel, type BottomPanelProps, type BottomPanelView } from "./BottomPanel.js";
+export { StatusBar, StatusBarItem, type StatusBarItemProps, type StatusBarProps, type StatusBarTone, } from "./StatusBar.js";
+export { WorkbenchShell, type WorkbenchShellProps } from "./WorkbenchShell.js";
+export { COLUMN_TYPES, asBinary, buildColumnMeta, cellText, columnSignature, compareCells, isNumericType, normalizeColumnType, sniffColumnType, viewRowIndexes, type BinaryCell, type ColumnType, type GridColumn, type GridColumnMeta, type GridRow, type GridSort, type SortDirection, } from "./grid-model.js";
+export { EMPTY_SELECTION, extendSelection, isSelected, moveActive, selectAll, selectCell, selectColumn, selectRow, selectionBounds, selectionSize, toggleCell, type CellRef, type SelectionRange, type SelectionState, } from "./grid-selection.js";
+export { EXPORT_FORMATS, exportBlob, exportMatrix, formatMatrix, quoteIdentifier, rowsMatrix, selectionMatrix, sqlLiteral, toCSV, toInsert, toJSON, toJSONL, toMarkdown, toTSV, type CellMatrix, type CopyFormat, type ExportFile, type ExportFormat, } from "./grid-format.js";
+export { computeStats, formatStatValue, numericSummary, profileColumn, type ColumnProfile, type ColumnStats, type NumericSummary, type ProfileKind, } from "./grid-stats.js";
+export { NO_CHANGES, addRow, changeSetToSql, deleteRows, editCell, insertedKeys, isCellChanged, parseCellInput, pendingCounts, pendingValue, revertRow, toChangeSet, type ChangeSet, type ChangeSetDelete, type ChangeSetInsert, type ChangeSetUpdate, type PendingChanges, type PendingCounts, type PendingRow, type PendingState, } from "./pending.js";
+export { downloadBase64, downloadBlob, downloadExport } from "./download.js";
+export { ColumnKeyIcons, ColumnTypeIcon, GridCellValue, type ColumnKeyIconsProps, type ColumnTypeIconProps, type GridCellValueProps, } from "./GridCell.js";
+export { TruncationBanner, type TruncationBannerProps } from "./TruncationBanner.js";
+export { CellDetailDialog, RowDetailDrawer, type CellDetailDialogProps, type RowDetailDrawerProps, } from "./GridDetails.js";
+export { PendingChangesBar, type PendingChangesBarProps } from "./PendingChangesBar.js";
+export { DataGrid, type DataGridProps, type GridCommitError, type GridCopyEvent, type GridExportOption, type GridExportRequest, } from "./DataGrid.js";
+export { DataProfile, type DataProfileProps } from "./DataProfile.js";
+export { DataChart, type ChartKind, type ChartLibrary, type DataChartProps } from "./DataChart.js";
+export { CodeEditor, configureMonaco, type CodeEditorProps, type MonacoApi, type MonacoEditor, } from "./CodeEditor.js";
+export { SqlEditor, type SqlEditorProps } from "./SqlEditor.js";
+export { ambiguousColumns, extractTableRefs, isDdlStatement, resolveSqlDot, sqlCompletions, sqlCursorContext, sqlMatch, statementAt, SQL_FUNCTIONS, SQL_KEYWORDS, type SqlColumn, type SqlCompletion, type SqlCompletionKind, type SqlCompletionResult, type SqlCursorContext, type SqlDotTarget, type SqlSchema, type SqlSchemaRequest, type SqlTable, type SqlTableRef, } from "./sql-completion.js";
+export { cssColorToHex, editorTheme, readEditorPalette, type EditorPalette, type EditorThemeData, } from "./editor-theme.js";

package/dist/workbench/index.js

@@ -0,0 +1,47 @@
+/**
+ * `@calliopelabs/ui/workbench`: the pieces of an IDE-style tool that more
+ * than one Calliope AI product draws. Opt-in, like `./agent`: an app that
+ * has no file browser never loads it. Everything is host-driven: data comes
+ * in as props, every change goes out through a callback, nothing fetches.
+ * Styles come from the package preset (`@calliopelabs/ui/preset.css`).
+ */
+export { canDrop, fileExtension, formatBytes, isWithin, joinPath, parentPath, parseDelimited, pathSegments, previewKindFor, sortFiles, } from "./model.js";
+export { FILE_DRAG_TYPE } from "./dnd.js";
+export { FileIcon } from "./FileIcon.js";
+export { FileTree } from "./FileTree.js";
+export { FileList } from "./FileList.js";
+export { FileGrid } from "./FileGrid.js";
+export { FileBrowser } from "./FileBrowser.js";
+export { UploadDropzone, } from "./UploadDropzone.js";
+export { FilePreview } from "./FilePreview.js";
+// The IDE shell.
+export { formatShortcut, isMacPlatform, matchesShortcut, parseShortcut, shortcutKeys, } from "./keys.js";
+export { KeyboardShortcutsDialog, ShortcutKeys, useRegisteredShortcuts, useShortcuts, } from "./Shortcuts.js";
+export { fuzzyScore, rankItems } from "./palette.js";
+export { CommandPalette } from "./CommandPalette.js";
+export { MenuBar } from "./MenuBar.js";
+export { ActivityBar } from "./ActivityBar.js";
+export { EditorGroup, EditorTabs, editorTabId, } from "./EditorTabs.js";
+export { Pane, PaneGroup, resolvePaneSizes, } from "./PaneGroup.js";
+export { BottomPanel } from "./BottomPanel.js";
+export { StatusBar, StatusBarItem, } from "./StatusBar.js";
+export { WorkbenchShell } from "./WorkbenchShell.js";
+// The data grid, profile and chart.
+export { COLUMN_TYPES, asBinary, buildColumnMeta, cellText, columnSignature, compareCells, isNumericType, normalizeColumnType, sniffColumnType, viewRowIndexes, } from "./grid-model.js";
+export { EMPTY_SELECTION, extendSelection, isSelected, moveActive, selectAll, selectCell, selectColumn, selectRow, selectionBounds, selectionSize, toggleCell, } from "./grid-selection.js";
+export { EXPORT_FORMATS, exportBlob, exportMatrix, formatMatrix, quoteIdentifier, rowsMatrix, selectionMatrix, sqlLiteral, toCSV, toInsert, toJSON, toJSONL, toMarkdown, toTSV, } from "./grid-format.js";
+export { computeStats, formatStatValue, numericSummary, profileColumn, } from "./grid-stats.js";
+export { NO_CHANGES, addRow, changeSetToSql, deleteRows, editCell, insertedKeys, isCellChanged, parseCellInput, pendingCounts, pendingValue, revertRow, toChangeSet, } from "./pending.js";
+export { downloadBase64, downloadBlob, downloadExport } from "./download.js";
+export { ColumnKeyIcons, ColumnTypeIcon, GridCellValue, } from "./GridCell.js";
+export { TruncationBanner } from "./TruncationBanner.js";
+export { CellDetailDialog, RowDetailDrawer, } from "./GridDetails.js";
+export { PendingChangesBar } from "./PendingChangesBar.js";
+export { DataGrid, } from "./DataGrid.js";
+export { DataProfile } from "./DataProfile.js";
+export { DataChart } from "./DataChart.js";
+// The code and SQL editors (Monaco, an optional peer the host loads).
+export { CodeEditor, configureMonaco, } from "./CodeEditor.js";
+export { SqlEditor } from "./SqlEditor.js";
+export { ambiguousColumns, extractTableRefs, isDdlStatement, resolveSqlDot, sqlCompletions, sqlCursorContext, sqlMatch, statementAt, SQL_FUNCTIONS, SQL_KEYWORDS, } from "./sql-completion.js";
+export { cssColorToHex, editorTheme, readEditorPalette, } from "./editor-theme.js";

package/dist/workbench/keys.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Keyboard chords as strings: `"Mod+K"`, `"Mod+Shift+A"`, `"Alt+ArrowLeft"`,
+ * `"F2"`. `Mod` is Command on a Mac and Control elsewhere, so one binding
+ * serves both. Pure: parsing, matching and display, no listeners.
+ */
+export interface KeyChord {
+    /** The key, as `KeyboardEvent.key` names it, lowercased for letters. */
+    key: string;
+    mod: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+export declare function parseShortcut(shortcut: string): KeyChord;
+export declare function isMacPlatform(): boolean;
+type KeyEventLike = Pick<KeyboardEvent, "key" | "code" | "ctrlKey" | "metaKey" | "altKey" | "shiftKey">;
+export declare function matchesShortcut(event: KeyEventLike, shortcut: string | KeyChord, isMac?: boolean): boolean;
+/** The keys of a chord as they are drawn: `["⌘", "K"]` on a Mac, `["Ctrl", "K"]` elsewhere. */
+export declare function shortcutKeys(shortcut: string, isMac?: boolean): string[];
+/** One string for a menu or a tooltip: `"⌘K"` on a Mac, `"Ctrl+K"` elsewhere. */
+export declare function formatShortcut(shortcut: string, isMac?: boolean): string;
+export {};