@ni/nimble-components 21.5.1 → 21.5.2

package/dist/all-components-bundle.js

@@ -16301,7 +16301,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Fri, 16 Feb 2024 17:54:10 GMT
+   * Generated on Mon, 19 Feb 2024 18:58:25 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -65953,79 +65953,94 @@ img.ProseMirror-separator {
   class ExpansionManager {
       constructor(tanStackTable) {
           this.tanStackTable = tanStackTable;
-          // This field represents whether or not the expanded state of **all** rows is in the default expanded
-          // state or not. Note that the default expanded state for a particular row type (group vs parent) can
-          // potentially be different (e.g. expanded for groups and collapsed for parent rows).
-          this.isInDefaultState = true;
-          this.collapsedRows = new Set();
+          this.explicitExpansionStates = new Map();
           this.hierarchyOptions = new Map();
           this.isHierarchyEnabled = false;
+          this.parentRowsWithChildren = new Set();
       }
       isRowExpanded(row) {
           if (!this.isRowExpandable(row)) {
               return false;
           }
-          if (row.subRows.length === 0) {
-              return false;
-          }
-          return this.isInDefaultState || !this.collapsedRows.has(row.id);
+          const expansionState = this.explicitExpansionStates.get(row.id);
+          return expansionState ?? this.getDefaultExpansionState(row);
       }
       toggleRowExpansion(row) {
           if (!this.isRowExpandable(row)) {
               return;
           }
           const wasExpanded = this.isRowExpanded(row);
-          this.isInDefaultState = false;
-          if (wasExpanded) {
-              this.collapsedRows.add(row.id);
-          }
-          else {
-              this.collapsedRows.delete(row.id);
-          }
+          this.explicitExpansionStates.set(row.id, !wasExpanded);
           row.toggleExpanded();
       }
       collapseAll() {
           this.resetExpansionState();
-          this.isInDefaultState = false;
           const rows = this.tanStackTable.getRowModel().flatRows;
           for (const row of rows) {
               if (this.isRowExpandable(row)) {
-                  this.collapsedRows.add(row.id);
+                  this.explicitExpansionStates.set(row.id, false);
               }
           }
           this.tanStackTable.toggleAllRowsExpanded(false);
       }
       resetExpansionState() {
-          this.collapsedRows.clear();
-          this.isInDefaultState = true;
+          this.explicitExpansionStates.clear();
       }
       resetHierarchyOptions() {
           this.hierarchyOptions.clear();
       }
       processDataUpdate(rows) {
-          if (this.collapsedRows.size === 0 && this.hierarchyOptions.size === 0) {
+          if (this.explicitExpansionStates.size === 0
+              && this.hierarchyOptions.size === 0) {
               return;
           }
-          const updatedCollapsedRows = new Set();
+          const updatedExplicitExpansionStates = new Map();
           const updatedHierarchyOptions = new Map();
+          const updatedParentRowsWithChildren = new Set();
           for (const row of rows) {
               const rowId = row.id;
-              if (this.collapsedRows.has(rowId)) {
-                  updatedCollapsedRows.add(rowId);
-              }
+              const isGroupRow = row.getIsGrouped();
               const rowHierarchyOptions = this.hierarchyOptions.get(rowId);
-              if (!row.getIsGrouped() && rowHierarchyOptions) {
+              if (!isGroupRow && rowHierarchyOptions) {
                   updatedHierarchyOptions.set(rowId, rowHierarchyOptions);
               }
+              if (this.isRowExpandable(row)) {
+                  const expansionState = this.explicitExpansionStates.get(rowId);
+                  if (expansionState !== undefined) {
+                      updatedExplicitExpansionStates.set(rowId, expansionState);
+                  }
+                  if (!isGroupRow) {
+                      const hasChildRows = row.subRows.length !== 0;
+                      if (hasChildRows) {
+                          updatedParentRowsWithChildren.add(rowId);
+                      }
+                      else if (this.parentRowsWithChildren.has(rowId)) {
+                          // The row used to have children, but now it does not. Therefore,
+                          // collapse the row.
+                          updatedExplicitExpansionStates.set(rowId, false);
+                      }
+                  }
+              }
           }
-          this.collapsedRows = updatedCollapsedRows;
+          this.explicitExpansionStates = updatedExplicitExpansionStates;
           this.hierarchyOptions = updatedHierarchyOptions;
+          this.parentRowsWithChildren = updatedParentRowsWithChildren;
       }
       setHierarchyOptions(hierarchyOptions) {
-          this.hierarchyOptions.clear();
+          const updatedHierarchyOptions = new Map();
           for (const { recordId, options } of hierarchyOptions) {
-              this.hierarchyOptions.set(recordId, options);
+              updatedHierarchyOptions.set(recordId, options);
+              const oldState = this.hierarchyOptions.get(recordId)?.delayedHierarchyState;
+              const newState = options.delayedHierarchyState;
+              if (oldState === TableRecordDelayedHierarchyState.loadingChildren
+                  && newState === TableRecordDelayedHierarchyState.canLoadChildren
+                  && !this.parentRowsWithChildren.has(recordId)) {
+                  // If a row without children transitions from loadingChildren to canLoadChildren,
+                  // put it back in its default state of collapsed.
+                  this.explicitExpansionStates.delete(recordId);
+              }
           }
+          this.hierarchyOptions = updatedHierarchyOptions;
       }
       isRowExpandable(row) {
           return row.subRows.length > 0 || this.canLoadDelayedChildren(row.id);
@@ -66047,6 +66062,12 @@ img.ProseMirror-separator {
           const delayedHierarchyState = this.hierarchyOptions.get(id)?.delayedHierarchyState;
           return delayedHierarchyState !== TableRecordDelayedHierarchyState.none;
       }
+      getDefaultExpansionState(row) {
+          // Rows with children (group rows and parent rows with populated children)
+          // default to expanded. Other rows (parent rows with lazy-loaded children)
+          // default to collapsed.
+          return row.subRows.length !== 0;
+      }
   }
 
   /**