@ni/nimble-components 8.0.0 → 8.0.1

package/dist/all-components-bundle.js

@@ -18866,37 +18866,8 @@
      */
     class TreeItem extends TreeItem$1 {
         constructor() {
-            super();
+            super(...arguments);
             this.treeView = null;
-            this.handleClickOverride = (event) => {
-                if (event.composedPath().includes(this.expandCollapseButton)) {
-                    // just have base class handle click event for glyph
-                    return;
-                }
-                const treeItem = this.getImmediateTreeItem(event.target);
-                if (treeItem?.disabled || treeItem !== this) {
-                    // don't allow base TreeItem to emit a 'selected-change' event when a disabled item is clicked
-                    event.stopImmediatePropagation();
-                    return;
-                }
-                const leavesOnly = this.treeView?.selectionMode === TreeViewSelectionMode.LeavesOnly;
-                const all = this.treeView?.selectionMode === TreeViewSelectionMode.All;
-                const hasChildren = this.hasChildTreeItems();
-                if ((leavesOnly && !hasChildren) || all) {
-                    const selectedTreeItem = this.getImmediateTreeItem(this.treeView?.currentSelected);
-                    // deselect currently selected item if different than this instance
-                    if (selectedTreeItem && this !== this.treeView?.currentSelected) {
-                        selectedTreeItem.selected = false;
-                    }
-                    this.selected = true;
-                }
-                else {
-                    // implicit (hasChildren && leavesOnly) || none, so only allow expand/collapse, not select
-                    this.expanded = !this.expanded;
-                }
-                // don't allow base class to process click event
-                event.stopImmediatePropagation();
-            };
             // This prevents the toggling of selected state when a TreeItem is clicked multiple times,
             // which is what the FAST TreeItem allows
             this.handleSelectedChange = (event) => {
@@ -18905,7 +18876,6 @@
                     this.setGroupSelectionOnRootParentTreeItem(this);
                 }
             };
-            this.addEventListener('click', this.handleClickOverride);
         }
         connectedCallback() {
             super.connectedCallback();
@@ -18917,14 +18887,9 @@
         }
         disconnectedCallback() {
             super.disconnectedCallback();
-            this.removeEventListener('click', this.handleClickOverride);
             this.removeEventListener('selected-change', this.handleSelectedChange);
             this.treeView = null;
         }
-        hasChildTreeItems() {
-            const treeItemChild = this.querySelector('[role="treeitem"]');
-            return treeItemChild !== null;
-        }
         clearTreeGroupSelection() {
             const currentGroupSelection = this.treeView?.querySelectorAll(`[${groupSelectedAttribute}]`);
             currentGroupSelection?.forEach(treeItem => treeItem.removeAttribute(groupSelectedAttribute));
@@ -18939,14 +18904,6 @@
                 currentItem.setAttribute(groupSelectedAttribute, 'true');
             }
         }
-        getImmediateTreeItem(element) {
-            let foundElement = element;
-            while (foundElement
-                && !(foundElement?.getAttribute('role') === 'treeitem')) {
-                foundElement = foundElement?.parentElement;
-            }
-            return foundElement;
-        }
         /**
          * This was copied directly from the FAST TreeItem implementation
          * @returns the root tree view
@@ -18994,6 +18951,43 @@
             super(...arguments);
             this.selectionMode = TreeViewSelectionMode.All;
         }
+        handleClick(e) {
+            if (e.defaultPrevented) {
+                // handled, do nothing
+                return false;
+            }
+            if (!(e.target instanceof Element) || !isTreeItemElement(e.target)) {
+                // not a tree item, ignore
+                return true;
+            }
+            const item = e.target;
+            if (item.disabled) {
+                return false;
+            }
+            if (this.canSelect(item)) {
+                item.selected = true;
+            }
+            else if (this.itemHasChildren(item)) {
+                item.expanded = !item.expanded;
+            }
+            return true;
+        }
+        canSelect(item) {
+            switch (this.selectionMode) {
+                case TreeViewSelectionMode.All:
+                    return true;
+                case TreeViewSelectionMode.None:
+                    return false;
+                case TreeViewSelectionMode.LeavesOnly:
+                    return !this.itemHasChildren(item);
+                default:
+                    return true;
+            }
+        }
+        itemHasChildren(item) {
+            const treeItemChild = item.querySelector('[role="treeitem"]');
+            return treeItemChild !== null;
+        }
     }
     __decorate([
         attr({ attribute: 'selection-mode' })