table.ts

    class YieldTable {
        element: HTMLElement;

        constructor(data: Data) {
            this.element = S.create("div", "amura_yield_table")
            this.parseValues(data)
            this.render(data)
        }

        private parseValues(data: Data) {
            let startTime;
            let endTime;

            let intervals = data.intervals;
            for (let j = 0, k = intervals.length; j < k; j++) {
                let interval = intervals[j];
                if (interval.start) {
                    interval.start = new Date(interval.start as string)
                }
                if (interval.end) {
                    interval.end = new Date(interval.end as string)
                }

                if (!startTime || startTime > interval.startTime) {
                    startTime = interval.startTime;
                }
                if (!endTime || endTime < interval.endTime) {
                    endTime = interval.endTime;
                }
            }

            data.startTime = startTime
            data.endTime = endTime

            let rs = data.reservations;
            for (let j = 0, k = rs.length; j < k; j++) {
                rs[j].start = new Date(rs[j].start as any);
            }
        }

        private render(data: Data) {
            this.renderHeader(data.startTime, data.endTime)

            let d = data.start;
            let end = data.end;
            let loopGuard = 0;

            while (d < end) {
                this.renderDay(d, data)
                d = S.addDays(d, 1)

                loopGuard++;
                if (loopGuard > 400) {
                    S.logError(T("@@La configuración es incorrecta."))
                    throw "Unbounded loop"
                }
            }
        }

        private renderHeader(startTime: number, endTime: number) {
            let row = S.create("div", "row header", this.element)
            S.create("div", "dateLabel", row)
            let cells = S.create("div", "headerCells", row)

            let d = S.setTimeMillis(new Date(), startTime)
            let end = S.setTimeMillis(d, endTime)
            let loopGuard = 0;

            while (d < end) {
                let hour = d.getHours()
                let type;
                if (hour <= 12) {
                    type = "am"
                } else {
                    hour -= 12;
                    type = "pm"
                }

                let cell = S.create("div", "cell", cells, String(hour))
                cell.style.left = Math.floor((S.getTimeMillis(d) - startTime) / 60000) * PIXELS_PER_MIN + "px";
                cell.style.width = 60 * PIXELS_PER_MIN + "px"

                S.create("span", "type", cell, type)

                d = S.addMinutes(d, 60)
                loopGuard++
                if (loopGuard > 2000) {
                    S.logError(T("@@La configuración es incorrecta."))
                    throw "Unbounded loop"
                }
            }
        }

        private renderDay(d: Date, data: Data) {
            let row = S.create("div", "row", this.element)

            let label = S.create("div", "dateLabel", row, S.formatDate(d, "d"))
            let name = S.create("span", "dayName", label, S.getWeekDayshortName(d))
            switch (d.getDay()) {
                case 0:
                case 6:
                    name.classList.add("weekend")
                    break;
            }

            let cells = S.create("div", "cells", row)

            let intervals = this.getIntervals(d, data.intervals)
            let reservations = data.reservations

            for (let j = 0, k = intervals.length; j < k; j++) {
                let interval = intervals[j]
                let start = S.setTimeMillis(d, interval.startTime)
                let end = S.setTimeMillis(d, interval.endTime)
                let minutes = interval.duration;
                if (minutes == 0) {
                    S.logError(T("@@La configuración es incorrecta.") + " " + T("@@El intervalo del periodo no puede ser cero"))
                    throw "errror"
                }

                let m = start;

                let loopGuard = 0;
                while (m < end) {
                    let cell = S.create("span", "cell", cells)
                    cell.style.left = Math.floor((S.getTimeMillis(m) - data.startTime) / 60000) * PIXELS_PER_MIN + "px";
                    cell.style.width = minutes * PIXELS_PER_MIN + "px"

                    let count = reservations.count(t => t.start.getTime() == m.getTime())
                    let percent = Math.round((count * 100) / data.slots);

                    let inner = S.create("span", "inner", cell)
                    inner.title = percent + "%";
                    inner.style.opacity = String(percent / 100)

                    m = S.addMinutes(m, minutes)
                    loopGuard++
                    if (loopGuard > 2000) {
                        S.logError(T("@@La configuración es incorrecta."))
                        throw "Unbounded loop"
                    }
                }
            }
        }

        private getIntervals(d: Date, intervals: Interval[]) {
            let result = [];

            for (let j = 0, k = intervals.length; j < k; j++) {
                let interval = intervals[j];
                if (interval.start && interval.start > d) {
                    continue;
                }
                if (interval.end && interval.end < d) {
                    continue;
                }
                if (interval.weekDays != null && !S.isWeekdayActive(interval.weekDays, d.getDay())) {
                    continue;
                }
                result.push(interval);
            }

            return result;
        }
    }