private static async loadItems()

in uui-core/src/data/processing/views/tree/treeStructure/helpers/FetchingHelper.ts [261:374]
93 lines of code
23 McCabe index (conditional complexity)

    private static async loadItems<TItem, TId, TFilter>({
        tree,
        options,
        byParentId,
        parentId,
        parent,
        dataSourceState,
        remainingRowsCount,
        loadAll,
    }: LoadItemsOptions<TItem, TId, TFilter>) {
        const {
            ids: originalIds,
            count: childrenCount,
            totalCount,
            assumedCount: prevAssumedCount,
            cursor: prevCursor,
        } = tree.getItems(parentId);
        const inputIds = byParentId.has(parentId) ? byParentId.get(parentId) ?? originalIds : originalIds;

        let ids = inputIds ?? [];
        const loadedItems: TItem[] = [];

        const flatten = dataSourceState.search && options.flattenSearchResults;

        // Selection cascading forces to load all nodes under particular node
        if (loadAll) {
            remainingRowsCount = Number.MAX_SAFE_INTEGER;
        }

        const missingCount = Math.max(0, remainingRowsCount - ids.length);

        const availableCount = childrenCount != null ? childrenCount - ids.length : missingCount;

        const range: LazyDataSourceApiRequestRange = { from: ids.length };

        let skipRequest = false;
        if (!loadAll) {
            range.count = missingCount;
            skipRequest = options.isLoadStrict ? true : skipRequest;
        }

        if (missingCount === 0 || availableCount === 0 || skipRequest) {
            return {
                ids,
                nodeInfo: { count: childrenCount, totalCount, assumedCount: prevAssumedCount, cursor: prevCursor },
                loadedItems,
            };
        }

        // Need to load additional items in the current layer
        const requestContext: LazyDataSourceApiRequestContext<TItem, TId> = {};

        if (!flatten) {
            if (parent != null) {
                requestContext.parentId = parentId;
                requestContext.parent = parent;
            } else {
                // in flatten mode, we don't set parent and parentId even for root - as we don't want to limit results to top-level nodes only
                requestContext.parentId = null;
                requestContext.parent = null;
            }
        }

        const response = await options.api(
            {
                sorting: dataSourceState.sorting,
                search: dataSourceState.search,
                filter: options.filter,
                range,
                page: dataSourceState.page,
                pageSize: dataSourceState.pageSize,
                cursor: prevCursor,
            },
            requestContext,
        );

        const from = response.from == null ? range.from : response.from;

        if (response.items?.length) {
            ids = [...ids];
            for (let n = 0; n < response.items.length; n++) {
                const item = response.items[n];
                loadedItems.push(item);
                const id = tree.getParams().getId(item);
                ids[n + from] = id;
            }
        }

        let newNodesCount;

        const loadedItemsCount = (response.items?.length ?? 0);
        if (response.count !== null && response.count !== undefined) {
            newNodesCount = response.count;
        } else if (loadedItemsCount < missingCount) {
            newNodesCount = from + loadedItemsCount;
        }

        let assumedCount = undefined;
        if (!flatten && parent && tree.getParams().getChildCount) {
            assumedCount = tree.getParams().getChildCount(parent);
        }

        let nodeInfo = { count: childrenCount, totalCount, assumedCount: prevAssumedCount, cursor: response.cursor };
        if (newNodesCount !== childrenCount || assumedCount !== prevAssumedCount) {
            nodeInfo = { ...nodeInfo, count: newNodesCount, assumedCount };
        }

        nodeInfo = { ...nodeInfo, totalCount: response.totalCount ?? totalCount };
        return {
            ids,
            nodeInfo,
            loadedItems,
        };
    }