@deephaven/iris-grid 1.28.0 → 1.29.0

package/dist/KeyedSelection.js

@@ -0,0 +1,699 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { EMPTY_ARRAY, EMPTY_MAP } from '@deephaven/utils';
+import { computeGestureExtend, cursorLandingCellForRanges, nextCursorInRanges, withCommittedCursor } from '@deephaven/grid';
+/**
+ * Serializes key-column values to a stable string for use as a Map/Set key.
+ * JSON.stringify encodes NaN, Infinity, and -Infinity as null, so we
+ * substitute sentinel strings to preserve their distinct identities.
+ */
+export function serializeKeyValues(values) {
+  return JSON.stringify(values, (_key, value) => {
+    if (typeof value === 'number') {
+      if (Number.isNaN(value)) return '__NaN__';
+      if (value === Infinity) return '__Infinity__';
+      if (value === -Infinity) return '__-Infinity__';
+    }
+    return value;
+  });
+}
+
+/**
+ * Configuration for a `KeyedSelection`. `getModel` is required; every
+ * other field defaults to an "empty" value (`null`, an empty set/map, or
+ * `false` where appropriate).
+ */
+
+/**
+ * Immutable `Selection` for keyed tables: identifies rows by their
+ * serialized key-column values rather than raw row indices, so the
+ * selection survives ticks that shuffle row positions.
+ *
+ * Rows sharing the same key highlight together (see `isRowSelected`).
+ * When `invertedSelection` is true, `selectedKeys` is treated as an
+ * exclusion set (all rows selected except those keys).
+ */
+export class KeyedSelection {
+  static empty(getModel) {
+    return new KeyedSelection({
+      getModel
+    });
+  }
+  constructor(options) {
+    var _options$selectedKeys, _options$overlayRange, _options$invertedSele, _options$selectedKeyV, _options$maxRows, _options$pendingRange, _options$anchorKey, _options$anchorRow, _options$cursorKey, _options$cursorRowHin, _options$cursorColumn, _options$selectionEnd, _options$selectionEnd2, _options$selectionEnd3;
+    _defineProperty(this, "getModel", void 0);
+    _defineProperty(this, "selectedKeys", void 0);
+    _defineProperty(this, "overlayRanges", void 0);
+    _defineProperty(this, "invertedSelection", void 0);
+    _defineProperty(this, "selectedKeyValues", void 0);
+    _defineProperty(this, "maxRows", void 0);
+    _defineProperty(this, "pendingRanges", void 0);
+    _defineProperty(this, "anchorKey", void 0);
+    _defineProperty(this, "anchorRow", void 0);
+    _defineProperty(this, "cursorKey", void 0);
+    _defineProperty(this, "cursorRowHint", void 0);
+    _defineProperty(this, "cursorColumn", void 0);
+    _defineProperty(this, "selectionEndKey", void 0);
+    _defineProperty(this, "selectionEndRowHint", void 0);
+    _defineProperty(this, "selectionEndColumn", void 0);
+    /** Keys derived from the current overlay range's viewport-visible rows. */
+    _defineProperty(this, "gestureKeys", void 0);
+    this.getModel = options.getModel;
+    this.selectedKeys = (_options$selectedKeys = options.selectedKeys) !== null && _options$selectedKeys !== void 0 ? _options$selectedKeys : new Set();
+    this.overlayRanges = (_options$overlayRange = options.overlayRanges) !== null && _options$overlayRange !== void 0 ? _options$overlayRange : EMPTY_ARRAY;
+    this.invertedSelection = (_options$invertedSele = options.invertedSelection) !== null && _options$invertedSele !== void 0 ? _options$invertedSele : false;
+    this.selectedKeyValues = (_options$selectedKeyV = options.selectedKeyValues) !== null && _options$selectedKeyV !== void 0 ? _options$selectedKeyV : EMPTY_MAP;
+    this.maxRows = (_options$maxRows = options.maxRows) !== null && _options$maxRows !== void 0 ? _options$maxRows : null;
+    this.pendingRanges = (_options$pendingRange = options.pendingRanges) !== null && _options$pendingRange !== void 0 ? _options$pendingRange : EMPTY_ARRAY;
+    this.anchorKey = (_options$anchorKey = options.anchorKey) !== null && _options$anchorKey !== void 0 ? _options$anchorKey : null;
+    this.anchorRow = (_options$anchorRow = options.anchorRow) !== null && _options$anchorRow !== void 0 ? _options$anchorRow : null;
+    this.cursorKey = (_options$cursorKey = options.cursorKey) !== null && _options$cursorKey !== void 0 ? _options$cursorKey : null;
+    this.cursorRowHint = (_options$cursorRowHin = options.cursorRowHint) !== null && _options$cursorRowHin !== void 0 ? _options$cursorRowHin : null;
+    this.cursorColumn = (_options$cursorColumn = options.cursorColumn) !== null && _options$cursorColumn !== void 0 ? _options$cursorColumn : null;
+    this.selectionEndKey = (_options$selectionEnd = options.selectionEndKey) !== null && _options$selectionEnd !== void 0 ? _options$selectionEnd : null;
+    this.selectionEndRowHint = (_options$selectionEnd2 = options.selectionEndRowHint) !== null && _options$selectionEnd2 !== void 0 ? _options$selectionEnd2 : null;
+    this.selectionEndColumn = (_options$selectionEnd3 = options.selectionEndColumn) !== null && _options$selectionEnd3 !== void 0 ? _options$selectionEnd3 : null;
+
+    // Enumerate only viewport-visible rows so gesture key lookup stays O(1)
+    // and construction is O(viewport) regardless of total table size.
+    if (this.overlayRanges.length === 0) {
+      this.gestureKeys = new Set();
+    } else {
+      var _model$viewport$top, _model$viewport, _model$viewport$botto, _model$viewport2;
+      var model = this.getModel();
+      var viewTop = (_model$viewport$top = (_model$viewport = model.viewport) === null || _model$viewport === void 0 ? void 0 : _model$viewport.top) !== null && _model$viewport$top !== void 0 ? _model$viewport$top : 0;
+      var viewBottom = (_model$viewport$botto = (_model$viewport2 = model.viewport) === null || _model$viewport2 === void 0 ? void 0 : _model$viewport2.bottom) !== null && _model$viewport$botto !== void 0 ? _model$viewport$botto : 0;
+      var keys = new Set();
+      for (var i = 0; i < this.overlayRanges.length; i += 1) {
+        var _this$overlayRanges$i = this.overlayRanges[i],
+          startRow = _this$overlayRanges$i.startRow,
+          endRow = _this$overlayRanges$i.endRow;
+        if (startRow == null) continue; // eslint-disable-line no-continue
+        var last = endRow !== null && endRow !== void 0 ? endRow : startRow;
+        var clampedStart = Math.max(startRow, viewTop);
+        var clampedEnd = Math.min(last, viewBottom);
+        for (var r = clampedStart; r <= clampedEnd; r += 1) {
+          var data = this.getRowKeyData(r);
+          if (data != null) keys.add(data.key);
+        }
+      }
+      this.gestureKeys = keys;
+    }
+  }
+
+  /**
+   * Returns a copy of this selection with the given fields overridden.
+   * Unspecified fields carry through; pass `null` (or an empty
+   * set/map/false) to explicitly clear a field.
+   */
+  copyWith(overrides) {
+    return new KeyedSelection(_objectSpread({
+      getModel: this.getModel,
+      selectedKeys: this.selectedKeys,
+      overlayRanges: this.overlayRanges,
+      invertedSelection: this.invertedSelection,
+      selectedKeyValues: this.selectedKeyValues,
+      maxRows: this.maxRows,
+      pendingRanges: this.pendingRanges,
+      anchorKey: this.anchorKey,
+      anchorRow: this.anchorRow,
+      cursorKey: this.cursorKey,
+      cursorRowHint: this.cursorRowHint,
+      cursorColumn: this.cursorColumn,
+      selectionEndKey: this.selectionEndKey,
+      selectionEndRowHint: this.selectionEndRowHint,
+      selectionEndColumn: this.selectionEndColumn
+    }, overrides));
+  }
+
+  /**
+   * Returns both the serialized key and the raw values for a visible row, or
+   * `null` when the row is not keyable (e.g. totals / aggregation floating
+   * rows whose column values are aggregates, not real row keys).
+   */
+  getRowKeyData(row) {
+    var model = this.getModel();
+    if (model.isKeyableRow(row) !== true) return null;
+    var values = model.selectionKeyColumnIndices.map(col => model.valueForCell(col, row));
+    return {
+      key: serializeKeyValues(values),
+      values
+    };
+  }
+  isEmpty() {
+    // Inverted selection means all rows are selected — never empty.
+    if (this.invertedSelection) return false;
+    // Pending resolution means a selection is in progress — not empty.
+    if (this.pendingRanges.length > 0) return false;
+    return this.selectedKeys.size === 0 && this.gestureKeys.size === 0;
+  }
+  describe() {
+    if (this.pendingRanges.length > 0) return 'Selection loading.';
+    // Non-unique key columns can map one key to many rows; report the
+    // truthful count (keys) rather than lying about row counts.
+    var unit = this.getModel().hasUniqueSelectionKeys ? 'row' : 'key';
+    var n = this.selectedKeys.size;
+    if (this.invertedSelection) {
+      if (n === 0) return 'Everything selected.';
+      return unit === 'row' ? "All rows except ".concat(n, " selected.") : "All rows except ".concat(n, " ").concat(n === 1 ? 'key' : 'keys', " selected.");
+    }
+    if (n === 0) return 'No selection.';
+    if (n === 1) return unit === 'row' ? '1 row selected.' : '1 key selected.';
+    return unit === 'row' ? "".concat(n, " rows selected.") : "".concat(n, " keys selected.");
+  }
+
+  // Keyed selection is always full-row; column is irrelevant
+  isCellSelected(_column, row) {
+    return this.isRowSelected(row);
+  }
+  isRowSelected(row) {
+    var data = this.getRowKeyData(row);
+    if (data == null) return false;
+    var key = data.key;
+    if (this.invertedSelection) return !this.selectedKeys.has(key);
+    // Include gesture preview keys so key-siblings highlight on mousedown without waiting for commit.
+    return this.selectedKeys.has(key) || this.gestureKeys.has(key);
+  }
+
+  // Only fully selected when the inversion covers every row (i.e. select-all).
+  isColumnSelected(_column) {
+    return this.invertedSelection && this.selectedKeys.size === 0;
+  }
+  getNextCursorInDirection(current, direction) {
+    var _this$getModel = this.getModel(),
+      columnCount = _this$getModel.columnCount,
+      rowCount = _this$getModel.rowCount;
+    return nextCursorInRanges(this.overlayRanges, current, direction, {
+      columnCount,
+      rowCount
+    });
+  }
+  getCursorLandingCell() {
+    var _this$getModel2 = this.getModel(),
+      columnCount = _this$getModel2.columnCount,
+      rowCount = _this$getModel2.rowCount;
+    return cursorLandingCellForRanges(this.overlayRanges, {
+      columnCount,
+      rowCount
+    });
+  }
+
+  // Cursor / endpoint tracking. Rows are stored as `(key, rowHint)` pairs so
+  // ticks that shuffle row indices resolve to the live row via
+  // `findKeyInViewport`; columns don't drift and are kept as raw indices.
+  withCursor(row, column) {
+    var _this$getRowKeyData$k, _this$getRowKeyData;
+    if (row === this.cursorRow && column === this.cursorColumn) return this;
+    var nextKey = row != null ? (_this$getRowKeyData$k = (_this$getRowKeyData = this.getRowKeyData(row)) === null || _this$getRowKeyData === void 0 ? void 0 : _this$getRowKeyData.key) !== null && _this$getRowKeyData$k !== void 0 ? _this$getRowKeyData$k : null : null;
+    return this.copyWith({
+      cursorKey: nextKey,
+      cursorRowHint: row,
+      cursorColumn: column
+    });
+  }
+  withSelectionEnd(row, column) {
+    var _this$getRowKeyData$k2, _this$getRowKeyData2;
+    if (row === this.selectionEndRow && column === this.selectionEndColumn) {
+      return this;
+    }
+    var nextKey = row != null ? (_this$getRowKeyData$k2 = (_this$getRowKeyData2 = this.getRowKeyData(row)) === null || _this$getRowKeyData2 === void 0 ? void 0 : _this$getRowKeyData2.key) !== null && _this$getRowKeyData$k2 !== void 0 ? _this$getRowKeyData$k2 : null : null;
+    return this.copyWith({
+      selectionEndKey: nextKey,
+      selectionEndRowHint: row,
+      selectionEndColumn: column
+    });
+  }
+
+  /**
+   * Replaces the transient overlay ranges (mid-gesture preview) with the
+   * given ranges. Preserves the gesture anchor so mid-drag range updates
+   * don't clobber the shift-click origin.
+   *
+   * When `isReplacing` is true the caller intends the overlay to replace
+   * the current committed selection (drag / shift+click); previously
+   * committed keys are dropped so the commit uses the overlay as a fresh
+   * selection. Otherwise the committed keys are kept, letting a subsequent
+   * `commitGesture` fold the overlay into the existing set.
+   */
+  withMouseGestureRanges(ranges) {
+    var isReplacing = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (isReplacing) {
+      return this.copyWith({
+        selectedKeys: new Set(),
+        overlayRanges: ranges,
+        invertedSelection: false,
+        selectedKeyValues: EMPTY_MAP,
+        pendingRanges: EMPTY_ARRAY
+      });
+    }
+    return this.copyWith({
+      overlayRanges: ranges,
+      pendingRanges: EMPTY_ARRAY
+    });
+  }
+
+  /**
+   * Sets the gesture anchor (extend-from position for shift-click and
+   * keyboard extend) to the row's key. Passing `null` clears the anchor.
+   */
+  withGestureAnchor(row) {
+    var _this$getRowKeyData$k3, _this$getRowKeyData3;
+    var nextKey = row != null ? (_this$getRowKeyData$k3 = (_this$getRowKeyData3 = this.getRowKeyData(row)) === null || _this$getRowKeyData3 === void 0 ? void 0 : _this$getRowKeyData3.key) !== null && _this$getRowKeyData$k3 !== void 0 ? _this$getRowKeyData$k3 : null : null;
+    if (nextKey === this.anchorKey && row === this.anchorRow) return this;
+    return this.copyWith({
+      anchorKey: nextKey,
+      anchorRow: row
+    });
+  }
+
+  /**
+   * The current `{row, column}` of the gesture anchor, or `null` if none is
+   * set. Because `KeyedSelection` tracks the anchor by serialized key, the
+   * anchor's visible row may drift as the viewport scrolls. Resolves the
+   * key against the current viewport when possible; falls back to the
+   * click-time row hint (`anchorRow`) when the key has scrolled out. Returns
+   * `null` only when neither is set.
+   */
+  getGestureAnchor() {
+    if (this.anchorKey == null && this.anchorRow == null) return null;
+    if (this.anchorKey != null) {
+      var viewportRow = this.findKeyInViewport(this.anchorKey, this.anchorRow);
+      if (viewportRow != null) return {
+        row: viewportRow,
+        column: null
+      };
+    }
+    // Anchor key is not in the viewport; fall back to the click-time row hint.
+    return {
+      row: this.anchorRow,
+      column: null
+    };
+  }
+
+  /**
+   * Returns the visible row of `key`, or `null` if it's not in the viewport.
+   * When multiple rows share the key (non-unique key columns), prefers the one
+   * closest to `hint` so we track the row the caller last saw the key at.
+   */
+  findKeyInViewport(key, hint) {
+    var _model$viewport$top2, _model$viewport3, _model$viewport$botto2, _model$viewport4;
+    var model = this.getModel();
+    var viewTop = (_model$viewport$top2 = (_model$viewport3 = model.viewport) === null || _model$viewport3 === void 0 ? void 0 : _model$viewport3.top) !== null && _model$viewport$top2 !== void 0 ? _model$viewport$top2 : 0;
+    var viewBottom = (_model$viewport$botto2 = (_model$viewport4 = model.viewport) === null || _model$viewport4 === void 0 ? void 0 : _model$viewport4.bottom) !== null && _model$viewport$botto2 !== void 0 ? _model$viewport$botto2 : 0;
+    var best = null;
+    var bestDist = Infinity;
+    for (var r = viewTop; r <= viewBottom; r += 1) {
+      var data = this.getRowKeyData(r);
+      if (data == null || data.key !== key) continue; // eslint-disable-line no-continue
+      if (hint == null) return r;
+      var dist = Math.abs(r - hint);
+      if (dist < bestDist) {
+        best = r;
+        bestDist = dist;
+      }
+    }
+    return best;
+  }
+  get cursorRow() {
+    var _this$findKeyInViewpo;
+    if (this.cursorKey == null) return this.cursorRowHint;
+    return (_this$findKeyInViewpo = this.findKeyInViewport(this.cursorKey, this.cursorRowHint)) !== null && _this$findKeyInViewpo !== void 0 ? _this$findKeyInViewpo : this.cursorRowHint;
+  }
+  get selectionEndRow() {
+    var _this$findKeyInViewpo2;
+    if (this.selectionEndKey == null) return this.selectionEndRowHint;
+    return (_this$findKeyInViewpo2 = this.findKeyInViewport(this.selectionEndKey, this.selectionEndRowHint)) !== null && _this$findKeyInViewpo2 !== void 0 ? _this$findKeyInViewpo2 : this.selectionEndRowHint;
+  }
+  withGestureExtend(cursor, opts) {
+    var _computeGestureExtend = computeGestureExtend(this.overlayRanges, this.getGestureAnchor(), cursor, opts),
+      newRanges = _computeGestureExtend.newRanges,
+      isReplacing = _computeGestureExtend.isReplacing,
+      trimBefore = _computeGestureExtend.trimBefore,
+      resetAnchor = _computeGestureExtend.resetAnchor;
+    var base = trimBefore ? this.trimmed() : this;
+    var result = base.withMouseGestureRanges(newRanges, isReplacing);
+    if (resetAnchor) {
+      // Keyed selection is row based, so column is not used in the anchor.
+      result = result.withGestureAnchor(cursor.row);
+    }
+    return result;
+  }
+  commitGesture(lastCommitted, opts) {
+    if (this.overlayRanges.length === 0) return this;
+    if (opts.settle === false) {
+      // Mouse-down: keep overlayRanges pending. The overlay-to-committed
+      // merge (add / toggle-off / consolidation) runs on mouse-up so a drag
+      // can grow the overlay without prematurely folding it into selectedKeys.
+      return withCommittedCursor(this, this.getCursorLandingCell(), opts);
+    }
+
+    // Scan ranges for endpoints and total row count
+    var first = null;
+    var lastRow = 0;
+    var rowCount = 0;
+    for (var i = 0; i < this.overlayRanges.length; i += 1) {
+      var _this$overlayRanges$i2 = this.overlayRanges[i],
+        startRow = _this$overlayRanges$i2.startRow,
+        endRow = _this$overlayRanges$i2.endRow;
+      if (startRow == null) continue; // eslint-disable-line no-continue
+      var rEnd = endRow !== null && endRow !== void 0 ? endRow : startRow;
+      if (first === null) first = startRow;
+      lastRow = rEnd;
+      rowCount += rEnd - startRow + 1;
+    }
+    if (first === null || rowCount === 0) return this;
+    var next = new Set(this.selectedKeys);
+    if (this.selectedKeys.size > 0 || this.invertedSelection) {
+      // Ctrl+click / ctrl+drag path: clearSelectedRanges was not called, so
+      // selectedKeys still holds the previous committed keys. Toggle off when
+      // every row in the overlay was already committed (single-row ctrl+click
+      // on a selected row, or ctrl+drag over an all-selected range); otherwise
+      // add all rows to the selection without unioning them off.
+      var shouldToggle = true;
+      for (var _i = 0; _i < this.overlayRanges.length && shouldToggle; _i += 1) {
+        var _this$overlayRanges$_ = this.overlayRanges[_i],
+          _startRow = _this$overlayRanges$_.startRow,
+          _endRow = _this$overlayRanges$_.endRow;
+        if (_startRow == null) continue; // eslint-disable-line no-continue
+        var _rEnd = _endRow !== null && _endRow !== void 0 ? _endRow : _startRow;
+        for (var r = _startRow; r <= _rEnd; r += 1) {
+          if (!lastCommitted.isRowSelected(r)) {
+            shouldToggle = false;
+            break;
+          }
+        }
+      }
+
+      // Multi-row ctrl+shift add that spans out-of-viewport should  defer
+      // to async resolution while preserving the already-committed keys.
+      if (!shouldToggle && !this.invertedSelection) {
+        var _model$viewport$top3, _model$viewport5, _model$viewport$botto3, _model$viewport6;
+        var model = this.getModel();
+        var viewTop = (_model$viewport$top3 = (_model$viewport5 = model.viewport) === null || _model$viewport5 === void 0 ? void 0 : _model$viewport5.top) !== null && _model$viewport$top3 !== void 0 ? _model$viewport$top3 : 0;
+        var viewBottom = (_model$viewport$botto3 = (_model$viewport6 = model.viewport) === null || _model$viewport6 === void 0 ? void 0 : _model$viewport6.bottom) !== null && _model$viewport$botto3 !== void 0 ? _model$viewport$botto3 : 0;
+        if (first < viewTop || lastRow > viewBottom) {
+          return withCommittedCursor(this.copyWith({
+            overlayRanges: EMPTY_ARRAY,
+            pendingRanges: this.overlayRanges
+          }), this.getCursorLandingCell(), opts);
+        }
+      }
+      var _nextKeyValues = new Map(this.selectedKeyValues);
+      for (var _i2 = 0; _i2 < this.overlayRanges.length; _i2 += 1) {
+        var _this$overlayRanges$_2 = this.overlayRanges[_i2],
+          _startRow2 = _this$overlayRanges$_2.startRow,
+          _endRow2 = _this$overlayRanges$_2.endRow;
+        if (_startRow2 == null) continue; // eslint-disable-line no-continue
+        var _rEnd2 = _endRow2 !== null && _endRow2 !== void 0 ? _endRow2 : _startRow2;
+        for (var _r = _startRow2; _r <= _rEnd2; _r += 1) {
+          var _data = this.getRowKeyData(_r);
+          if (_data == null) continue; // eslint-disable-line no-continue
+          var _k = _data.key,
+            _values = _data.values;
+          if (shouldToggle) {
+            // Toggle off: every overlay row was already in lastCommitted, so
+            // ctrl+click / ctrl+drag flips them off.
+            if (this.invertedSelection) {
+              next.add(_k);
+              _nextKeyValues.set(_k, _values);
+            } else {
+              next.delete(_k);
+              _nextKeyValues.delete(_k);
+            }
+          } else if (this.invertedSelection) {
+            next.delete(_k);
+            _nextKeyValues.delete(_k);
+          } else {
+            next.add(_k);
+            _nextKeyValues.set(_k, _values);
+          }
+        }
+      }
+      return withCommittedCursor(this.copyWith({
+        selectedKeys: next,
+        overlayRanges: EMPTY_ARRAY,
+        selectedKeyValues: _nextKeyValues,
+        pendingRanges: EMPTY_ARRAY
+      }), this.getCursorLandingCell(), opts);
+    }
+
+    // Regular click path: clearSelectedRanges emptied selectedKeys first.
+    // Multi-row shift selections may span out-of-viewport rows where valueForCell
+    // returns null. Defer those to async resolution in IrisGrid.
+    // Assumes shift+click/drag emits one contiguous overlay range; `first`/`lastRow`
+    // are that range's endpoints and drive the anchor/target endpoint capture below.
+    if (rowCount > 1) {
+      var _model$viewport$top4, _model$viewport7, _model$viewport$botto4, _model$viewport8;
+      var _model = this.getModel();
+      var _viewTop = (_model$viewport$top4 = (_model$viewport7 = _model.viewport) === null || _model$viewport7 === void 0 ? void 0 : _model$viewport7.top) !== null && _model$viewport$top4 !== void 0 ? _model$viewport$top4 : 0;
+      var _viewBottom = (_model$viewport$botto4 = (_model$viewport8 = _model.viewport) === null || _model$viewport8 === void 0 ? void 0 : _model$viewport8.bottom) !== null && _model$viewport$botto4 !== void 0 ? _model$viewport$botto4 : 0;
+
+      // Fast path: entire range is in the viewport, so we can enumerate keys
+      // synchronously and skip the async fetch race entirely.
+      if (first >= _viewTop && lastRow <= _viewBottom) {
+        var _nextKeyValues2 = new Map();
+        for (var _r2 = first; _r2 <= lastRow; _r2 += 1) {
+          var _data2 = this.getRowKeyData(_r2);
+          if (_data2 == null) continue; // eslint-disable-line no-continue
+          _nextKeyValues2.set(_data2.key, _data2.values);
+        }
+        return withCommittedCursor(this.copyWith({
+          selectedKeys: new Set(_nextKeyValues2.keys()),
+          overlayRanges: EMPTY_ARRAY,
+          invertedSelection: false,
+          selectedKeyValues: _nextKeyValues2,
+          pendingRanges: EMPTY_ARRAY
+        }), this.getCursorLandingCell(), opts);
+      }
+
+      // Slow path: same async-fetch mechanism as `withCommittedRanges`.
+      // `IrisGrid.resolveKeyedSelection` fetches keys for the overlay ranges;
+      // rows that scroll away during the fetch are dropped from the result.
+      return withCommittedCursor(this.copyWith({
+        selectedKeys: new Set(),
+        invertedSelection: false,
+        selectedKeyValues: EMPTY_MAP,
+        pendingRanges: this.overlayRanges
+      }), this.getCursorLandingCell(), opts);
+    }
+
+    // Single-row path (rowCount === 1): first === lastRow.
+    var row = first;
+    var data = this.getRowKeyData(row);
+    if (data == null) {
+      // Row is not keyable (totals / aggregation row); commit clears the
+      // overlay without touching the keyed set.
+      return withCommittedCursor(this.copyWith({
+        overlayRanges: EMPTY_ARRAY
+      }), this.getCursorLandingCell(), opts);
+    }
+    var k = data.key,
+      values = data.values;
+    var nextKeyValues = new Map(this.selectedKeyValues);
+    // Deselect only when the clicked row was the entire previous committed selection.
+    var wasEntireSelection = opts.allowDeselect !== false && lastCommitted instanceof KeyedSelection && !lastCommitted.invertedSelection && lastCommitted.selectedKeys.size === 1 && lastCommitted.selectedKeys.has(k);
+    if (wasEntireSelection) {
+      next.delete(k);
+      nextKeyValues.delete(k);
+    } else {
+      next.add(k);
+      nextKeyValues.set(k, values);
+    }
+    return withCommittedCursor(this.copyWith({
+      selectedKeys: next,
+      overlayRanges: EMPTY_ARRAY,
+      invertedSelection: false,
+      selectedKeyValues: nextKeyValues,
+      pendingRanges: EMPTY_ARRAY
+    }), this.getCursorLandingCell(), opts);
+  }
+  clear() {
+    // Fresh empty carrying cursor forward (Escape semantics). Endpoint is
+    // transient gesture state and drops as part of the reset.
+    return KeyedSelection.empty(this.getModel).copyWith({
+      cursorKey: this.cursorKey,
+      cursorRowHint: this.cursorRowHint,
+      cursorColumn: this.cursorColumn
+    });
+  }
+
+  // Shift+click needs a clean slate so the range replaces rather than extends the old keys.
+  // Anchor is preserved so shift+click's extend reads it after the trim.
+  trimmed() {
+    return this.copyWith({
+      selectedKeys: new Set(),
+      overlayRanges: EMPTY_ARRAY,
+      invertedSelection: false,
+      selectedKeyValues: EMPTY_MAP,
+      maxRows: null,
+      pendingRanges: EMPTY_ARRAY
+    });
+  }
+
+  // Always returns non-inverted; switching to a new selection exits inverted mode.
+  withCommittedRanges(ranges, anchor) {
+    var result = this.installCommittedRanges(ranges);
+    if (anchor === undefined) return result;
+    // Keyed selection is row based, so column is not used in the anchor.
+    return result.withGestureAnchor(anchor.row);
+  }
+  installCommittedRanges(ranges) {
+    var _model$viewport$top5, _model$viewport9, _model$viewport$botto5, _model$viewport0;
+    // Fields threaded through every fresh install so cursor / endpoint state
+    // survive programmatic range replacement (matches Escape semantics).
+    var carry = {
+      cursorKey: this.cursorKey,
+      cursorRowHint: this.cursorRowHint,
+      cursorColumn: this.cursorColumn,
+      selectionEndKey: this.selectionEndKey,
+      selectionEndRowHint: this.selectionEndRowHint,
+      selectionEndColumn: this.selectionEndColumn
+    };
+    // Replacement semantics: discard previous selection and select exactly these rows.
+    if (ranges.length === 0) {
+      return new KeyedSelection(_objectSpread({
+        getModel: this.getModel
+      }, carry));
+    }
+
+    // Compute the true min/max across every range so the viewport check is
+    // correct even when input ranges arrive out of order or non-contiguous
+    // (e.g. plugin-driven programmatic selection).
+    var minRow = null;
+    var maxRow = null;
+    for (var i = 0; i < ranges.length; i += 1) {
+      var _ranges$i = ranges[i],
+        startRow = _ranges$i.startRow,
+        endRow = _ranges$i.endRow;
+      if (startRow == null) continue; // eslint-disable-line no-continue
+      var rEnd = endRow !== null && endRow !== void 0 ? endRow : startRow;
+      var low = Math.min(startRow, rEnd);
+      var high = Math.max(startRow, rEnd);
+      if (minRow === null || low < minRow) minRow = low;
+      if (maxRow === null || high > maxRow) maxRow = high;
+    }
+    if (minRow === null || maxRow === null) {
+      return new KeyedSelection(_objectSpread({
+        getModel: this.getModel
+      }, carry));
+    }
+    var model = this.getModel();
+    var viewTop = (_model$viewport$top5 = (_model$viewport9 = model.viewport) === null || _model$viewport9 === void 0 ? void 0 : _model$viewport9.top) !== null && _model$viewport$top5 !== void 0 ? _model$viewport$top5 : 0;
+    var viewBottom = (_model$viewport$botto5 = (_model$viewport0 = model.viewport) === null || _model$viewport0 === void 0 ? void 0 : _model$viewport0.bottom) !== null && _model$viewport$botto5 !== void 0 ? _model$viewport$botto5 : 0;
+
+    // Fast path: every range fits in the viewport, so valueForCell answers
+    // synchronously with real values.
+    if (minRow >= viewTop && maxRow <= viewBottom) {
+      var next = new Set();
+      var nextKeyValues = new Map();
+      for (var _i3 = 0; _i3 < ranges.length; _i3 += 1) {
+        var _ranges$_i = ranges[_i3],
+          _startRow3 = _ranges$_i.startRow,
+          _endRow3 = _ranges$_i.endRow;
+        if (_startRow3 == null) continue; // eslint-disable-line no-continue
+        var _rEnd3 = _endRow3 !== null && _endRow3 !== void 0 ? _endRow3 : _startRow3;
+        var _low = Math.min(_startRow3, _rEnd3);
+        var _high = Math.max(_startRow3, _rEnd3);
+        for (var r = _low; r <= _high; r += 1) {
+          var data = this.getRowKeyData(r);
+          if (data == null) continue; // eslint-disable-line no-continue
+          next.add(data.key);
+          nextKeyValues.set(data.key, data.values);
+        }
+      }
+      return new KeyedSelection(_objectSpread({
+        getModel: this.getModel,
+        selectedKeys: next,
+        selectedKeyValues: nextKeyValues
+      }, carry));
+    }
+
+    // Slow path: any row outside the viewport would resolve to a phantom
+    // all-null key via undefined valueForCell reads. Defer to async key fetch;
+    // IrisGrid's onSelectionChange handler picks up pendingRanges.
+    return new KeyedSelection(_objectSpread({
+      getModel: this.getModel,
+      pendingRanges: ranges
+    }, carry));
+  }
+
+  // Sets invertedSelection=true with an empty exclusion set (all rows selected).
+  selectAll() {
+    // Fresh inverted-all carrying cursor forward.
+    return KeyedSelection.empty(this.getModel).copyWith({
+      invertedSelection: true,
+      cursorKey: this.cursorKey,
+      cursorRowHint: this.cursorRowHint,
+      cursorColumn: this.cursorColumn
+    });
+  }
+  truncate(maxRows) {
+    if (maxRows === this.maxRows) return this;
+    return this.copyWith({
+      maxRows
+    });
+  }
+
+  /**
+   * Builds a fully-resolved selection from async-fetched key values merged with the current selection, clearing pendingRanges.
+   */
+  resolve(keyValues) {
+    var mergedKeys = new Set(this.selectedKeys);
+    var mergedKeyValues = new Map(this.selectedKeyValues);
+    keyValues.forEach((values, key) => {
+      mergedKeys.add(key);
+      mergedKeyValues.set(key, values);
+    });
+    return this.copyWith({
+      selectedKeys: mergedKeys,
+      overlayRanges: EMPTY_ARRAY,
+      invertedSelection: false,
+      selectedKeyValues: mergedKeyValues,
+      maxRows: null,
+      pendingRanges: EMPTY_ARRAY
+    });
+  }
+
+  /**
+   * Returns the exact committed row count when each key maps to one row,
+   * or null when the count is unknown (non-unique keys or pending resolution).
+   * For inverted selections the count is approximate on ticking tables.
+   */
+  getUniqueRowCount() {
+    if (this.pendingRanges.length > 0 || !this.getModel().hasUniqueSelectionKeys) {
+      return null;
+    }
+    if (this.invertedSelection) {
+      return this.getModel().rowCount - this.selectedKeys.size;
+    }
+    return this.selectedKeys.size;
+  }
+
+  /** Returns a new selection with the given row's key toggled. */
+  withToggledRow(row) {
+    var data = this.getRowKeyData(row);
+    if (data == null) return this;
+    var key = data.key,
+      values = data.values;
+    var next = new Set(this.selectedKeys);
+    var nextKeyValues = new Map(this.selectedKeyValues);
+    if (next.has(key)) {
+      next.delete(key);
+      nextKeyValues.delete(key);
+    } else {
+      next.add(key);
+      nextKeyValues.set(key, values);
+    }
+    return this.copyWith({
+      selectedKeys: next,
+      overlayRanges: EMPTY_ARRAY,
+      selectedKeyValues: nextKeyValues,
+      pendingRanges: EMPTY_ARRAY
+    });
+  }
+}
+export default KeyedSelection;
+//# sourceMappingURL=KeyedSelection.js.map