@kermodes/grid 0.0.0-stage → 0.3.13-dev.71.ge96feae

package/dist/key-handlers/SelectionKeyHandler.d.ts

@@ -0,0 +1,11 @@
+import { type EventHandlerResult } from '../EventHandlerResult';
+import type Grid from '../Grid';
+import KeyHandler, { type GridKeyboardEvent } from '../KeyHandler';
+declare class SelectionKeyHandler extends KeyHandler {
+    onDown(event: GridKeyboardEvent, grid: Grid): EventHandlerResult;
+    handleArrowMove(deltaColumn: number, deltaRow: number, event: GridKeyboardEvent, grid: Grid): boolean;
+    handleRowEdge(targetColumn: number, event: GridKeyboardEvent, grid: Grid): boolean;
+    handlePageUp(e: GridKeyboardEvent, grid: Grid): boolean;
+    handlePageDown(e: GridKeyboardEvent, grid: Grid): boolean;
+}
+export default SelectionKeyHandler;

package/dist/key-handlers/index.d.ts

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

package/dist/menuItems.d.ts

@@ -0,0 +1,53 @@
+import { type SortKey } from '@kermodes/client';
+/** What a menu item does; the viewer carries it out */
+export type MenuAction = {
+    type: 'sort';
+    by: SortKey[];
+} | {
+    type: 'filter';
+    column: string;
+    text: string;
+} | {
+    type: 'edit-filter';
+    column: string;
+} | {
+    type: 'clear-filters';
+} | {
+    type: 'copy-cell';
+} | {
+    type: 'show-value';
+} | {
+    type: 'copy-selection';
+    header: boolean;
+} | {
+    type: 'copy-text';
+    text: string;
+};
+export type MenuItem = {
+    label: string;
+    action: MenuAction;
+    hint?: string;
+};
+/**
+ * What was right-clicked: a column header, or a cell with its raw value (null
+ * for a null) and the text the grid shows for it.
+ */
+export type MenuTarget = {
+    kind: 'header';
+    column: string;
+    type: string;
+} | {
+    kind: 'cell';
+    column: string;
+    type: string;
+    value: unknown;
+    text: string;
+};
+/** The view the menu acts on */
+export type MenuView = {
+    sort: readonly SortKey[];
+    filters: Readonly<Record<string, string>>;
+    isSelectionWide: boolean;
+};
+/** The menu for `target`, in sections separated by rules */
+export declare function contextMenu(target: MenuTarget, view: MenuView): MenuItem[][];

package/dist/mouse-handlers/GridColumnMoveMouseHandler.d.ts

@@ -0,0 +1,50 @@
+import type Grid from '../Grid';
+import { type GridPoint } from '../GridUtils';
+import GridMouseHandler, { type GridMouseEvent } from '../GridMouseHandler';
+import { type EventHandlerResult } from '../EventHandlerResult';
+import type { VisibleIndex, MoveOperation, Coordinate } from '../GridMetrics';
+import type { BoundedAxisRange } from '../GridAxisRange';
+export interface DraggingColumn {
+    range: BoundedAxisRange;
+    depth: number;
+    left: Coordinate;
+    width: number;
+}
+interface ColumnInfo {
+    visibleIndex: VisibleIndex;
+    left: number;
+    right: number;
+    width: number;
+}
+declare class GridColumnMoveMouseHandler extends GridMouseHandler {
+    cursor: string | null;
+    private draggingOffset?;
+    private initialOffset?;
+    private initialGridPoint?;
+    private scrollingInterval?;
+    private scrollingDirection?;
+    private draggingColumn;
+    private setScrollInterval;
+    private clearScrollInterval;
+    onLeave(): EventHandlerResult;
+    onDown(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onDrag(gridPoint: GridPoint, grid: Grid, event: GridMouseEvent): EventHandlerResult;
+    /**
+     * Moves a dragging column, if possible, the specified distance
+     * @param mouseX The point the move was initiated from
+     * @param grid The Grid component
+     * @param deltaX The distance of the move
+     */
+    moveDraggingColumn(mouseX: number, grid: Grid, deltaX: number): void;
+    /**
+     * Applies the column move and updates draggingColumn in the mouse handler
+     * Does not check if the move is valid
+     * @param draggingColumn The dragging column info
+     * @param to The index to move the column to
+     * @param movedColumns The array of column moves
+     * @returns A new array of column moves
+     */
+    moveColumn(draggingColumn: ColumnInfo, to: number, movedColumns: readonly MoveOperation[]): readonly MoveOperation[];
+    onUp(_gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+}
+export default GridColumnMoveMouseHandler;

package/dist/mouse-handlers/GridColumnSeparatorMouseHandler.d.ts

@@ -0,0 +1,27 @@
+import type Grid from '../Grid';
+import type GridMetricCalculator from '../GridMetricCalculator';
+import type { ModelIndex, GridMetrics } from '../GridMetrics';
+import type GridModel from '../GridModel';
+import type { GridTheme } from '../GridTheme';
+import GridUtils, { type GridPoint } from '../GridUtils';
+import GridSeparatorMouseHandler, { type GridSeparator } from './GridSeparatorMouseHandler';
+declare class GridColumnSeparatorMouseHandler extends GridSeparatorMouseHandler {
+    static getColumnSeparator(gridPoint: GridPoint, metrics: GridMetrics, model: GridModel, theme: GridTheme): GridSeparator | null;
+    hiddenCursor: string;
+    defaultCursor: string;
+    pointProperty: 'x';
+    userSizesProperty: 'userColumnWidths';
+    visibleOffsetProperty: 'visibleColumnXs';
+    visibleSizesProperty: 'visibleColumnWidths';
+    marginProperty: 'rowHeaderWidth';
+    calculatedSizesProperty: 'calculatedColumnWidths';
+    initialSizesProperty: 'initialColumnWidths';
+    modelIndexesProperty: 'modelColumns';
+    getHiddenItems: typeof GridUtils.getHiddenColumns;
+    getNextShownItem: typeof GridUtils.getNextShownColumn;
+    setSize(metricCalculator: GridMetricCalculator, modelIndex: ModelIndex, size: number): void;
+    resetSize(metricCalculator: GridMetricCalculator, modelIndex: ModelIndex): void;
+    updateSeparator(grid: Grid, separator: GridSeparator | null): void;
+    getSeparator: typeof GridColumnSeparatorMouseHandler.getColumnSeparator;
+}
+export default GridColumnSeparatorMouseHandler;

package/dist/mouse-handlers/GridHorizontalScrollBarMouseHandler.d.ts

@@ -0,0 +1,24 @@
+import { type EventHandlerResult } from '../EventHandlerResult';
+import type Grid from '../Grid';
+import { type VisibleIndex } from '../GridMetrics';
+import GridMouseHandler from '../GridMouseHandler';
+import { type GridPoint } from '../GridUtils';
+declare class GridHorizontalScrollBarMouseHandler extends GridMouseHandler {
+    static getLeftWithOffsetFromRawLeft(grid: Grid, rawLeft: number): {
+        left: VisibleIndex;
+        leftOffset: number;
+    };
+    private dragOffset?;
+    cursor: string;
+    isInScrollBar(gridPoint: GridPoint, grid: Grid): boolean;
+    getLeftWithOffset(gridPoint: GridPoint, grid: Grid): {
+        left: number;
+        leftOffset: number;
+    };
+    onDown(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onDrag(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onMove(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onUp(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onClick(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+}
+export default GridHorizontalScrollBarMouseHandler;

package/dist/mouse-handlers/GridScrollBarCornerMouseHandler.d.ts

@@ -0,0 +1,14 @@
+import { type EventHandlerResult } from '../EventHandlerResult';
+import type Grid from '../Grid';
+import GridMouseHandler from '../GridMouseHandler';
+import { type GridPoint } from '../GridUtils';
+/**
+ * Used to eat the mouse event in the bottom right corner of the scroll bar
+ */
+declare class GridScrollBarCornerMouseHandler extends GridMouseHandler {
+    isInCorner(gridPoint: GridPoint, grid: Grid): boolean;
+    onDown(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onUp(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onClick(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+}
+export default GridScrollBarCornerMouseHandler;

package/dist/mouse-handlers/GridSelectionMouseHandler.d.ts

@@ -0,0 +1,19 @@
+import { type EventHandlerResult } from '../EventHandlerResult';
+import type Grid from '../Grid';
+import GridMouseHandler, { type GridMouseEvent } from '../GridMouseHandler';
+import { type GridPoint } from '../GridUtils';
+declare class GridSelectionMouseHandler extends GridMouseHandler {
+    private startPoint?;
+    private hasExtendedFloating;
+    private timer?;
+    private lastTriggerTime?;
+    onDown(gridPoint: GridPoint, grid: Grid, event: GridMouseEvent): EventHandlerResult;
+    onDrag(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onUp(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onDoubleClick(gridPoint: GridPoint, grid: Grid, event: GridMouseEvent): EventHandlerResult;
+    onContextMenu(gridPoint: GridPoint, grid: Grid, event: GridMouseEvent): EventHandlerResult;
+    moveSelection(grid: Grid, gridPoint: GridPoint, deltaX: number, deltaY: number): void;
+    startTimer(grid: Grid, gridPoint: GridPoint, deltaX: number, deltaY: number): void;
+    stopTimer(): void;
+}
+export default GridSelectionMouseHandler;

package/dist/mouse-handlers/GridSeparatorMouseHandler.d.ts

@@ -0,0 +1,61 @@
+import type Grid from '../Grid';
+import type { GridMetricCalculator } from '../GridMetricCalculator';
+import type GridModel from '../GridModel';
+import { type EventHandlerResult } from '../EventHandlerResult';
+import { type ModelIndex, type VisibleIndex } from '../GridMetrics';
+import type GridMetrics from '../GridMetrics';
+import GridMouseHandler from '../GridMouseHandler';
+import type { GridTheme } from '../GridTheme';
+import type { GridPoint } from '../GridUtils';
+export type PointProperty = 'x' | 'y';
+export type UserSizeProperty = 'userRowHeights' | 'userColumnWidths';
+export type VisibleOffsetProperty = 'visibleRowYs' | 'visibleColumnXs';
+export type VisibleSizeProperty = 'visibleRowHeights' | 'visibleColumnWidths';
+export type MarginProperty = 'columnHeaderHeight' | 'rowHeaderWidth';
+export type CalculatedSizeProperty = 'calculatedRowHeights' | 'calculatedColumnWidths';
+export type InitialSizeProperty = 'initialRowHeights' | 'initialColumnWidths';
+export type ModelIndexesProperty = 'modelRows' | 'modelColumns';
+export interface GridSeparator {
+    index: VisibleIndex;
+    depth: number;
+}
+/**
+ * Abstract class that should be extended for column/row behavior
+ * Override the necessary functions/properties
+ */
+declare abstract class GridSeparatorMouseHandler extends GridMouseHandler {
+    protected draggingIndex?: VisibleIndex;
+    protected resizingItems: VisibleIndex[];
+    protected hiddenItems: VisibleIndex[];
+    protected targetSizes: Map<VisibleIndex, number>;
+    protected dragOffset: number;
+    abstract hiddenCursor: string;
+    abstract defaultCursor: string;
+    abstract pointProperty: PointProperty;
+    abstract userSizesProperty: UserSizeProperty;
+    abstract visibleOffsetProperty: VisibleOffsetProperty;
+    abstract visibleSizesProperty: VisibleSizeProperty;
+    abstract marginProperty: MarginProperty;
+    abstract calculatedSizesProperty: CalculatedSizeProperty;
+    abstract initialSizesProperty: InitialSizeProperty;
+    abstract modelIndexesProperty: ModelIndexesProperty;
+    abstract getHiddenItems(itemIndex: VisibleIndex, metrics: GridMetrics): VisibleIndex[];
+    abstract getNextShownItem(itemIndex: VisibleIndex, metrics: GridMetrics): VisibleIndex | null;
+    abstract setSize(metricCalculator: GridMetricCalculator, modelIndex: ModelIndex, size: number): void;
+    abstract resetSize(metricCalculator: GridMetricCalculator, modelIndex: ModelIndex): void;
+    abstract updateSeparator(grid: Grid, separator: GridSeparator | null): void;
+    abstract getSeparator(gridPoint: GridPoint, metrics: GridMetrics, model: GridModel, theme: GridTheme): GridSeparator | null;
+    onDown(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onMove(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onDrag(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onUp(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onDoubleClick(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    updateCursor(metrics: GridMetrics, itemIndex: VisibleIndex): void;
+    /**
+     * Record the size the item should snap back to while dragging.
+     * @returns False if the item has no metrics to derive a target size from
+     */
+    addTargetSize(metrics: GridMetrics, itemIndex: VisibleIndex): boolean;
+    removeTargetSize(itemIndex: VisibleIndex): void;
+}
+export default GridSeparatorMouseHandler;

package/dist/mouse-handlers/GridVerticalScrollBarMouseHandler.d.ts

@@ -0,0 +1,24 @@
+import { type EventHandlerResult } from '../EventHandlerResult';
+import type Grid from '../Grid';
+import { type VisibleIndex } from '../GridMetrics';
+import GridMouseHandler from '../GridMouseHandler';
+import { type GridPoint } from '../GridUtils';
+declare class GridVerticalScrollBarMouseHandler extends GridMouseHandler {
+    static getTopWithOffsetFromRawTop(grid: Grid, rawTop: number): {
+        top: VisibleIndex;
+        topOffset: number;
+    };
+    private dragOffset?;
+    cursor: string;
+    isInScrollBar(gridPoint: GridPoint, grid: Grid): boolean;
+    getTopWithOffset(gridPoint: GridPoint, grid: Grid): {
+        top: number;
+        topOffset: number;
+    };
+    onDown(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onMove(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onDrag(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onUp(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+    onClick(gridPoint: GridPoint, grid: Grid): EventHandlerResult;
+}
+export default GridVerticalScrollBarMouseHandler;

package/dist/mouse-handlers/index.d.ts

@@ -0,0 +1,8 @@
+export { default as GridSelectionMouseHandler } from './GridSelectionMouseHandler';
+export { default as GridColumnSeparatorMouseHandler } from './GridColumnSeparatorMouseHandler';
+export { default as GridHorizontalScrollBarMouseHandler } from './GridHorizontalScrollBarMouseHandler';
+export { default as GridScrollBarCornerMouseHandler } from './GridScrollBarCornerMouseHandler';
+export { default as GridVerticalScrollBarMouseHandler } from './GridVerticalScrollBarMouseHandler';
+export * from './GridSeparatorMouseHandler';
+export { default as GridColumnMoveMouseHandler } from './GridColumnMoveMouseHandler';
+export type { DraggingColumn } from './GridColumnMoveMouseHandler';

package/dist/sorting.d.ts

@@ -0,0 +1,19 @@
+import { type SortKey } from '@kermodes/client';
+/**
+ * The sort after clicking the header of `column`. Each click cycles the column
+ * ascending → descending → unsorted. A plain click makes it the only key; an
+ * additive (shift) click cycles it in place, appending it as the last key if it
+ * was unsorted, and keeps the other keys.
+ */
+export declare function nextSort(sort: readonly SortKey[], column: string, additive: boolean): SortKey[];
+/**
+ * What the viewer shows on an engine report. `sent` is the number of the last
+ * sort or filter sent, `applied` the highest the engine reports done: until it
+ * catches up the rows predate a change, which can take seconds on a big table,
+ * so they are `pending` and the header keeps the sort `asked` for (`null` if
+ * none was) rather than flip back to the old one the reports still carry.
+ */
+export declare function shownView(sent: number, applied: number, asked: readonly SortKey[] | null, reported: readonly SortKey[]): {
+    pending: boolean;
+    sort: readonly SortKey[];
+};

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+export declare const EMPTY_ARRAY: readonly never[];
+export declare function clamp(value: number, lower: number, upper: number): number;
+export declare function assertNotNull<T>(value: T | null | undefined, message?: string): asserts value is T;
+export declare function assertNotNaN(value: number, message?: string): void;
+/**
+ * Retrieve a value from a map. If the value is not found and no default value is provided, throw.
+ * Use when the value _must_ be present
+ * @param map The map to get the value from
+ * @param key The key to fetch the value for
+ * @param defaultValue A default value to set if the key is not present
+ * @returns The value set for that key
+ */
+export declare function getOrThrow<K, V>(map: ReadonlyMap<K, V>, key: K, defaultValue?: V | undefined): V;
+/** Keys whose values differ (by identity) between two objects */
+export declare function getChangedKeys(oldObject: object, newObject: object): string[];

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@kermodes/grid",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.13-dev.71.ge96feae",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reecetec/kermodes.git",
+    "directory": "web/grid"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@kermodes/client": "0.3.13-dev.71.ge96feae",
+    "apache-arrow": "^21.0.0",
+    "classnames": "^2.5.1",
+    "memoize-one": "^6.0.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.