private static implicitCascadeSelection()

in uui-core/src/data/processing/views/tree/treeStructure/helpers/CheckingHelper.ts [184:260]
57 lines of code
12 McCabe index (conditional complexity)

    private static implicitCascadeSelection<TItem, TId>({
        tree,
        checkedIdsMap,
        checkedId,
        isChecked,
        isCheckable,
    }: SelectionOptions<TItem, TId>) {
        if (isChecked) {
            // eslint-disable-next-line eqeqeq
            if (checkedId != ROOT_ID) {
                checkedIdsMap.set(checkedId, true);
            }

            // In implicit mode, no children are loaded into the parent.
            // When some child is checked and the search is cleared, while checking the top parent no children will be loaded,
            // so there will be no children in the list of checked parent's children. Because of such behavior, explicitly checked
            // children will not be removed from the list.
            // To remove them, it is required to pass through all the checked items and check, if their parents don't contain the checked item.
            if (checkedIdsMap.size) {
                for (const [id] of checkedIdsMap) {
                    if (isEqual(id, checkedId)) {
                        continue;
                    }
                    const path = Tree.getPathById(id, tree);
                    if (path.some((item) => isEqual(item.id, checkedId))) {
                        checkedIdsMap.delete(id);
                    }
                }
            }

            if (checkedId === ROOT_ID) {
                const { ids: childrenIds } = tree.getItems(checkedId);

                // if selectedId is undefined and it is selected, that means selectAll
                childrenIds.forEach((id) => checkedIdsMap.set(id, true));
            }
            // check parents if all children are checked
            return this.checkParentsWithFullCheck({
                tree,
                checkedIdsMap,
                checkedId,
                isCheckable,
                removeExplicitChildrenSelection: true,
            });
        }

        // eslint-disable-next-line eqeqeq
        if (checkedId != ROOT_ID) {
            checkedIdsMap.delete(checkedId);

            const selectNeighboursOnly = (itemId: TId) => {
                const item = tree.getById(itemId);
                if (item === NOT_FOUND_RECORD) {
                    return;
                }

                const parentId = tree.getParams().getParentId?.(item);
                const parents = Tree.getParents(itemId, tree);
                // if some parent is checked, it is required to check all children explicitly,
                // except unchecked one.
                const someParentIsChecked = parents.some((parent) => checkedIdsMap.get(parent));
                tree.getItems(parentId).ids.forEach((id) => {
                    if (itemId !== id && someParentIsChecked) {
                        checkedIdsMap.set(id, true);
                    }
                });
                checkedIdsMap.delete(parentId);
            };

            const parents = Tree.getParents(checkedId, tree);
            [checkedId, ...parents.reverse()].forEach(selectNeighboursOnly);

            return checkedIdsMap;
        }

        return this.clearAllChecked({ tree, checkedIdsMap, isCheckable });
    }