private static async loadMissingItemsAndParents()

in uui-core/src/data/processing/views/tree/treeStructure/helpers/FetchingHelper.ts [195:259]
58 lines of code
16 McCabe index (conditional complexity)

    private static async loadMissingItemsAndParents<TItem, TId, TFilter>({
        tree,
        newItemsMap,
        options,
        itemsToLoad,
    }: LoadMissingItemsAndParentsOptions<TItem, TId, TFilter>) {
        const updatedItemsMap = cloneMap(newItemsMap);
        let iteration = 0;
        let prevMissingIds = new Set<TId>();
        let loadedItems: TItem[] = [];
        const isItemNotLoaded = (id: TId) => tree.getById(id) === NOT_FOUND_RECORD && !updatedItemsMap.has(id);

        while (true) {
            const missingIds = new Set<TId>();
            if (itemsToLoad && itemsToLoad.length > 0) {
                itemsToLoad.forEach((id) => {
                    if (isItemNotLoaded(id)) {
                        missingIds.add(id);
                    }
                });
            }
            if (tree.getParams().getParentId) {
                for (const [, item] of updatedItemsMap) {
                    const parentId = tree.getParams().getParentId(item);
                    if (parentId != null && isItemNotLoaded(parentId)) {
                        missingIds.add(parentId);
                    }
                }
            }

            if (missingIds.size === 0) {
                break;
            } else {
                const ids = Array.from(missingIds);
                const response = await options.api({ ids });
                if (response.items.length !== ids.length) {
                    console.error(`LazyTree: api does not returned requested items. Check that you handle 'ids' argument correctly.
                        Read more here: https://github.com/epam/UUI/issues/89`);
                }

                const newItems = response.items.filter((item) => {
                    const id = item ? tree.getParams().getId(item) : null;
                    return id !== null;
                });

                newItems.forEach((item) => {
                    const id = tree.getParams().getId(item);
                    updatedItemsMap.set(id, item);
                });

                loadedItems = loadedItems.concat(newItems);
                if (prevMissingIds.size === missingIds.size && isEqual(prevMissingIds, missingIds)) {
                    break;
                }

                prevMissingIds = new Set([...missingIds]);
            }
            iteration++;

            if (iteration > 1000) {
                throw new Error('LazyTree: More than 1000 iterations are made to load required items and their parents by ID. Check your api implementation');
            }
        }
        return { itemsMap: updatedItemsMap, loadedItems };
    }