@cognite/reveal-components 1.0.2 → 1.48552.0

package/dist/foundation/treeNodes/tree-node/tree-node-functions-on-key-down.js

@@ -1,66 +1,133 @@
-import { TreeNode as e } from "./tree-node.js";
-import { clearSelection as t, onToggleNode as n } from "./tree-node-functions.js";
-import { findIndex as r, findLastIndex as i } from "lodash-es";
-//#region libs/shared/reveal-components/src/foundation/treeNodes/tree-node/tree-node-functions-on-key-down.ts
-function a(e, n, r) {
-	if (n.key === "ArrowRight" || n.key === "ArrowLeft") return c(e, n.key === "ArrowRight"), !1;
-	if (n.key === "Escape") return t(e);
-	if (n.key === "Enter" || n.key === " ") return l(e);
-	if (n.key === "ArrowUp" || n.key === "ArrowDown") {
-		let t = n.key === "ArrowUp" ? -1 : 1, i = n.shiftKey;
-		return o(e, r, i, t);
-	}
-	return !1;
+import { findIndex, findLastIndex } from "lodash-es";
+import { TreeNode } from "./tree-node.js";
+import { clearSelection, onToggleNode } from "./tree-node-functions.js";
+export function onKeyDown(root, event, lastSelectedNodeRef) {
+    if (event.key === 'ArrowRight' || event.key === 'ArrowLeft') {
+        const expand = event.key === 'ArrowRight';
+        expandOrCollapseSelected(root, expand);
+        return false;
+    }
+    if (event.key === 'Escape') {
+        return clearSelection(root);
+    }
+    if (event.key === 'Enter' || event.key === ' ') {
+        return toggleCheckStateOnSelected(root);
+    }
+    if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
+        const direction = event.key === 'ArrowUp' ? -1 : 1;
+        const shift = event.shiftKey;
+        return selectOrExpandSelection(root, lastSelectedNodeRef, shift, direction);
+    }
+    return false;
 }
-function o(e, t, n, r) {
-	let i = Array.from(e.getExpandedThisAndDescendants()), a = t.current, o = a === void 0 ? -1 : i.indexOf(a), c = a !== void 0 && a.isSelected && o >= 0;
-	if (c && n) {
-		let { minIndex: e, maxIndex: t } = s(i, o);
-		if (r < 0) {
-			if (t > o) return i[t].setSelected(!1);
-			if (e <= o) return e--, e < 0 ? !1 : i[e].setSelected();
-		} else if (e < o) return i[e].setSelected(!1);
-		else if (t >= o) return t++, t >= i.length ? !1 : i[t].setSelected();
-	}
-	c || (o = r < 0 ? u(i) : d(i), a = o >= 0 ? i[o] : void 0);
-	let l = !1;
-	if (a) {
-		let e = o + r;
-		if (e < 0 || e >= i.length) return !1;
-		let a = i[e];
-		!n && f(i, a) && (l = !0), a.setSelected() && (n || (t.current = a), l = !0);
-	}
-	return l;
+function selectOrExpandSelection(root, lastSelectedNodeRef, isShift, direction) {
+    // direction = -1: Set previous node selected (before first selected), and clear all other selections
+    // direction = +1: Set next node selected (after last selected), and clear all other selections
+    const nodes = Array.from(root.getExpandedThisAndDescendants());
+    let selectedNode = lastSelectedNodeRef.current;
+    let selectedIndex = selectedNode !== undefined ? nodes.indexOf(selectedNode) : -1;
+    const hasSelected = selectedNode !== undefined && selectedNode.isSelected && selectedIndex >= 0;
+    if (hasSelected && isShift) {
+        let { minIndex, maxIndex } = getMinMaxIndexedOfSelection(nodes, selectedIndex);
+        if (direction < 0) {
+            if (maxIndex > selectedIndex) {
+                return nodes[maxIndex].setSelected(false);
+            } else if (minIndex <= selectedIndex) {
+                minIndex--;
+                if (minIndex < 0) {
+                    return false;
+                }
+                return nodes[minIndex].setSelected();
+            }
+        } else {
+            if (minIndex < selectedIndex) {
+                return nodes[minIndex].setSelected(false);
+            } else if (maxIndex >= selectedIndex) {
+                maxIndex++;
+                if (maxIndex >= nodes.length) {
+                    return false;
+                }
+                return nodes[maxIndex].setSelected();
+            }
+        }
+    }
+    // Fallback
+    if (!hasSelected) {
+        selectedIndex = direction < 0 ? getFirstSelectedIndex(nodes) : getLastSelectedIndex(nodes);
+        selectedNode = selectedIndex >= 0 ? nodes[selectedIndex] : undefined;
+    }
+    let isChanged = false;
+    if (selectedNode) {
+        const nextIndex = selectedIndex + direction;
+        if (nextIndex < 0 || nextIndex >= nodes.length) {
+            return false;
+        }
+        const nextNode = nodes[nextIndex];
+        if (!isShift && deselectAllExcept(nodes, nextNode)) {
+            isChanged = true;
+        }
+        if (nextNode.setSelected()) {
+            if (!isShift) {
+                lastSelectedNodeRef.current = nextNode;
+            }
+            isChanged = true;
+        }
+    }
+    return isChanged;
 }
-function s(e, t) {
-	if (t < 0) throw Error("selectedIndex must be non-negative");
-	let n = t;
-	for (let r = t - 1; r >= 0 && e[r].isSelected; r--) n = r;
-	let r = t;
-	for (let n = t + 1; n < e.length && e[n].isSelected; n++) r = n;
-	return {
-		minIndex: n,
-		maxIndex: r
-	};
+function getMinMaxIndexedOfSelection(nodes, selectedIndex) {
+    if (selectedIndex < 0) {
+        throw new Error('selectedIndex must be non-negative');
+    }
+    let minIndex = selectedIndex;
+    for(let i = selectedIndex - 1; i >= 0; i--){
+        if (nodes[i].isSelected) {
+            minIndex = i;
+        } else {
+            break;
+        }
+    }
+    let maxIndex = selectedIndex;
+    for(let i = selectedIndex + 1; i < nodes.length; i++){
+        if (nodes[i].isSelected) {
+            maxIndex = i;
+        } else {
+            break;
+        }
+    }
+    return {
+        minIndex,
+        maxIndex
+    };
 }
-function c(e, t) {
-	for (let n of e.getExpandedThisAndDescendants()) n.isSelected && (n.isExpanded = t);
+function expandOrCollapseSelected(root, expand) {
+    for (const node of root.getExpandedThisAndDescendants()){
+        if (node.isSelected) node.isExpanded = expand;
+    }
 }
-function l(t) {
-	let r = !1;
-	for (let i of t.getThisAndDescendantsByType(e)) i.isSelected && n(i) && (r = !0);
-	return r;
+function toggleCheckStateOnSelected(root) {
+    let isChanged = false;
+    for (const descendant of root.getThisAndDescendantsByType(TreeNode)){
+        if (descendant.isSelected && onToggleNode(descendant)) {
+            isChanged = true;
+        }
+    }
+    return isChanged;
 }
-function u(e) {
-	return r(e, (e) => e.isSelected);
+function getFirstSelectedIndex(nodes) {
+    return findIndex(nodes, (node)=>node.isSelected);
 }
-function d(e) {
-	return i(e, (e) => e.isSelected);
+function getLastSelectedIndex(nodes) {
+    return findLastIndex(nodes, (node)=>node.isSelected);
 }
-function f(e, t) {
-	let n = !1;
-	for (let r of e) r !== t && r.setSelected(!1) && (n = !0);
-	return n;
+function deselectAllExcept(nodes, except) {
+    let isChanged = false;
+    for (const node of nodes){
+        if (node !== except && node.setSelected(false)) {
+            isChanged = true;
+        }
+    }
+    return isChanged;
 }
-//#endregion
-export { a as onKeyDown };
+
+//# sourceMappingURL=tree-node-functions-on-key-down.js.map

package/dist/foundation/treeNodes/tree-node/tree-node-functions-on-key-down.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/treeNodes/tree-node/tree-node-functions-on-key-down.ts"],"sourcesContent":["import { findIndex, findLastIndex } from 'lodash-es';\n\nimport { TreeNode } from './tree-node';\nimport { clearSelection, onToggleNode } from './tree-node-functions';\n\nexport function onKeyDown(\n  root: TreeNode,\n  event: KeyboardEvent,\n  lastSelectedNodeRef: { current: TreeNode | undefined }\n): boolean {\n  if (event.key === 'ArrowRight' || event.key === 'ArrowLeft') {\n    const expand = event.key === 'ArrowRight';\n    expandOrCollapseSelected(root, expand);\n    return false;\n  }\n  if (event.key === 'Escape') {\n    return clearSelection(root);\n  }\n  if (event.key === 'Enter' || event.key === ' ') {\n    return toggleCheckStateOnSelected(root);\n  }\n  if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {\n    const direction = event.key === 'ArrowUp' ? -1 : 1;\n    const shift = event.shiftKey;\n    return selectOrExpandSelection(root, lastSelectedNodeRef, shift, direction);\n  }\n  return false;\n}\n\nfunction selectOrExpandSelection(\n  root: TreeNode,\n  lastSelectedNodeRef: { current: TreeNode | undefined },\n  isShift: boolean,\n  direction: number\n): boolean {\n  // direction = -1: Set previous node selected (before first selected), and clear all other selections\n  // direction = +1: Set next node selected (after last selected), and clear all other selections\n  const nodes = Array.from(root.getExpandedThisAndDescendants());\n  let selectedNode = lastSelectedNodeRef.current;\n  let selectedIndex =\n    selectedNode !== undefined ? nodes.indexOf(selectedNode) : -1;\n\n  const hasSelected =\n    selectedNode !== undefined && selectedNode.isSelected && selectedIndex >= 0;\n\n  if (hasSelected && isShift) {\n    let { minIndex, maxIndex } = getMinMaxIndexedOfSelection(\n      nodes,\n      selectedIndex\n    );\n    if (direction < 0) {\n      if (maxIndex > selectedIndex) {\n        return nodes[maxIndex].setSelected(false);\n      } else if (minIndex <= selectedIndex) {\n        minIndex--;\n        if (minIndex < 0) {\n          return false;\n        }\n        return nodes[minIndex].setSelected();\n      }\n    } else {\n      if (minIndex < selectedIndex) {\n        return nodes[minIndex].setSelected(false);\n      } else if (maxIndex >= selectedIndex) {\n        maxIndex++;\n        if (maxIndex >= nodes.length) {\n          return false;\n        }\n        return nodes[maxIndex].setSelected();\n      }\n    }\n  }\n  // Fallback\n  if (!hasSelected) {\n    selectedIndex =\n      direction < 0\n        ? getFirstSelectedIndex(nodes)\n        : getLastSelectedIndex(nodes);\n    selectedNode = selectedIndex >= 0 ? nodes[selectedIndex] : undefined;\n  }\n  let isChanged = false;\n  if (selectedNode) {\n    const nextIndex = selectedIndex + direction;\n    if (nextIndex < 0 || nextIndex >= nodes.length) {\n      return false;\n    }\n    const nextNode = nodes[nextIndex];\n    if (!isShift && deselectAllExcept(nodes, nextNode)) {\n      isChanged = true;\n    }\n    if (nextNode.setSelected()) {\n      if (!isShift) {\n        lastSelectedNodeRef.current = nextNode;\n      }\n      isChanged = true;\n    }\n  }\n  return isChanged;\n}\n\nfunction getMinMaxIndexedOfSelection(\n  nodes: TreeNode[],\n  selectedIndex: number\n): { minIndex: number; maxIndex: number } {\n  if (selectedIndex < 0) {\n    throw new Error('selectedIndex must be non-negative');\n  }\n  let minIndex = selectedIndex;\n  for (let i = selectedIndex - 1; i >= 0; i--) {\n    if (nodes[i].isSelected) {\n      minIndex = i;\n    } else {\n      break;\n    }\n  }\n  let maxIndex = selectedIndex;\n  for (let i = selectedIndex + 1; i < nodes.length; i++) {\n    if (nodes[i].isSelected) {\n      maxIndex = i;\n    } else {\n      break;\n    }\n  }\n  return { minIndex, maxIndex };\n}\n\nfunction expandOrCollapseSelected(root: TreeNode, expand: boolean): void {\n  for (const node of root.getExpandedThisAndDescendants()) {\n    if (node.isSelected) node.isExpanded = expand;\n  }\n}\n\nfunction toggleCheckStateOnSelected(root: TreeNode): boolean {\n  let isChanged = false;\n  for (const descendant of root.getThisAndDescendantsByType(TreeNode)) {\n    if (descendant.isSelected && onToggleNode(descendant)) {\n      isChanged = true;\n    }\n  }\n  return isChanged;\n}\n\nfunction getFirstSelectedIndex(nodes: TreeNode[]): number {\n  return findIndex(nodes, (node) => node.isSelected);\n}\n\nfunction getLastSelectedIndex(nodes: TreeNode[]): number {\n  return findLastIndex(nodes, (node) => node.isSelected);\n}\n\nfunction deselectAllExcept(nodes: TreeNode[], except: TreeNode): boolean {\n  let isChanged = false;\n  for (const node of nodes) {\n    if (node !== except && node.setSelected(false)) {\n      isChanged = true;\n    }\n  }\n  return isChanged;\n}\n"],"names":["findIndex","findLastIndex","TreeNode","clearSelection","onToggleNode","onKeyDown","root","event","lastSelectedNodeRef","key","expand","expandOrCollapseSelected","toggleCheckStateOnSelected","direction","shift","shiftKey","selectOrExpandSelection","isShift","nodes","Array","from","getExpandedThisAndDescendants","selectedNode","current","selectedIndex","undefined","indexOf","hasSelected","isSelected","minIndex","maxIndex","getMinMaxIndexedOfSelection","setSelected","length","getFirstSelectedIndex","getLastSelectedIndex","isChanged","nextIndex","nextNode","deselectAllExcept","Error","i","node","isExpanded","descendant","getThisAndDescendantsByType","except"],"mappings":"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"}

package/dist/foundation/treeNodes/tree-node/tree-node-functions.d.ts

@@ -1,17 +1,17 @@
-import { TreeNode } from './tree-node';
+import { TreeNode } from "./tree-node";
 export declare function onSelectNode(node: TreeNode, isShift: boolean, isControl: boolean, lastSelectedNode?: TreeNode): boolean;
 /**
- * Handles the event when a node's checkbox is clicked, toggling its state between `All` and `None`.
- * It also updates the checkbox states of all its descendants and ancestors.
- *
- * @param node - The tree node that was clicked.
- *
- * @remarks
- * - If the node's checkbox state is `All`, it will be set to `None`, and vice versa.
- * - All descendants of the node will have their checkbox states updated to match the node's
- *   new state, unless their state is undefined.
- * - All ancestors of the node will have their checkbox states recalculated,
- *   unless their state is undefined.
- */
+* Handles the event when a node's checkbox is clicked, toggling its state between `All` and `None`.
+* It also updates the checkbox states of all its descendants and ancestors.
+*
+* @param node - The tree node that was clicked.
+*
+* @remarks
+* - If the node's checkbox state is `All`, it will be set to `None`, and vice versa.
+* - All descendants of the node will have their checkbox states updated to match the node's
+*   new state, unless their state is undefined.
+* - All ancestors of the node will have their checkbox states recalculated,
+*   unless their state is undefined.
+*/
 export declare function onToggleNode(node: TreeNode): boolean;
 export declare function clearSelection(root: TreeNode, except?: TreeNode): boolean;

package/dist/foundation/treeNodes/tree-node/tree-node-functions.js

@@ -1,44 +1,115 @@
-import { CheckboxState as e } from "../../utilities/types.js";
-import { TreeNode as t } from "./tree-node.js";
-//#region libs/shared/reveal-components/src/foundation/treeNodes/tree-node/tree-node-functions.ts
-function n(e, t, n, r) {
-	let i = e.getRoot();
-	if (i === void 0) return !1;
-	if (n) return e.isSelected = !e.isSelected, !0;
-	if (t && r !== void 0 && r.isSelected) {
-		let t = Array.from(i.getExpandedThisAndDescendants()), n = t.indexOf(r);
-		if (n >= 0) {
-			let r = t.indexOf(e);
-			if (r >= 0) {
-				r < n && ([n, r] = [r, n]);
-				let e = !1;
-				for (let i = 0; i < t.length; i++) t[i].setSelected(n <= i && i <= r) && (e = !0);
-				return e;
-			}
-		}
-	}
-	let o = a(i, e);
-	return e.setSelected(!0) || o;
+import { CheckboxState } from "../../utilities/types.js";
+import { TreeNode } from "./tree-node.js";
+export function onSelectNode(node, isShift, isControl, lastSelectedNode) {
+    const root = node.getRoot();
+    if (root === undefined) {
+        return false;
+    }
+    if (isControl) {
+        // Just invert selection
+        node.isSelected = !node.isSelected;
+        return true;
+    }
+    if (isShift && lastSelectedNode !== undefined && lastSelectedNode.isSelected) {
+        // Expand selection from previous selected to this node, and set all other nodes unselected
+        const nodes = Array.from(root.getExpandedThisAndDescendants());
+        let startIndex = nodes.indexOf(lastSelectedNode);
+        if (startIndex >= 0) {
+            let endIndex = nodes.indexOf(node);
+            if (endIndex >= 0) {
+                if (endIndex < startIndex) {
+                    [startIndex, endIndex] = [
+                        endIndex,
+                        startIndex
+                    ];
+                }
+                let isChanged = false;
+                for(let i = 0; i < nodes.length; i++){
+                    if (nodes[i].setSelected(startIndex <= i && i <= endIndex)) {
+                        isChanged = true;
+                    }
+                }
+                return isChanged;
+            }
+        }
+    }
+    // Fallback to single select
+    // Deselect all others and select the clicked node
+    const isChanged = clearSelection(root, node);
+    return node.setSelected(true) || isChanged;
 }
-function r(n) {
-	if (n.checkboxState === void 0) return !1;
-	n.checkboxState = n.checkboxState === e.All ? e.None : e.All;
-	for (let e of n.getDescendants()) e.checkboxState !== void 0 && (e.checkboxState = n.checkboxState);
-	for (let e of n.getAncestorsByType(t)) e.checkboxState !== void 0 && (e.checkboxState = i(e));
-	return !0;
+/**
+ * Handles the event when a node's checkbox is clicked, toggling its state between `All` and `None`.
+ * It also updates the checkbox states of all its descendants and ancestors.
+ *
+ * @param node - The tree node that was clicked.
+ *
+ * @remarks
+ * - If the node's checkbox state is `All`, it will be set to `None`, and vice versa.
+ * - All descendants of the node will have their checkbox states updated to match the node's
+ *   new state, unless their state is undefined.
+ * - All ancestors of the node will have their checkbox states recalculated,
+ *   unless their state is undefined.
+ */ export function onToggleNode(node) {
+    if (node.checkboxState === undefined) {
+        return false;
+    }
+    if (node.checkboxState === CheckboxState.All) {
+        node.checkboxState = CheckboxState.None;
+    } else {
+        node.checkboxState = CheckboxState.All;
+    }
+    // Recalculate all descendants and ancestors
+    for (const descendant of node.getDescendants()){
+        if (descendant.checkboxState !== undefined) {
+            descendant.checkboxState = node.checkboxState;
+        }
+    }
+    for (const ancestor of node.getAncestorsByType(TreeNode)){
+        if (ancestor.checkboxState !== undefined) {
+            ancestor.checkboxState = calculateCheckboxState(ancestor);
+        }
+    }
+    return true;
 }
-function i(t) {
-	let n = 0, r = 0, i = 0;
-	for (let a of t.getChildren()) {
-		let t = a.checkboxState;
-		if (a.isCheckboxEnabled === !0 && t !== void 0 && (n++, t === e.All ? r++ : t === e.None && i++, r > 0 && i > 0)) return e.Some;
-	}
-	return n === 0 ? t.checkboxState : n === r ? e.All : n === i ? e.None : e.Some;
+function calculateCheckboxState(node) {
+    let numTotal = 0;
+    let numAll = 0;
+    let numNone = 0;
+    for (const child of node.getChildren()){
+        const checkboxState = child.checkboxState;
+        if (child.isCheckboxEnabled !== true || checkboxState === undefined) {
+            continue;
+        }
+        numTotal++;
+        if (checkboxState === CheckboxState.All) {
+            numAll++;
+        } else if (checkboxState === CheckboxState.None) {
+            numNone++;
+        }
+        if (numAll > 0 && numNone > 0) {
+            return CheckboxState.Some; // Optimization by early return
+        }
+    }
+    if (numTotal === 0) {
+        return node.checkboxState;
+    }
+    if (numTotal === numAll) {
+        return CheckboxState.All;
+    }
+    if (numTotal === numNone) {
+        return CheckboxState.None;
+    }
+    return CheckboxState.Some;
 }
-function a(e, n) {
-	let r = !1;
-	for (let i of e.getThisAndDescendantsByType(t)) i !== n && i.setSelected(!1) && (r = !0);
-	return r;
+export function clearSelection(root, except) {
+    let isChanged = false;
+    for (const descendant of root.getThisAndDescendantsByType(TreeNode)){
+        if (descendant !== except && descendant.setSelected(false)) {
+            isChanged = true;
+        }
+    }
+    return isChanged;
 }
-//#endregion
-export { a as clearSelection, n as onSelectNode, r as onToggleNode };
+
+//# sourceMappingURL=tree-node-functions.js.map

package/dist/foundation/treeNodes/tree-node/tree-node-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/foundation/treeNodes/tree-node/tree-node-functions.ts"],"sourcesContent":["import { CheckboxState } from '../../utilities/types';\n\nimport { TreeNode } from './tree-node';\n\nexport function onSelectNode(\n  node: TreeNode,\n  isShift: boolean,\n  isControl: boolean,\n  lastSelectedNode?: TreeNode\n): boolean {\n  const root = node.getRoot();\n  if (root === undefined) {\n    return false;\n  }\n  if (isControl) {\n    // Just invert selection\n    node.isSelected = !node.isSelected;\n    return true;\n  }\n  if (\n    isShift &&\n    lastSelectedNode !== undefined &&\n    lastSelectedNode.isSelected\n  ) {\n    // Expand selection from previous selected to this node, and set all other nodes unselected\n    const nodes = Array.from(root.getExpandedThisAndDescendants());\n    let startIndex = nodes.indexOf(lastSelectedNode);\n    if (startIndex >= 0) {\n      let endIndex = nodes.indexOf(node);\n      if (endIndex >= 0) {\n        if (endIndex < startIndex) {\n          [startIndex, endIndex] = [endIndex, startIndex];\n        }\n        let isChanged = false;\n        for (let i = 0; i < nodes.length; i++) {\n          if (nodes[i].setSelected(startIndex <= i && i <= endIndex)) {\n            isChanged = true;\n          }\n        }\n        return isChanged;\n      }\n    }\n  }\n  // Fallback to single select\n  // Deselect all others and select the clicked node\n  const isChanged = clearSelection(root, node);\n  return node.setSelected(true) || isChanged;\n}\n\n/**\n * Handles the event when a node's checkbox is clicked, toggling its state between `All` and `None`.\n * It also updates the checkbox states of all its descendants and ancestors.\n *\n * @param node - The tree node that was clicked.\n *\n * @remarks\n * - If the node's checkbox state is `All`, it will be set to `None`, and vice versa.\n * - All descendants of the node will have their checkbox states updated to match the node's\n *   new state, unless their state is undefined.\n * - All ancestors of the node will have their checkbox states recalculated,\n *   unless their state is undefined.\n */\nexport function onToggleNode(node: TreeNode): boolean {\n  if (node.checkboxState === undefined) {\n    return false;\n  }\n  if (node.checkboxState === CheckboxState.All) {\n    node.checkboxState = CheckboxState.None;\n  } else {\n    node.checkboxState = CheckboxState.All;\n  }\n  // Recalculate all descendants and ancestors\n  for (const descendant of node.getDescendants()) {\n    if (descendant.checkboxState !== undefined) {\n      descendant.checkboxState = node.checkboxState;\n    }\n  }\n  for (const ancestor of node.getAncestorsByType(TreeNode)) {\n    if (ancestor.checkboxState !== undefined) {\n      ancestor.checkboxState = calculateCheckboxState(ancestor);\n    }\n  }\n  return true;\n}\n\nfunction calculateCheckboxState(node: TreeNode): CheckboxState | undefined {\n  let numTotal = 0;\n  let numAll = 0;\n  let numNone = 0;\n\n  for (const child of node.getChildren()) {\n    const checkboxState = child.checkboxState;\n    if (child.isCheckboxEnabled !== true || checkboxState === undefined) {\n      continue;\n    }\n    numTotal++;\n    if (checkboxState === CheckboxState.All) {\n      numAll++;\n    } else if (checkboxState === CheckboxState.None) {\n      numNone++;\n    }\n    if (numAll > 0 && numNone > 0) {\n      return CheckboxState.Some; // Optimization by early return\n    }\n  }\n  if (numTotal === 0) {\n    return node.checkboxState;\n  }\n  if (numTotal === numAll) {\n    return CheckboxState.All;\n  }\n  if (numTotal === numNone) {\n    return CheckboxState.None;\n  }\n  return CheckboxState.Some;\n}\n\nexport function clearSelection(root: TreeNode, except?: TreeNode): boolean {\n  let isChanged = false;\n  for (const descendant of root.getThisAndDescendantsByType(TreeNode)) {\n    if (descendant !== except && descendant.setSelected(false)) {\n      isChanged = true;\n    }\n  }\n  return isChanged;\n}\n"],"names":["CheckboxState","TreeNode","onSelectNode","node","isShift","isControl","lastSelectedNode","root","getRoot","undefined","isSelected","nodes","Array","from","getExpandedThisAndDescendants","startIndex","indexOf","endIndex","isChanged","i","length","setSelected","clearSelection","onToggleNode","checkboxState","All","None","descendant","getDescendants","ancestor","getAncestorsByType","calculateCheckboxState","numTotal","numAll","numNone","child","getChildren","isCheckboxEnabled","Some","except","getThisAndDescendantsByType"],"mappings":"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"}

package/dist/foundation/treeNodes/tree-node/tree-node.d.ts

@@ -1,94 +1,94 @@
-import { Signal } from '@cognite/signal-utils';
-import { Class } from '../../domainObjectsHelpers/Class';
-import { IconColor, IconName, CheckboxState, UniqueId } from '../../utilities/types';
-import { ILazyLoader } from '../tree-node-type/i-lazy-loader';
-import { TreeNodeType } from '../tree-node-type/tree-node-type';
+import type { Signal } from "@cognite/signal-utils";
+import { type Class } from "../../domainObjectsHelpers/Class";
+import { type IconColor, type IconName, CheckboxState, type UniqueId } from "../../utilities/types";
+import { type ILazyLoader } from "../tree-node-type/i-lazy-loader";
+import { type TreeNodeType } from "../tree-node-type/tree-node-type";
 /**
- * Represents a node in a tree structure.
- * This is the default Implements the TreeNodeType interface and can be reused
- * By default it is a simple tree node with a label.
- * in most cases.
- */
+* Represents a node in a tree structure.
+* This is the default Implements the TreeNodeType interface and can be reused
+* By default it is a simple tree node with a label.
+* in most cases.
+*/
 export declare class TreeNode implements TreeNodeType {
-    readonly updateSignal: Signal<number>;
-    private _id?;
-    private _label;
-    private _icon;
-    private _iconColor;
-    private _isSelected;
-    private _checkboxState;
-    private _tooltip;
-    private _isExpanded;
-    private _isCheckboxEnabled;
-    private _hasBoldLabel;
-    private _hasInfoIcon;
-    private _isLoadingChildren;
-    private _isLoadingSiblings;
-    private _needLoadChildren;
-    private _needLoadSiblings;
-    protected _children: TreeNode[] | undefined;
-    protected _parent: TreeNode | undefined;
-    get childCount(): number;
-    get id(): UniqueId;
-    get label(): string;
-    set label(value: string);
-    get hasBoldLabel(): boolean;
-    set hasBoldLabel(value: boolean);
-    get icon(): IconName;
-    set icon(value: IconName);
-    get iconColor(): IconColor;
-    set iconColor(value: IconColor);
-    get hasInfoIcon(): boolean;
-    set hasInfoIcon(value: boolean);
-    get isSelected(): boolean;
-    set isSelected(value: boolean);
-    get isExpanded(): boolean;
-    set isExpanded(value: boolean);
-    get isCheckboxEnabled(): boolean;
-    set isCheckboxEnabled(value: boolean);
-    get checkboxState(): CheckboxState | undefined;
-    set checkboxState(value: CheckboxState | undefined);
-    get tooltip(): string | undefined;
-    set tooltip(value: string | undefined);
-    get needLoadChildren(): boolean;
-    set needLoadChildren(value: boolean);
-    get needLoadSiblings(): boolean;
-    set needLoadSiblings(value: boolean);
-    get isLoadingChildren(): boolean;
-    set isLoadingChildren(value: boolean);
-    get isLoadingSiblings(): boolean;
-    set isLoadingSiblings(value: boolean);
-    get isParent(): boolean;
-    get parent(): TreeNode | undefined;
-    get children(): TreeNode[] | undefined;
-    areEqual(child: TreeNode): boolean;
-    getRoot(): TreeNode;
-    getLastChild(): TreeNode | undefined;
-    getSelectedNodes(): TreeNode[];
-    getCheckedNodes(): TreeNode[];
-    deselectAll(): void;
-    expandAllAncestors(): void;
-    getChildren(loader?: ILazyLoader): Generator<TreeNode>;
-    getChildrenByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
-    getDescendants(): Generator<TreeNode>;
-    getExpandedThisAndDescendants(): Generator<TreeNode>;
-    getDescendantsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
-    getThisAndDescendants(): Generator<TreeNode>;
-    getThisAndDescendantsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
-    getAncestors(): Generator<TreeNode>;
-    getAncestorsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
-    getThisAndAncestorsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
-    addChild(child: TreeNode): void;
-    insertChild(index: number, child: TreeNode): void;
-    loadChildren(loader: ILazyLoader): Promise<void>;
-    loadSiblings(loader: ILazyLoader): Promise<void>;
-    hasChild(child: TreeNode): boolean;
-    /**
-     * Sets the selection state
-     *
-     * @param isSelected - Whether the node should be selected. Defaults to true
-     * @returns True if the selection state was changed, false if it was already in the desired state
-     */
-    setSelected(isSelected?: boolean): boolean;
-    update(): void;
+	readonly updateSignal: Signal<number>;
+	private _id?;
+	private _label;
+	private _icon;
+	private _iconColor;
+	private _isSelected;
+	private _checkboxState;
+	private _tooltip;
+	private _isExpanded;
+	private _isCheckboxEnabled;
+	private _hasBoldLabel;
+	private _hasInfoIcon;
+	private _isLoadingChildren;
+	private _isLoadingSiblings;
+	private _needLoadChildren;
+	private _needLoadSiblings;
+	protected _children: TreeNode[] | undefined;
+	protected _parent: TreeNode | undefined;
+	get childCount(): number;
+	get id(): UniqueId;
+	get label(): string;
+	set label(value: string);
+	get hasBoldLabel(): boolean;
+	set hasBoldLabel(value: boolean);
+	get icon(): IconName;
+	set icon(value: IconName);
+	get iconColor(): IconColor;
+	set iconColor(value: IconColor);
+	get hasInfoIcon(): boolean;
+	set hasInfoIcon(value: boolean);
+	get isSelected(): boolean;
+	set isSelected(value: boolean);
+	get isExpanded(): boolean;
+	set isExpanded(value: boolean);
+	get isCheckboxEnabled(): boolean;
+	set isCheckboxEnabled(value: boolean);
+	get checkboxState(): CheckboxState | undefined;
+	set checkboxState(value: CheckboxState | undefined);
+	get tooltip(): string | undefined;
+	set tooltip(value: string | undefined);
+	get needLoadChildren(): boolean;
+	set needLoadChildren(value: boolean);
+	get needLoadSiblings(): boolean;
+	set needLoadSiblings(value: boolean);
+	get isLoadingChildren(): boolean;
+	set isLoadingChildren(value: boolean);
+	get isLoadingSiblings(): boolean;
+	set isLoadingSiblings(value: boolean);
+	get isParent(): boolean;
+	get parent(): TreeNode | undefined;
+	get children(): TreeNode[] | undefined;
+	areEqual(child: TreeNode): boolean;
+	getRoot(): TreeNode;
+	getLastChild(): TreeNode | undefined;
+	getSelectedNodes(): TreeNode[];
+	getCheckedNodes(): TreeNode[];
+	deselectAll(): void;
+	expandAllAncestors(): void;
+	getChildren(loader?: ILazyLoader): Generator<TreeNode>;
+	getChildrenByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+	getDescendants(): Generator<TreeNode>;
+	getExpandedThisAndDescendants(): Generator<TreeNode>;
+	getDescendantsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+	getThisAndDescendants(): Generator<TreeNode>;
+	getThisAndDescendantsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+	getAncestors(): Generator<TreeNode>;
+	getAncestorsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+	getThisAndAncestorsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+	addChild(child: TreeNode): void;
+	insertChild(index: number, child: TreeNode): void;
+	loadChildren(loader: ILazyLoader): Promise<void>;
+	loadSiblings(loader: ILazyLoader): Promise<void>;
+	hasChild(child: TreeNode): boolean;
+	/**
+	* Sets the selection state
+	*
+	* @param isSelected - Whether the node should be selected. Defaults to true
+	* @returns True if the selection state was changed, false if it was already in the desired state
+	*/
+	setSelected(isSelected?: boolean): boolean;
+	update(): void;
 }