@itwin/presentation-hierarchies-react
Version:
React components based on `@itwin/presentation-hierarchies`
158 lines • 5.87 kB
JavaScript
;
/*---------------------------------------------------------------------------------------------
* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
* See LICENSE.md in the project root for license terms and full copyright notice.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.TreeModel = void 0;
exports.isTreeModelHierarchyNode = isTreeModelHierarchyNode;
exports.isTreeModelInfoNode = isTreeModelInfoNode;
/** @internal */
function isTreeModelHierarchyNode(node) {
return "nodeData" in node && node.nodeData !== undefined;
}
/** @internal */
function isTreeModelInfoNode(node) {
return "type" in node && node.type !== undefined;
}
/** @internal */
var TreeModel;
(function (TreeModel) {
function expandNode(model, nodeId, isExpanded) {
const node = model.idToNode.get(nodeId);
if (!node || !isTreeModelHierarchyNode(node)) {
return "none";
}
node.isExpanded = isExpanded;
if (!isExpanded || !node.children) {
return "none";
}
const children = model.parentChildMap.get(node.id);
if (!children) {
node.isLoading = true;
return "loadChildren";
}
if (children.length !== 1) {
return "none";
}
const firstChild = TreeModel.getNode(model, children[0]);
if (!firstChild || !isTreeModelInfoNode(firstChild) || firstChild.type !== "Unknown") {
return "none";
}
// remove subtree if there is only one `Unknown` info node in order to attempt reloading children
TreeModel.removeSubTree(model, nodeId);
node.isLoading = true;
return "reloadChildren";
}
TreeModel.expandNode = expandNode;
/** @internal */
function addHierarchyPart(model, rootId, hierarchyPart) {
removeSubTree(model, rootId);
for (const [parentId, children] of hierarchyPart.parentChildMap) {
model.parentChildMap.set(parentId, children);
}
for (const [nodeId, node] of hierarchyPart.idToNode) {
model.idToNode.set(nodeId, node);
}
const parentNode = rootId !== undefined ? model.idToNode.get(rootId) : model.rootNode;
/* c8 ignore next 3*/
if (!parentNode || isTreeModelInfoNode(parentNode)) {
return;
}
parentNode.isLoading = false;
}
TreeModel.addHierarchyPart = addHierarchyPart;
function removeSubTree(model, parentId) {
const currentChildren = model.parentChildMap.get(parentId);
if (!currentChildren) {
return;
}
model.parentChildMap.delete(parentId);
for (const childId of currentChildren) {
const childNode = model.idToNode.get(childId);
if (childNode && isTreeModelHierarchyNode(childNode)) {
removeSubTree(model, childNode.id);
}
model.idToNode.delete(childId);
}
}
TreeModel.removeSubTree = removeSubTree;
function setHierarchyLimit(model, nodeId, limit) {
return updateForReload(model, nodeId, (node) => {
node.hierarchyLimit = limit;
});
}
TreeModel.setHierarchyLimit = setHierarchyLimit;
function setInstanceFilter(model, nodeId, filter) {
return updateForReload(model, nodeId, (node) => {
if (filter && isTreeModelHierarchyNode(node)) {
node.isExpanded = true;
}
node.instanceFilter = filter;
});
}
TreeModel.setInstanceFilter = setInstanceFilter;
function selectNodes(model, nodeIds, changeType) {
if (changeType === "replace") {
for (const [nodeId, node] of model.idToNode) {
if (!isTreeModelHierarchyNode(node)) {
continue;
}
node.isSelected = !!nodeIds.find((id) => id === nodeId);
}
return;
}
for (const nodeId of nodeIds) {
const modelNode = model.idToNode.get(nodeId);
if (!modelNode || !isTreeModelHierarchyNode(modelNode)) {
return;
}
modelNode.isSelected = changeType === "add";
}
}
TreeModel.selectNodes = selectNodes;
function isNodeSelected(model, nodeId) {
const currentNode = model.idToNode.get(nodeId);
return !!currentNode && isTreeModelHierarchyNode(currentNode) && !!currentNode.isSelected;
}
TreeModel.isNodeSelected = isNodeSelected;
function getNode(model, nodeId) {
if (!nodeId) {
return model.rootNode;
}
return model.idToNode.get(nodeId);
}
TreeModel.getNode = getNode;
function setIsLoading(model, nodeId, isLoading) {
if (nodeId === undefined) {
model.rootNode.isLoading = isLoading;
return;
}
const modelNode = model.idToNode.get(nodeId);
/* c8 ignore next 3*/
if (!modelNode || !isTreeModelHierarchyNode(modelNode)) {
return;
}
modelNode.isLoading = isLoading;
}
TreeModel.setIsLoading = setIsLoading;
})(TreeModel || (exports.TreeModel = TreeModel = {}));
function updateForReload(model, nodeId, update) {
TreeModel.removeSubTree(model, nodeId);
if (nodeId === undefined) {
update(model.rootNode);
model.rootNode.isLoading = true;
return true;
}
const modelNode = model.idToNode.get(nodeId);
if (!modelNode || !isTreeModelHierarchyNode(modelNode)) {
return false;
}
update(modelNode);
if (modelNode.isExpanded) {
modelNode.isLoading = true;
return true;
}
return false;
}
//# sourceMappingURL=TreeModel.js.map