@kermodes/grid 0.0.0-stage → 0.3.13-dev.68.g32b767a

package/dist/RangedSelection.d.ts

@@ -0,0 +1,118 @@
+import GridRange, { type GridRangeIndex, type SELECTION_DIRECTION } from './GridRange';
+import type { VisibleIndex } from './GridMetrics';
+import { type BoundedAxisRange } from './GridAxisRange';
+import type { CommitGestureOptions, GestureExtendOptions, GetModel, Selection, TickRangeSelection } from './Selection';
+/**
+ * Immutable `Selection` for standard (row-indexed) grids. Each entry in
+ * `ranges` describes a rectangle of cells; consumers iterate/consolidate
+ * as needed.
+ */
+export declare class RangedSelection implements Selection, TickRangeSelection {
+    /** Committed selection rectangles; may be empty for a cleared selection. */
+    readonly ranges: readonly GridRange[];
+    /**
+     * Deferred lookup for the current `GridModel`. Passed as a closure
+     * (not a direct reference) so this Selection always reads the model
+     * currently on `Grid.props.model` — surviving prop swaps without
+     * holding a stale reference.
+     */
+    private readonly getModel;
+    /** Anchor row for shift-click / keyboard extend; null when no anchor is set. */
+    private readonly gestureStartRow;
+    /** Anchor column for shift-click / keyboard extend; null when no anchor is set. */
+    private readonly gestureStartColumn;
+    /** Focus row; null when no cursor is set. */
+    readonly cursorRow: VisibleIndex | null;
+    /** Focus column; null when no cursor is set. */
+    readonly cursorColumn: VisibleIndex | null;
+    /** Last shift/drag endpoint row; null when unset. */
+    readonly selectionEndRow: VisibleIndex | null;
+    /** Last shift/drag endpoint column; null when unset. */
+    readonly selectionEndColumn: VisibleIndex | null;
+    static empty(getModel: GetModel): RangedSelection;
+    constructor(
+    /** Committed selection rectangles; may be empty for a cleared selection. */
+    ranges: readonly GridRange[], 
+    /**
+     * Deferred lookup for the current `GridModel`. Passed as a closure
+     * (not a direct reference) so this Selection always reads the model
+     * currently on `Grid.props.model` — surviving prop swaps without
+     * holding a stale reference.
+     */
+    getModel: GetModel, 
+    /** Anchor row for shift-click / keyboard extend; null when no anchor is set. */
+    gestureStartRow?: GridRangeIndex, 
+    /** Anchor column for shift-click / keyboard extend; null when no anchor is set. */
+    gestureStartColumn?: GridRangeIndex, 
+    /** Focus row; null when no cursor is set. */
+    cursorRow?: VisibleIndex | null, 
+    /** Focus column; null when no cursor is set. */
+    cursorColumn?: VisibleIndex | null, 
+    /** Last shift/drag endpoint row; null when unset. */
+    selectionEndRow?: VisibleIndex | null, 
+    /** Last shift/drag endpoint column; null when unset. */
+    selectionEndColumn?: VisibleIndex | null);
+    /**
+     * Returns a copy with the given fields overridden. Unspecified fields
+     * carry through from `this`, so mutations that only touch ranges /
+     * anchor keep cursor + endpoint intact without extra bookkeeping at
+     * every call site.
+     */
+    private copyWith;
+    isEmpty(): boolean;
+    isCellSelected(column: VisibleIndex, row: VisibleIndex): boolean;
+    isRowSelected(row: VisibleIndex): boolean;
+    isColumnSelected(column: VisibleIndex): boolean;
+    /**
+     * Checks if all ranges are within the bounds of the grid model.
+     * @returns True if all ranges are within bounds, false otherwise.
+     */
+    isInBounds(): boolean;
+    toRanges(): readonly GridRange[];
+    getColumnTickRanges(): readonly BoundedAxisRange[];
+    getRowTickRanges(): readonly BoundedAxisRange[];
+    private cachedColumnTickRanges;
+    private cachedRowTickRanges;
+    withCommittedRanges(ranges: readonly GridRange[], anchor?: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }): RangedSelection;
+    /**
+     * Sets the gesture anchor (extend-from position for shift-click and
+     * keyboard extend) to the given cell. Passing `null` for both clears it.
+     */
+    private withGestureAnchor;
+    /**
+     * The current `{row, column}` of the gesture anchor, or `null` if none is set.
+     */
+    private getGestureAnchor;
+    selectAll(): RangedSelection;
+    getNextCursorInDirection(current: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }, direction: SELECTION_DIRECTION): {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    } | null;
+    private getCursorLandingCell;
+    withCursor(row: VisibleIndex | null, column: VisibleIndex | null): RangedSelection;
+    withSelectionEnd(row: VisibleIndex | null, column: VisibleIndex | null): RangedSelection;
+    withGestureExtend(cursor: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }, opts: GestureExtendOptions): RangedSelection;
+    commitGesture(lastCommitted: Selection, opts: CommitGestureOptions): RangedSelection;
+    clear(): RangedSelection;
+    trimmed(): RangedSelection;
+    truncate(maxRows: number): RangedSelection;
+}
+export declare function isRangedSelection(selection: Selection): selection is RangedSelection;
+export declare function assertIsRangedSelection(selection: Selection): asserts selection is RangedSelection;
+/**
+ * Returns `selection.toRanges()` when `selection` is a `RangedSelection`,
+ * otherwise `EMPTY_ARRAY`. Handy for consumers that only care about the
+ * range-form projection of a selection (e.g. legacy `selectedRanges`
+ * callbacks) and want a stable empty array for keyed / null selections.
+ */
+export declare function selectionToRanges(selection: Selection | null | undefined): readonly GridRange[];
+export default RangedSelection;

package/dist/Selection.d.ts

@@ -0,0 +1,218 @@
+import type GridRange from './GridRange';
+import type { GridRangeIndex, SELECTION_DIRECTION } from './GridRange';
+import type GridModel from './GridModel';
+import type { VisibleIndex } from './GridMetrics';
+import type { BoundedAxisRange } from './GridAxisRange';
+/** Provides current model data to Selection instances without holding a stale reference. */
+export type GetModel = () => GridModel;
+/**
+ * Immutable value object representing the current selection state of the grid.
+ * Mutations return new instances; Grid stores the result in React state.
+ *
+ * Composed from five sub-interfaces:
+ * - `SelectionQueries` — read-only inspection.
+ * - `SelectionTransforms` — immutable transforms with no external dependencies.
+ * - `ProgrammaticSelection` — programmatic write path (`Grid.setSelectedRanges`).
+ * - `MouseSelection` — mouse-driven gestures (click, shift-click, drag).
+ * - `KeyboardSelection` — keyboard-driven queries (Tab/Enter advance, cursor
+ *   landing after commit).
+ */
+export interface Selection extends SelectionQueries, SelectionTransforms, ProgrammaticSelection, MouseSelection, KeyboardSelection {
+}
+/** Read-only inspection of a `Selection`. Every method is side-effect-free. */
+export interface SelectionQueries {
+    /** True when the selection contains no cells and no in-progress gesture. */
+    isEmpty: () => boolean;
+    /** True when `(column, row)` is part of the selection. */
+    isCellSelected: (column: VisibleIndex, row: VisibleIndex) => boolean;
+    /** True when the entire row is part of the selection. */
+    isRowSelected: (row: VisibleIndex) => boolean;
+    /** True when the entire column is part of the selection. */
+    isColumnSelected: (column: VisibleIndex) => boolean;
+    /** The focus cell's row, or `null` when there is no cursor set. */
+    readonly cursorRow: VisibleIndex | null;
+    /** The focus cell's column, or `null` when there is no cursor set. */
+    readonly cursorColumn: VisibleIndex | null;
+    /** Row of the last shift/drag endpoint, or `null` when unset. */
+    readonly selectionEndRow: VisibleIndex | null;
+    /** Column of the last shift/drag endpoint, or `null` when unset. */
+    readonly selectionEndColumn: VisibleIndex | null;
+}
+/**
+ * Optional capability implemented by selections that can project onto
+ * scrollbar tick marks. Ranges are returned sorted by start and merged so
+ * consumers can iterate directly without re-normalizing per frame.
+ */
+export interface TickRangeSelection {
+    /**
+     * Sorted, non-overlapping column `[start, end]` pairs for scrollbar tick
+     * rendering.
+     */
+    getColumnTickRanges: () => readonly BoundedAxisRange[];
+    /**
+     * Sorted, non-overlapping row `[start, end]` pairs for scrollbar tick
+     * rendering.
+     */
+    getRowTickRanges: () => readonly BoundedAxisRange[];
+}
+export declare function isTickRangeSelection(selection: Selection): selection is Selection & TickRangeSelection;
+/**
+ * Immutable transformations of a `Selection` that need no external context.
+ * Each method returns a new `Selection`; the receiver is never modified.
+ */
+export interface SelectionTransforms {
+    /** A fresh empty selection with no committed state, overlay, or anchor. */
+    clear: () => Selection;
+    /**
+     * A new selection keeping only the last committed range (for
+     * `RangedSelection`) or clearing committed keys (for `KeyedSelection`).
+     * Called by `Grid.trimSelectedRanges` immediately before shift-based
+     * extend so the anchor is preserved.
+     */
+    trimmed: () => Selection;
+    /** A new selection covering the entire grid. */
+    selectAll: () => Selection;
+    /** A new selection containing at most `maxRows` rows. */
+    truncate: (maxRows: number) => Selection;
+}
+/**
+ * Programmatic write path: install a caller-supplied set of ranges as the
+ * committed selection. Used by `Grid.setSelectedRanges`, `setFocusRow`, and
+ * `moveCursorInDirection`. Distinct from gesture-driven writes, which are
+ * being reworked in the `MouseSelection` / `KeyboardSelection` interfaces.
+ */
+export interface ProgrammaticSelection {
+    /**
+     * Replaces the committed selection with the given ranges and clears any
+     * transient overlay state. When `anchor` is provided, sets the gesture
+     * anchor (extend-from position for shift-click and keyboard extend) to
+     * the given cell; otherwise clears it.
+     */
+    withCommittedRanges: (ranges: readonly GridRange[], anchor?: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }) => Selection;
+}
+/**
+ * Modifier-key-derived mode for a mouse gesture:
+ * - `replace` — plain click: clear the current selection and install a
+ *   single cell at the cursor.
+ * - `add` — ctrl/meta click: keep the current selection and add a single
+ *   cell at the cursor.
+ * - `extend` — shift click / drag: trim to the last range and extend it
+ *   from the gesture anchor to the cursor.
+ * - `maximize` — ctrl+shift click: keep all ranges, grow the last range
+ *   to include the cursor.
+ */
+export type GestureMode = 'replace' | 'add' | 'extend' | 'maximize';
+/** Options for `MouseSelection.withGestureExtend`. */
+export type GestureExtendOptions = {
+    /** How the current selection should be combined with the incoming cursor. */
+    mode: GestureMode;
+    /** Full-row selection mode (theme `autoSelectRow`). */
+    autoSelectRow: boolean;
+    /** Full-column selection mode (theme `autoSelectColumn`). */
+    autoSelectColumn: boolean;
+};
+/** Options for `MouseSelection.commitGesture`. */
+export type CommitGestureOptions = {
+    /**
+     * When true, a single-row commit that repeats the previous single-row
+     * selection is treated as a deselect. Matches the `autoSelectRow` theme
+     * flag semantic.
+     */
+    autoSelectRow: boolean;
+    /**
+     * Post-commit cursor position. When `settled` is non-empty and this
+     * cursor falls outside it, `commitGesture` substitutes a landing cell
+     * from the pre-commit selection. When `settled` is empty, this cursor
+     * is preserved on the returned selection (matches Escape semantics).
+     * Omit for no-op commits that shouldn't touch cursor.
+     */
+    cursor?: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    };
+    /**
+     * When true (default), a commit whose settled ranges match the previous
+     * single-row / single-cell committed selection is treated as a deselect.
+     * This is the mouse click-to-deselect affordance. Keyboard callers pass
+     * `false` so arrowing onto an already-selected cell just moves the cursor
+     * instead of clearing the selection.
+     */
+    allowDeselect?: boolean;
+    /**
+     * When true (default), the commit finalizes the gesture: deselect check,
+     * hole-punch on overlap, and range consolidation all run. Pass `false`
+     * from mouse-down so those steps defer to mouse-up; between them the
+     * drag can grow the last range without eagerly fragmenting the prior
+     * selection.
+     */
+    settle?: boolean;
+};
+/**
+ * Mouse-driven selection updates. Both `withGestureExtend` and
+ * `commitGesture` are called by `Grid`'s mouse handlers.
+ *
+ * A gesture starts on mouse-down, may extend across drag frames, and settles
+ * on mouse-up. Each drag frame calls `withGestureExtend` to update the
+ * transient overlay; `commitGesture` folds the overlay into the committed
+ * selection.
+ */
+export interface MouseSelection {
+    /**
+     * Applies a mouse gesture that moves the selection to `cursor` per `opts`.
+     * `mode` chooses replace / add / extend / maximize semantics based on the
+     * modifier keys the caller observed.
+     *
+     * Returns a transient overlay-updated selection. Caller controls when to
+     * `commitGesture` — mouse handlers commit on mouse-up only; a plain click
+     * commits immediately.
+     */
+    withGestureExtend: (cursor: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }, opts: GestureExtendOptions) => Selection;
+    /**
+     * Settles the current transient overlay into the committed selection.
+     * Handles consolidation, deselect-on-reclick, and subtract logic. Returns
+     * identity (`this`) when there is nothing to commit.
+     *
+     * `lastCommitted` is the selection state as it was BEFORE the current
+     * gesture began. Grid pins this in state at gesture-start so the
+     * deselect-on-reclick comparison stays stable across drag frames.
+     */
+    commitGesture: (lastCommitted: Selection, opts: CommitGestureOptions) => Selection;
+}
+/**
+ * Keyboard-driven selection queries. Grid's key handlers use these to advance
+ * the cursor within the current selection (Tab/Enter) and to place the cursor
+ * after a commit or programmatic install.
+ */
+export interface KeyboardSelection {
+    /**
+     * Returns the next cursor cell in `direction` starting from `current`.
+     * When the selection is empty or has exactly one cell, walks the whole
+     * grid (wrapping at edges) so a lone Tab still moves the cursor.
+     * Otherwise cycles through the currently selected ranges.
+     */
+    getNextCursorInDirection: (current: {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    }, direction: SELECTION_DIRECTION) => {
+        row: GridRangeIndex;
+        column: GridRangeIndex;
+    } | null;
+    /**
+     * A new selection with the cursor set to `(column, row)`. Passing `null`
+     * for both clears the cursor. Non-cursor state (ranges, keys, anchor,
+     * selection endpoint) is preserved.
+     */
+    withCursor: (row: VisibleIndex | null, column: VisibleIndex | null) => Selection;
+    /**
+     * A new selection with the shift/drag endpoint set to `(column, row)`.
+     * Passing `null` for both clears the endpoint. Non-endpoint state
+     * (ranges, keys, anchor, cursor) is preserved.
+     */
+    withSelectionEnd: (row: VisibleIndex | null, column: VisibleIndex | null) => Selection;
+}

package/dist/TableViewer.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type GridTheme } from './GridTheme';
+import { type ViewerChannel } from '@kermodes/client';
+export type TableViewerProps = {
+    channel: ViewerChannel;
+    theme: GridTheme;
+    maxGridHeight?: number;
+    follow?: boolean;
+};
+/**
+ * The table viewer (architecture.md §15.3): the canvas grid over a viewport of
+ * an engine table, with header sort, quick filters, copy, change highlighting,
+ * and a status line. Talks to the engine only through `channel`.
+ */
+export declare function TableViewer({ channel, theme, maxGridHeight, follow, }: TableViewerProps): React.ReactElement;
+export default TableViewer;

package/dist/TableViewerGrid.d.ts

@@ -0,0 +1,16 @@
+import GridMetricCalculator, { type GridMetricState } from './GridMetricCalculator';
+import { type ModelIndex, type VisibleIndex } from './GridMetrics';
+import GridRenderer from './GridRenderer';
+import { type GridRenderState } from './GridRendererTypes';
+/** Column widths leave room in the header for the sort indicator, so sorting never resizes */
+export declare class TableViewerMetricCalculator extends GridMetricCalculator {
+    calculateColumnHeaderWidth(modelColumn: ModelIndex, state: GridMetricState, maxColumnWidth: number): number;
+}
+/** Draws the sort in the headers and flashes over changed or copied cells */
+export declare class TableViewerRenderer extends GridRenderer {
+    drawColumnHeaderAtIndex(context: CanvasRenderingContext2D, state: GridRenderState, index: VisibleIndex, bounds: {
+        minX: number;
+        maxX: number;
+    }): void;
+    drawCellBackgrounds(context: CanvasRenderingContext2D, state: GridRenderState): void;
+}

package/dist/TextCellRenderer.d.ts

@@ -0,0 +1,8 @@
+import { type VisibleIndex } from './GridMetrics';
+import { type GridRenderState } from './GridRendererTypes';
+declare class TextCellRenderer {
+    drawCellContent(context: CanvasRenderingContext2D, state: GridRenderState, column: VisibleIndex, row: VisibleIndex): void;
+    private cachedTruncateToWidth;
+    getCachedTruncatedString: (context: CanvasRenderingContext2D, text: string, width: number, fontWidthLower?: number, fontWidthUpper?: number, truncationChar?: string) => string;
+}
+export default TextCellRenderer;

package/dist/ThemeContext.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type GridTheme as GridThemeType } from './GridTheme';
+export type ThemeContextValue = Partial<GridThemeType>;
+export declare const ThemeContext: React.Context<ThemeContextValue>;
+export default ThemeContext;

package/dist/ValuePopover.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { type ShownValue } from './cellValue';
+/** Where a cell is, relative to the positioned parent the popover is drawn in */
+export type CellRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type ValuePopoverProps = {
+    cell: CellRect;
+    column: string;
+    type: string;
+    value: ShownValue;
+    onCopy: (text: string) => void;
+    onClose: () => void;
+};
+/**
+ * A cell's whole value under it (above it where there is no room below): JSON pretty-printed,
+ * selectable, with Copy. Escape or a click elsewhere closes it.
+ */
+export declare function ValuePopover({ cell, column, type, value, onCopy, onClose, }: ValuePopoverProps): React.ReactElement;
+export default ValuePopover;

package/dist/ViewportGridModel.d.ts

@@ -0,0 +1,92 @@
+import { type Table } from 'apache-arrow';
+import GridModel from './GridModel';
+import { type ModelIndex } from './GridMetrics';
+import { type GridColor, type GridTheme, type NullableGridColor } from './GridTheme';
+import { type SortKey, type ViewportColumn } from '@kermodes/client';
+/** How long a changed or copied cell stays highlighted */
+export declare const FLASH_DURATION_MS = 600;
+export declare function isNumericType(type: string): boolean;
+/** Format one non-null cell value of a column of `type` */
+export declare function formatValue(type: string, value: unknown): string;
+/** A pushed window of rows: their keys and a reader of their values */
+export type RowWindow = {
+    keys: ArrayLike<bigint>;
+    value: (column: number, index: number) => unknown;
+};
+/**
+ * The cells of `next` whose value differs from the same row (by key) in `previous`.
+ * Rows that are new to `next` are not changes, however they got there (scrolled
+ * into view, filtered in), and neither are rows that only moved.
+ * @returns Pairs of row index in `next` and column
+ */
+export declare function changedCells(previous: RowWindow, next: RowWindow, columnCount: number): Array<[index: number, column: number]>;
+/**
+ * A grid model over a window of a larger table: the column list, the table's
+ * total row count, and the rows at positions `start..start + window.numRows`
+ * decoded from Arrow, with the key of each row. Rows outside the window read
+ * as empty (still loading). Also holds what the header shows (the sort) and
+ * which cells are flashing.
+ */
+export declare class ViewportGridModel extends GridModel {
+    private viewColumns;
+    private totalRowCount;
+    private windowStart;
+    private windowRowCount;
+    private vectors;
+    private keys;
+    private keyIndex;
+    private textCache;
+    private sort;
+    private flashes;
+    private listeners;
+    constructor(columns?: readonly ViewportColumn[], rowCount?: number);
+    get rowCount(): number;
+    get columnCount(): number;
+    get columns(): readonly ViewportColumn[];
+    /** First row position held in the window */
+    get start(): number;
+    /** Call `listener` after every change; returns the function that stops it */
+    subscribe(listener: () => void): () => void;
+    private notify;
+    /** Replace the column list. Drops the window, whose columns no longer match. */
+    setColumns(columns: readonly ViewportColumn[]): void;
+    /** Set the total row count of the table */
+    setRowCount(rowCount: number): void;
+    /**
+     * Replace the window with the rows of `table`, which start at row position
+     * `start`, hold the columns in `columns` order, and have the given keys.
+     * Cells whose value changed since the last window, for the same key, flash.
+     */
+    setWindow(start: number, table: Table, keys: BigUint64Array, now?: number): void;
+    private rowWindow;
+    private clearWindow;
+    /** Set the sort the header shows */
+    setSort(sort: readonly SortKey[]): void;
+    get sortKeys(): readonly SortKey[];
+    /** The sort key on `column` and its 1-based priority, or null when unsorted */
+    sortForColumn(column: ModelIndex): {
+        descending: boolean;
+        priority: number;
+    } | null;
+    /** Whether the row at `row` has arrived */
+    isRowLoaded(row: ModelIndex): boolean;
+    /** The raw value at a cell: undefined when the row has not arrived, null for a null */
+    valueAt(column: ModelIndex, row: ModelIndex): unknown;
+    /** Start a flash on one cell, eg. to show it was copied */
+    flashCell(column: ModelIndex, row: ModelIndex, now?: number): void;
+    /** Whether any cell is still flashing at `now` */
+    hasFlashes(now?: number): boolean;
+    /**
+     * Call `draw` for each flashing cell in the window with how far its flash has
+     * faded, from 0 (just started) to 1 (gone).
+     */
+    forEachFlash(now: number, draw: (column: ModelIndex, row: ModelIndex, progress: number) => void): void;
+    private pruneFlashes;
+    textForColumnHeader(column: ModelIndex): string;
+    textForCell(column: ModelIndex, row: ModelIndex): string;
+    textAlignForCell(column: ModelIndex): CanvasTextAlign;
+    /** Numbers by sign and dates in their theme colours, after Deephaven's grid */
+    colorForCell(column: ModelIndex, row: ModelIndex, theme: GridTheme): GridColor;
+    backgroundColorForCell(column: ModelIndex, row: ModelIndex, theme: GridTheme): NullableGridColor;
+}
+export default ViewportGridModel;

package/dist/cellValue.d.ts

@@ -0,0 +1,11 @@
+/** A cell's whole value as the value popover shows it */
+export type ShownValue = {
+    text: string;
+    isJson: boolean;
+};
+/**
+ * `value` in full: text holding a JSON object or array pretty-printed with two-space indents,
+ * anything else as copying it would give (numbers unrounded, dates in full). A null is the
+ * word null, so an empty popover never means "no value".
+ */
+export declare function shownValue(type: string, value: unknown): ShownValue;

package/dist/copy.d.ts

@@ -0,0 +1,29 @@
+import GridRange from './GridRange';
+import { type VisibleIndex } from './GridMetrics';
+import { type ViewportColumn } from '@kermodes/client';
+/** The most rows one copy takes; bigger selections copy their first rows */
+export declare const COPY_ROW_LIMIT = 100000;
+/** A cell's value as copied: displayed text, numbers raw (no thousands separators), nulls empty */
+export declare function copyValue(type: string, value: unknown): string;
+/** One field of tab-separated text, quoted when it holds a tab, line break, or quote */
+export declare function tsvField(text: string): string;
+export declare function toTsv(rows: readonly (readonly string[])[]): string;
+/** Which cells a copy of the selected ranges takes */
+export type CopyPlan = {
+    rows: number[];
+    columns: VisibleIndex[];
+    isCapped: boolean;
+    selectedRowCount: number;
+    contains: (column: VisibleIndex, row: number) => boolean;
+};
+export declare function planCopy(ranges: readonly GridRange[], columnCount: number, rowCount: number, limit?: number): CopyPlan;
+/**
+ * The tab-separated text of a copy: one line per row of the plan, optionally
+ * after a line of column names.
+ */
+export declare function copyText(plan: CopyPlan, columns: readonly ViewportColumn[], modelColumnOf: (column: VisibleIndex) => number, valueAt: (modelColumn: number, row: number) => unknown, includeHeader: boolean): string;
+/**
+ * Put `text` on the clipboard. Notebook front ends can run outputs in frames
+ * that deny the clipboard API, so fall back to copying from a hidden textarea.
+ */
+export declare function writeClipboard(text: string): Promise<void>;

package/dist/cover.d.ts

@@ -0,0 +1,16 @@
+import { type ViewerState } from '@kermodes/client';
+/**
+ * What covers a viewer's rows when they are not current (docs/theme.md, "Live data states"):
+ * a failure in their place, skeleton rows before the first arrive, or the rows dimmed under a
+ * spinner while something brings them up to date. Current rows are covered by nothing.
+ */
+export type Cover = {
+    kind: 'failed';
+    message: string;
+} | {
+    kind: 'skeleton';
+} | {
+    kind: 'busy';
+    label: string;
+} | null;
+export declare function viewerCover(state: Pick<ViewerState, 'status' | 'error' | 'retrying'>, hasRows: boolean, isUpdating: boolean): Cover;

package/dist/errors/AssertionError.d.ts

@@ -0,0 +1,4 @@
+export declare class AssertionError extends Error {
+    isAssertionFailed: boolean;
+}
+export default AssertionError;

package/dist/errors/assertIsDefined.d.ts

@@ -0,0 +1,2 @@
+export declare function assertIsDefined<T>(val: T): asserts val is NonNullable<T>;
+export default assertIsDefined;

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { default as assertIsDefined } from './assertIsDefined';
+export { default as AssertionError } from './AssertionError';

package/dist/fastMemoize.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A minimal memoizer for the hot per cell render paths.
+ *
+ * `memoizeClear` wraps memoizee, which routes every call through a
+ * configurable argument resolver, a nested lookup structure and an LRU queue
+ * that has to be reordered on each hit. That is a reasonable trade for
+ * occasional calls, but a function invoked once per visible cell of every
+ * frame pays it tens of thousands of times a second: profiling a grid scroll
+ * found more time spent inside memoizee than in the truncation and
+ * tokenization it was caching.
+ *
+ * This keeps a tree of `Map`s with one level per argument, keyed on the
+ * argument values themselves. The arguments are deliberately not combined
+ * into a single string key: cell text can be tens of thousands of characters,
+ * and a freshly built key would have to be copied, hashed and retained on
+ * every call. Keying on the original string lets the engine reuse the hash it
+ * caches on that string, so a lookup stays cheap however long the text is.
+ * `Map` compares with SameValueZero, so primitives match by value and objects,
+ * functions and symbols by identity.
+ *
+ * There is no eviction queue to maintain because the entire cache is dropped
+ * once it fills, which is the behaviour `memoizeClear` already settled on to
+ * avoid LRU thrashing.
+ *
+ * The returned function does not forward `this`, so the memoized function must
+ * not depend on it.
+ */
+/**
+ * Longest string V8 hashes by content (`String::kMaxHashCalcLength`). Longer
+ * strings are hashed by their length alone, so long cells that only differ
+ * near the end, such as a long text with a row number appended, all share a
+ * bucket and every lookup compares them character by character. Callers that
+ * can receive strings this long should key on only the part they read.
+ */
+export declare const MAX_HASHED_STRING_LENGTH = 16383;
+/**
+ * Entries for a cache that is hit once per visible cell. If a single frame
+ * draws more distinct cells than the cache holds, it clears partway through
+ * every frame and never serves a hit. A maximized grid with minimum width
+ * columns shows about 7,500 cells on a 4K display and 13,500 on a 5K display
+ * at 100% scaling, so this leaves room for larger displays too.
+ */
+export declare const CELL_CACHE_SIZE = 50000;
+/**
+ * @param fn The function to memoize. Must not depend on `this`
+ * @param max Number of entries to hold before clearing the whole cache
+ * @returns The memoized function
+ */
+export declare function fastMemoize<A extends unknown[], R>(fn: (...args: A) => R, max: number): (...args: A) => R;
+export default fastMemoize;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { default as Grid } from './Grid';
+export * from './Grid';
+export * from './GridMetricCalculator';
+export * from './GridMetrics';
+export { default as GridModel } from './GridModel';
+export { default as GridMouseHandler } from './GridMouseHandler';
+export * from './GridMouseHandler';
+export { default as KeyHandler } from './KeyHandler';
+export * from './KeyHandler';
+export * from './EventHandlerResult';
+export * from './GridRange';
+export * from './GridAxisRange';
+export * from './GridRenderer';
+export * from './GridRendererTypes';
+export * from './GridTheme';
+export * from './GridUtils';
+export * from './Selection';
+export * from './GridSelectionUtils';
+export { RangedSelection, isRangedSelection, assertIsRangedSelection, selectionToRanges, } from './RangedSelection';
+export * from './ThemeContext';
+export * from './ColumnHeaderGroup';
+export * from './key-handlers';
+export * from './mouse-handlers';
+export * from './errors';
+export { injectGridStyles } from './GridStyles';
+export * from './ViewportGridModel';
+export { TableViewer, type TableViewerProps } from './TableViewer';
+export { TableViewerMetricCalculator, TableViewerRenderer } from './TableViewerGrid';
+export * from './FilterBar';
+export * from './sorting';
+export * from './copy';
+export * from './cellValue';