Function getProgramDescs

src/Data/ProgramData.js:142–194

(programIds, isRefresh = false, {priority = FOREGROUND_PRIORITY} = {})

}

export async function getProgramDescs(programIds, isRefresh = false, {priority = FOREGROUND_PRIORITY} = {}) {
    const uniqueProgramIds = [...new Set(programIds)].filter(Boolean);
    const requestEpoch = getCacheEpoch();
    const entries = await Promise.all(uniqueProgramIds.map((programId) => (
        readCacheEntry(programDescCacheKey(programId), {legacyFields: ["description"], requestEpoch})
    )));
    if (requestEpoch !== getCacheEpoch()) {
        return {};
    }

    const cachedDescriptions = Object.fromEntries(uniqueProgramIds.flatMap((programId, index) => (
        entries[index] ? [[programId, entries[index].value]] : []
    )));
    const expiredProgramIds = uniqueProgramIds.filter((programId, index) => (
        isCacheEntryExpired(entries[index], isRefresh)
    ));
    const request = beginCacheRequests(expiredProgramIds.map(programDescCacheKey), priority, requestEpoch);
    const requestProgramIds = request.keys.map(programIdFromDescCacheKey);

    if (requestProgramIds.length === 0) {
        return cachedDescriptions;
    }

    try {
        const response = await apiJson(PROGRAM_DESC_BATCH, {
            body: {ProgramIDs: requestProgramIds},
            fetchPriority: priority,
        });
        const refreshedDescriptions = requestProgramIds.reduce((descriptions, programId) => ({
            ...descriptions,
            [programId]: response.data?.[programId] ?? null,
        }), {});
        const cacheWrites = requestProgramIds.map((programId) => {
            const key = programDescCacheKey(programId);
            return writeCacheValue(key, refreshedDescriptions[programId], {
                requestEpoch: request.epoch,
                requestVersion: request.versionFor(key),
            });
        });
        if (priority === BACKGROUND_PRIORITY) {
            await Promise.all(cacheWrites);
        } else {
            cacheWrites.forEach((cacheWrite) => void cacheWrite.catch(() => {
            }));
        }
        return {
            ...cachedDescriptions,
            ...refreshedDescriptions,
        };
    } finally {
        request.release();
    }
}

export async function getProgramContent(programId, isRefresh = false) {
    /*