@deephaven/iris-grid 1.22.2-alpha-pivot-builder.0 → 1.23.0

package/dist/IrisGrid.js

@@ -272,8 +272,8 @@ class IrisGrid extends Component {
     /**
      * Apply the `transformTableOptions` transform (if any) to the
      * default option list.
-     * Catches exceptions so a buggy plugin can't break the grid,
-     * and warns about duplicate `type` collisions.
+     * Catches exceptions so a buggy plugin can't break the grid, and collapses
+     * duplicate `type` entries (last writer wins) before sorting by `order`.
      */
     _defineProperty(this, "getCachedTransformedOptionItems", memoize((items, transformTableOptions) => {
       if (transformTableOptions == null) {
@@ -286,11 +286,23 @@ class IrisGrid extends Component {
         log.error('transformTableOptions threw an error; falling back to defaults.', err);
         return items;
       }
+      // Collapse duplicate `type` entries before sorting. A duplicate `type`
+      // would otherwise collide on the `<Menu>` / `<Page>` React key and cause
+      // incorrect page reuse. Per the documented composition rule (see the
+      // package README), the last writer wins: a later entry — e.g. from a
+      // downstream middleware — overrides an earlier one with the same type.
+      // `Map.set` keeps the most recent value while preserving the original
+      // insertion slot, so an override stays in place unless it changes
+      // `order`.
+      var byType = new Map();
+      transformedItems.forEach(item => {
+        byType.set(String(item.type), item);
+      });
       // Stably sort by ascending `order`. Items without an `order` sink to
       // the end of the menu (default `Infinity`), while items with an `order`
       // are positioned by their weight. Decorate-sort-undecorate guarantees
       // stability regardless of the engine's sort implementation.
-      var sortedItems = transformedItems.map((item, index) => ({
+      var sortedItems = [...byType.values()].map((item, index) => ({
         item,
         index
       })).sort((a, b) => {
@@ -300,15 +312,6 @@ class IrisGrid extends Component {
         var item = _ref2.item;
         return item;
       });
-      var keys = new Set();
-      for (var i = 0; i < sortedItems.length; i += 1) {
-        var key = String(sortedItems[i].type);
-        if (keys.has(key)) {
-          log.warn("transformTableOptions produced duplicate type \"".concat(key, "\"; ") + 'only the first entry will be accessible from the menu.');
-          break;
-        }
-        keys.add(key);
-      }
       return Object.freeze(sortedItems);
     }, {
       max: 1
@@ -316,6 +319,17 @@ class IrisGrid extends Component {
     _defineProperty(this, "getCachedHiddenColumns", memoize((metricCalculator, userColumnWidths) => IrisGridUtils.getHiddenColumns(new Map([...metricCalculator.initialColumnWidths, ...userColumnWidths])), {
       max: 1
     }));
+    _defineProperty(this, "getCachedHiddenColumnNames", memoize((hiddenColumns, columns) => Object.freeze(hiddenColumns.map(idx => {
+      var _columns$idx;
+      return (_columns$idx = columns[idx]) === null || _columns$idx === void 0 ? void 0 : _columns$idx.name;
+    }).filter(n => n != null)), {
+      max: 1
+    }));
+    _defineProperty(this, "getCachedViewState", memoize(hiddenColumns => Object.freeze({
+      hiddenColumns
+    }), {
+      max: 1
+    }));
     _defineProperty(this, "getAggregationMap", memoize((columns, aggregations) => {
       var aggregationMap = {};
       aggregations.forEach(_ref3 => {
@@ -602,7 +616,7 @@ class IrisGrid extends Component {
     this.handleHeaderGroupsChanged = this.handleHeaderGroupsChanged.bind(this);
     this.handleUpdate = this.handleUpdate.bind(this);
     this.handleTableChanged = this.handleTableChanged.bind(this);
-    this.handleModelChanged = this.handleModelChanged.bind(this);
+    this.handleSchemaChanged = this.handleSchemaChanged.bind(this);
     this.handleTooltipRef = this.handleTooltipRef.bind(this);
     this.handleViewChanged = this.handleViewChanged.bind(this);
     this.handleFormatSelection = this.handleFormatSelection.bind(this);
@@ -727,17 +741,18 @@ class IrisGrid extends Component {
     }
     var _movedColumns = movedColumnsProp.length > 0 ? movedColumnsProp : _model.initialMovedColumns;
     var movedRows = movedRowsProp.length > 0 ? movedRowsProp : _model.initialMovedRows;
-    var metricCalculatorFactory = getMetricCalculator;
-    var _metricCalculator = metricCalculatorFactory({
+    var _metricCalculator = getMetricCalculator({
       userColumnWidths: new Map(_userColumnWidths),
       userColumnWidthsByName: userColumnWidthsByName != null ? new Map(userColumnWidthsByName) : undefined,
       userRowHeights: new Map(userRowHeights),
       movedColumns: _movedColumns,
       initialColumnWidths: new Map(_model === null || _model === void 0 || (_model$layoutHints = _model.layoutHints) === null || _model$layoutHints === void 0 || (_model$layoutHints = _model$layoutHints.hiddenColumns) === null || _model$layoutHints === void 0 ? void 0 : _model$layoutHints.map(name => [_model.getColumnIndexByName(name), 0]))
     });
-    // Remember the factory we used so we can detect a model-driven swap
-    // (e.g. pivot-builder's proxy swapping its inner model) on COLUMNS_CHANGED.
-    this.lastMetricCalculatorFactory = metricCalculatorFactory;
+    // Remember the factory we used so `maybeRebuildMetricCalculator` (called
+    // from `componentDidUpdate` when the `getMetricCalculator` prop changes)
+    // can detect a model-driven swap, e.g. pivot-builder's proxy swapping its
+    // inner model.
+    this.lastMetricCalculatorFactory = getMetricCalculator;
     var searchColumns = _selectedSearchColumns !== null && _selectedSearchColumns !== void 0 ? _selectedSearchColumns : [];
     var _searchFilter = CrossColumnSearch.createSearchFilter(_dh, _searchValue, searchColumns, _model.columns, _invertSearchColumns);
     this.tableUtils = new TableUtils(_dh);
@@ -857,7 +872,7 @@ class IrisGrid extends Component {
     // component state, so mirror that path when the `getMetricCalculator` prop
     // changes (e.g. the pivot-builder middleware swapping the pivot factory in
     // or out) so the calculator stays in sync. Moved columns are not touched
-    // here — a model swap resets them via `handleModelChanged`.
+    // here — a model swap resets them via `handleSchemaChanged`.
     if (getMetricCalculator !== prevProps.getMetricCalculator) {
       this.maybeRebuildMetricCalculator();
     }
@@ -1705,7 +1720,7 @@ class IrisGrid extends Component {
     model.addEventListener(IrisGridModel.EVENT.PENDING_DATA_UPDATED, this.handlePendingDataUpdated);
     model.addEventListener(IrisGridModel.EVENT.VIEWPORT_UPDATED, this.handleViewportUpdated);
     model.addEventListener(IrisGridModel.EVENT.TABLE_CHANGED, this.handleTableChanged);
-    model.addEventListener(IrisGridModel.EVENT.MODEL_CHANGED, this.handleModelChanged);
+    model.addEventListener(IrisGridModel.EVENT.SCHEMA_CHANGED, this.handleSchemaChanged);
   }
   stopListening(model) {
     model.removeEventListener(IrisGridModel.EVENT.UPDATED, this.handleUpdate);
@@ -1716,7 +1731,7 @@ class IrisGrid extends Component {
     model.removeEventListener(IrisGridModel.EVENT.PENDING_DATA_UPDATED, this.handlePendingDataUpdated);
     model.removeEventListener(IrisGridModel.EVENT.VIEWPORT_UPDATED, this.handleViewportUpdated);
     model.removeEventListener(IrisGridModel.EVENT.TABLE_CHANGED, this.handleTableChanged);
-    model.removeEventListener(IrisGridModel.EVENT.MODEL_CHANGED, this.handleModelChanged);
+    model.removeEventListener(IrisGridModel.EVENT.SCHEMA_CHANGED, this.handleSchemaChanged);
   }
   focus() {
     var _this$grid3;
@@ -2482,6 +2497,16 @@ class IrisGrid extends Component {
    * Clear the loading scrim in response to a model-driven `PENDING_CLEARED`
    * event. Only needed for operations that do not naturally end in
    * `UPDATED`/`COLUMNS_CHANGED`/`REQUEST_FAILED`.
+   *
+   * The current contract assumes a single outstanding model-driven operation:
+   * `handlePending` collapses concurrent `PENDING` events into one scrim, so
+   * this clears unconditionally. That is consistent with the existing scrim,
+   * which any model stop signal already clears regardless of what else is in
+   * flight. Ref-counting overlapping operations is intentionally deferred to
+   * the planned migration that routes the built-in `startLoading` calls
+   * through `PENDING`/`PENDING_CLEARED`; only once every raise/clear goes
+   * through this pair can a depth counter stay balanced (a counter added now
+   * would desync against the direct `startLoading` callers).
    */
   handlePendingCleared() {
     this.stopLoading();
@@ -2528,7 +2553,7 @@ class IrisGrid extends Component {
   }
 
   /**
-   * Handle an inner-model swap on a proxy model (`MODEL_CHANGED`). The previous
+   * Handle an inner-model swap on a proxy model (`SCHEMA_CHANGED`). The previous
    * model's `movedColumns` reference indices that may not exist in the new
    * model (e.g. a pivot exposes a different column set), so reset them to the
    * new model's initial order. The metric calculator is rebuilt separately when
@@ -2536,7 +2561,7 @@ class IrisGrid extends Component {
    * whose seed `movedColumns` are now stale self-heals because `getMetrics`
    * reconciles against the grid's current `movedColumns` at draw time.
    */
-  handleModelChanged() {
+  handleSchemaChanged() {
     var model = this.props.model;
     this.setState({
       movedColumns: model.initialMovedColumns
@@ -2761,8 +2786,8 @@ class IrisGrid extends Component {
    * carried over: a factory swap means the column set has effectively changed,
    * so the stored sizes wouldn't map to anything meaningful.
    *
-   * Moved columns are NOT reset here — that is owned by `handleModelChanged`
-   * (the `MODEL_CHANGED` event) so that a plain prop swap against the same
+   * Moved columns are NOT reset here — that is owned by `handleSchemaChanged`
+   * (the `SCHEMA_CHANGED` event) so that a plain prop swap against the same
    * model preserves the user's layout. The new calculator is seeded with the
    * current moved columns; `getMetrics` reconciles against the grid's live
    * `movedColumns` at draw time, so a later reset stays consistent.
@@ -2770,17 +2795,16 @@ class IrisGrid extends Component {
   maybeRebuildMetricCalculator() {
     var _model$layoutHints4;
     var getMetricCalculator = this.props.getMetricCalculator;
-    var factory = getMetricCalculator;
-    if (factory === this.lastMetricCalculatorFactory) return;
+    if (getMetricCalculator === this.lastMetricCalculatorFactory) return;
     var model = this.props.model;
     var movedColumns = this.state.movedColumns;
-    var next = factory({
+    var next = getMetricCalculator({
       userColumnWidths: new Map(),
       userRowHeights: new Map(),
       movedColumns,
       initialColumnWidths: new Map(model === null || model === void 0 || (_model$layoutHints4 = model.layoutHints) === null || _model$layoutHints4 === void 0 || (_model$layoutHints4 = _model$layoutHints4.hiddenColumns) === null || _model$layoutHints4 === void 0 ? void 0 : _model$layoutHints4.map(name => [model.getColumnIndexByName(name), 0]))
     });
-    this.lastMetricCalculatorFactory = factory;
+    this.lastMetricCalculatorFactory = getMetricCalculator;
     log.debug('Swapping metric calculator', next);
     // Also push the new calculator onto the Grid synchronously so any
     // immediately-following read of `Grid.metricCalculator` (before React has
@@ -3890,9 +3914,9 @@ class IrisGrid extends Component {
             }
             return /*#__PURE__*/_jsx(PluginTableOptionsErrorBoundary, {
               itemType: String(option.type),
-              onBack: this.handleMenuBack,
               children: /*#__PURE__*/_jsx(PluginPage, {
                 model: model,
+                viewState: this.getCachedViewState(this.getCachedHiddenColumnNames(hiddenColumns, model.columns)),
                 onBack: this.handleMenuBack
               })
             }, String(option.type));