nexle-tvguide-lib/src/tvEPG/util.js

TV guide library for Android TV

import { TV_GUIDE_CONSTANTS } from '../tvEPG/constants';

export function formatDay(time) {
    return time.toLocaleString('en-GB', {
        weekday: 'short',
        day: 'numeric',
        month: 'short',
        year: 'numeric',
    });
}
export function formatTime(time) {
    return time.toLocaleString('en-GB', {
        weekday: 'short',
        day: 'numeric',
        month: 'short',
        hour: 'numeric',
        minute: 'numeric',
        hour12: true,
    });
}
export function formatShortDate(time) {
    const day = new Date(time);
    return `${day.getDate()}/${day.getMonth()}/${day.getUTCFullYear()}`;

}

export function formatHourMin(timestamp) {
    const day = new Date(timestamp);
    let minutes = day.getMinutes();
    if (isTimestampEqualEndOfDay(timestamp)) {
        minutes = 0;
        const minutesText = minutes < 10 ? `0${minutes}` : minutes;
        return `0:${minutesText}`;
    } else {
        const minutesText = minutes < 10 ? `0${minutes}` : minutes;
        return `${day.getHours()}:${minutesText}`;
    }
}

export const generateTimelineData = day => {
    let date = new Date(day);
    let dateEnd = new Date(day);
    date.setHours(0, 0, 0, 1);
    let timeStpCount = date.getTime();
    dateEnd.setHours(23, 59, 59, 999);
    const endOfDate = dateEnd.getTime();
    let listTime = [];

    while (timeStpCount < endOfDate) {
        const h = date.getHours();
        const m = date.getMinutes();
        listTime.push(
            {
                start: date.getTime(),
                text: `${h}:${m === 0 ? '00' : m}`,
            }
        )
        date.setMinutes(date.getMinutes() + 30);
        timeStpCount = date.getTime();
    }
    return listTime;
};


export const getStartDayTimestamp = (day) => {
    let date = new Date(day);
    date.setHours(0, 0, 0, 0);
    return date.getTime();
}

export const getEndDayTimestamp = (day) => {
    let date = new Date(day);
    date.setHours(24, 0, 0, 0);
    return date.getTime();
}

export const devideNoProgramByHalfHour = (noProgram) => {
    let noProgramList = [];
    const deltalTime = noProgram.endDate - noProgram.startDate;
    if (deltalTime > TV_GUIDE_CONSTANTS.HALF_HOUR_DURATION) {
        const multi = Math.floor((deltalTime - deltalTime % TV_GUIDE_CONSTANTS.HALF_HOUR_DURATION) / TV_GUIDE_CONSTANTS.HALF_HOUR_DURATION);
        for (let j = 1; j <= multi; j++) {
            const endDatePrev = (noProgramList.length > 0) ? noProgramList[noProgramList.length - 1].endDate : noProgram.startDate;
            let program = { ...noProgram };
            program.startDate = endDatePrev;
            program.endDate = program.startDate + TV_GUIDE_CONSTANTS.HALF_HOUR_DURATION;
            program.startDateAdjusted = program.startDate;
            program.endDateAdjusted = program.endDate;
            noProgramList.push(program);
        }
        const endDateLast = (noProgramList.length > 0) ? noProgramList[noProgramList.length - 1].endDate : noProgram.startDate;
        if ((noProgram.endDate - endDateLast) > 0) {
            let program = { ...noProgram };
            program.startDate = endDateLast;
            program.endDate = noProgram.endDate;
            program.startDateAdjusted = program.startDate;
            program.endDateAdjusted = program.endDate;
            noProgramList.push(program);
        }
    } else {
        noProgramList.push({ ...noProgram })
    }
    return noProgramList;

}

export const processProgramsData = (programListData, day) => {
    const timestampStartOfDay = getStartDayTimestamp(day);
    const timestampEndOfDay = getEndDayTimestamp(day);
    let processedChannelList = [...programListData];
    processedChannelList = programListData.map((channel, index) => {
        let { programs } = channel;
        if (Array.isArray(programs) && programs.length === 0 || (programs.length === 1 && programs[0].id === -1)) {
            return {
                ...channel,
                programs: fillNoProgramsOfDay(day)
            }
        } else {
            programs.sort((program1, program2) => program1?.startDate - program2?.startDate);
            let noProgramList = [];
            programs = programs.map((programItem, indexProgram) => {
                if (programItem.startDate === 0) {
                    programItem.startDate = timestampStartOfDay;
                }
                if (programItem.endDate === 0) {
                    programItem.endDate = timestampEndOfDay;
                }
                if ((indexProgram !== programs.length - 1) && programItem.endDate < programs[indexProgram + 1].startDate) {
                    const newEmptyProgram = {
                        id: - 1,
                        startDate: programItem.endDate,
                        endDate: programs[indexProgram + 1].startDate,
                        startDateAdjusted: programItem.endDate,
                        endDateAdjusted: programs[indexProgram + 1].startDate,
                    };
                    const noProgramsEmpty = devideNoProgramByHalfHour(newEmptyProgram);
                    noProgramList = noProgramList.concat(noProgramsEmpty);
                }

                programItem.startDateAdjusted = programItem.startDate;
                programItem.endDateAdjusted = programItem.endDate;
                if (programItem.startDate < timestampStartOfDay) {
                    programItem.startDateAdjusted = timestampStartOfDay;
                    programItem.endDateAdjusted = programItem.endDate;
                }
                if (programItem.endDate > timestampEndOfDay) {
                    programItem.startDateAdjusted = programItem.startDate;
                    programItem.endDateAdjusted = timestampEndOfDay;
                }
                if (programItem.id === -1) {
                    const noPrograms = devideNoProgramByHalfHour(programItem);
                    noProgramList = noProgramList.concat(noPrograms);
                }
                return programItem;
            });

            programs = programs.filter(item => item.id !== -1);
            programs = programs.concat(noProgramList);
            programs.sort((program1, program2) => program1?.startDate - program2?.startDate)
            return {
                ...channel,
                programs
            }
        }

    });
    return processedChannelList;
}

export const getDefaultActiveProgramIndex = (programsList) => {
    if (typeof programsList !== 'object' || !programsList || programsList.length === 0) return 0;
    const today = new Date();
    const todayTimestamp = today.getTime();
    const indexProgramInitialFocus = programsList.findIndex(program => program.startDate <= todayTimestamp && program.endDate >= todayTimestamp)
    if (indexProgramInitialFocus !== -1)
        return indexProgramInitialFocus;
    return 0;
}

export const fillNoProgramsOfDay = (day) => {
    let programList = [];
    const timestampEndOfDay = getEndDayTimestamp(day);
    const timesGenarator = generateTimelineData(day);
    timesGenarator.map((timePart, index) => {
        if (index !== timesGenarator.length - 1) {
            programList.push(
                {
                    id: -1,
                    startDate: timePart.start,
                    startDateAdjusted: timePart.start,
                    endDate: timesGenarator[index + 1].start,
                    endDateAdjusted: timesGenarator[index + 1].start,
                }
            );
        } else {
            programList.push(
                {
                    id: -1,
                    startDate: timePart.start,
                    startDateAdjusted: timePart.start,
                    endDateAdjusted: timestampEndOfDay,
                    endDate: timestampEndOfDay,
                });
        }
    });
    return programList;
}

export const getDurationFromDateStart = (day, time) => {
    return Number(time - getStartDayTimestamp(day));
}

export const getDurationToDateEnd = (day, time) => {
    return Number(getEndDayTimestamp(day) - time);
}


export const compareTwoDates = (date1, date2) => {
    let day1 = new Date(date1);
    day1.setHours(0, 0, 0, 1);
    let day2 = new Date(date2);
    day2.setHours(0, 0, 0, 1);
    return day1.getTime() === day2.getTime();
}

export const isTimestampEqualEndOfDay = (timestamp) => {
    let date = new Date(timestamp);
    date.setHours(23, 59, 59, 999);
    return timestamp === date.getTime();
}