13331632524

Committed 14 Feb 2025 02:51PM CUT coverage: 22.015% (-69.6%) from 91.622%

Build # 13331632524

Build Type

Pull #15372

github

Committed by

web-flow

Commit Message

Merge d52d57714 into bcb78ae0a

Pull Request Pull Request #15372: chore(*): test ci passing

Run Details

1990 of 15592 branches covered (12.76%)

431 of 964 new or added lines in 18 files covered. (44.71%)

19956 existing lines in 307 files now uncovered.

6452 of 29307 relevant lines covered (22.02%)

249.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/projects/igniteui-angular/src/lib/calendar/common/helpers.ts

import {
    CalendarDay,
    CalendarRangeParams,
    DayParameter,
    daysInWeek,
    toCalendarDay,
} from "./model";
import { DateRangeDescriptor, DateRangeType } from "./types";
import { first, last, modulo } from "../../core/utils";

interface IFormattedParts {
    value: string;
    literal: string;
    combined: string;
}

export function areSameMonth(
    firstMonth: DayParameter,
    secondMonth: DayParameter,
) {
    const [a, b] = [toCalendarDay(firstMonth), toCalendarDay(secondMonth)];
    return a.year === b.year && a.month === b.month;
}

export function isNextMonth(target: DayParameter, origin: DayParameter) {
    const [a, b] = [toCalendarDay(target), toCalendarDay(origin)];
    return a.year === b.year ? a.month > b.month : a.year > b.year;
}

export function isPreviousMonth(target: DayParameter, origin: DayParameter) {
    const [a, b] = [toCalendarDay(target), toCalendarDay(origin)];
    return a.year === b.year ? a.month < b.month : a.year < b.year;
}

/** Returns the next date starting from `start` that does not match the `disabled` descriptors */
export function getNextActiveDate(
    start: CalendarDay,
    disabled: DateRangeDescriptor[] = [],
) {
    while (isDateInRanges(start, disabled)) {
        start = start.add("day", 1);
    }

    return start;
}

/** Returns the previous date starting from `start` that does not match the `disabled` descriptors */
export function getPreviousActiveDate(
    start: CalendarDay,
    disabled: DateRangeDescriptor[] = [],
) {
    while (isDateInRanges(start, disabled)) {
        start = start.add("day", -1);
    }

    return start;
}

export function getClosestActiveDate(
    start: CalendarDay,
    delta: number,
    disabled: DateRangeDescriptor[] = [],
): CalendarDay {
    // TODO: implement a more robust logic for max attempts,
    // i.e. the amount of days to jump between before giving up
    // currently it will try to find the closest date for a year
    const maxAttempts = 366;
    let date = start;
    let attempts = 0;

    while (attempts < maxAttempts) {
        date = start.add("day", delta * (attempts + 1));

        if (!isDateInRanges(date, disabled)) {
            return date;
        }

        attempts++;
    }

    return date;
}

/**
 * Returns a generator yielding day values between `start` and `end` (non-inclusive)
 * by a given `unit` as a step.
 *
 * @remarks
 * By default, `unit` is set to 'day'.
 */
export function* calendarRange(options: CalendarRangeParams) {
    let low = toCalendarDay(options.start);
    const unit = options.unit ?? "day";
    const high =
        typeof options.end === "number"
            ? low.add(unit, options.end)
            : toCalendarDay(options.end);

    const reverse = high.lessThan(low);
    const step = reverse ? -1 : 1;

    while (!reverse ? low.lessThan(high) : low.greaterThan(high)) {
        yield low;
        low = low.add(unit, step);
    }
}

export function* generateMonth(value: DayParameter, firstWeekDay: number) {
    const { year, month } = toCalendarDay(value);

    const start = new CalendarDay({ year, month });
    const offset = modulo(start.day - firstWeekDay, daysInWeek);
    yield* calendarRange({
        start: start.add("day", -offset),
        end: 42,
    });
}

export function getYearRange(current: DayParameter, range: number) {
    const year = toCalendarDay(current).year;
    const start = Math.floor(year / range) * range;
    return { start, end: start + range - 1 };
}

export function isDateInRanges(
    date: DayParameter,
    ranges: DateRangeDescriptor[],
) {
    const value = toCalendarDay(date);

    return ranges.some((range) => {
        const days = (range.dateRange ?? []).map((day) => toCalendarDay(day));

        switch (range.type) {
            case DateRangeType.After:
                return value.greaterThan(first(days));

            case DateRangeType.Before:
                return value.lessThan(first(days));

            case DateRangeType.Between: {
                const min = Math.min(
                    first(days).timestamp,
                    last(days).timestamp,
                );
                const max = Math.max(
                    first(days).timestamp,
                    last(days).timestamp,
                );
                return value.timestamp >= min && value.timestamp <= max;
            }

            case DateRangeType.Specific:
                return days.some((day) => day.equalTo(value));

            case DateRangeType.Weekdays:
                return !value.weekend;

            case DateRangeType.Weekends:
                return value.weekend;

            default:
                return false;
        }
    });
}

export function formatToParts(
    date: Date,
    locale: string,
    options: Intl.DateTimeFormatOptions,
    parts: string[],
): Record<string, any> {
    const formatter = new Intl.DateTimeFormat(locale, options);
    const result: Record<string, any> = {
        date,
        full: formatter.format(date),
    };

    const getFormattedPart = (
        formattedParts: Intl.DateTimeFormatPart[],
        partType: string,
    ): IFormattedParts => {
        const part = formattedParts.find(({ type }) => type === partType);
        const nextPart = formattedParts[formattedParts.indexOf(part) + 1];
        const value = part?.value || "";
        const literal = nextPart?.type === "literal" ? nextPart.value : "";
        return {
            value,
            literal,
            combined: value + literal,
        };
    };

    if ("formatToParts" in formatter) {
        const formattedParts = formatter.formatToParts(date);
        parts.forEach(
            (part) => (result[part] = getFormattedPart(formattedParts, part)),
        );
    } else {
        parts.forEach(
            (part) => (result[part] = { value: "", literal: "", combined: "" }),
        );
    }

    return result;
}

1	import {
2	CalendarDay,
3	CalendarRangeParams,
4	DayParameter,
5	daysInWeek,
6	toCalendarDay,
7	} from "./model";
8	import { DateRangeDescriptor, DateRangeType } from "./types";
9	import { first, last, modulo } from "../../core/utils";
10
11	interface IFormattedParts {
12	value: string;
13	literal: string;
14	combined: string;
15	}
16
17	export function areSameMonth(
18	firstMonth: DayParameter,
19	secondMonth: DayParameter,
20	) {
UNCOV 21	const [a, b] = [toCalendarDay(firstMonth), toCalendarDay(secondMonth)];	×
UNCOV 22	return a.year === b.year && a.month === b.month;	×
23	}
24
25	export function isNextMonth(target: DayParameter, origin: DayParameter) {
UNCOV 26	const [a, b] = [toCalendarDay(target), toCalendarDay(origin)];	×
UNCOV 27	return a.year === b.year ? a.month > b.month : a.year > b.year;	×
28	}
29
30	export function isPreviousMonth(target: DayParameter, origin: DayParameter) {
UNCOV 31	const [a, b] = [toCalendarDay(target), toCalendarDay(origin)];	×
UNCOV 32	return a.year === b.year ? a.month < b.month : a.year < b.year;	×
33	}
34
35	/** Returns the next date starting from `start` that does not match the `disabled` descriptors */
36	export function getNextActiveDate(
37	start: CalendarDay,
38	disabled: DateRangeDescriptor[] = [],	×
39	) {
UNCOV 40	while (isDateInRanges(start, disabled)) {	×
UNCOV 41	start = start.add("day", 1);	×
42	}
43
UNCOV 44	return start;	×
45	}
46
47	/** Returns the previous date starting from `start` that does not match the `disabled` descriptors */
48	export function getPreviousActiveDate(
49	start: CalendarDay,
50	disabled: DateRangeDescriptor[] = [],	×
51	) {
UNCOV 52	while (isDateInRanges(start, disabled)) {	×
UNCOV 53	start = start.add("day", -1);	×
54	}
55
UNCOV 56	return start;	×
57	}
58
59	export function getClosestActiveDate(
60	start: CalendarDay,
61	delta: number,
62	disabled: DateRangeDescriptor[] = [],	×
63	): CalendarDay {
64	// TODO: implement a more robust logic for max attempts,
65	// i.e. the amount of days to jump between before giving up
66	// currently it will try to find the closest date for a year
UNCOV 67	const maxAttempts = 366;	×
UNCOV 68	let date = start;	×
UNCOV 69	let attempts = 0;	×
70
UNCOV 71	while (attempts < maxAttempts) {	×
UNCOV 72	date = start.add("day", delta * (attempts + 1));	×
73
UNCOV 74	if (!isDateInRanges(date, disabled)) {	×
UNCOV 75	return date;	×
76	}
77
UNCOV 78	attempts++;	×
79	}
80
81	return date;	×
82	}
83
84	/**
85	* Returns a generator yielding day values between `start` and `end` (non-inclusive)
86	* by a given `unit` as a step.
87	*
88	* @remarks
89	* By default, `unit` is set to 'day'.
90	*/
91	export function* calendarRange(options: CalendarRangeParams) {
UNCOV 92	let low = toCalendarDay(options.start);	×
UNCOV 93	const unit = options.unit ?? "day";	×
94	const high =
UNCOV 95	typeof options.end === "number"	×
96	? low.add(unit, options.end)
97	: toCalendarDay(options.end);
98
UNCOV 99	const reverse = high.lessThan(low);	×
UNCOV 100	const step = reverse ? -1 : 1;	×
101
UNCOV 102	while (!reverse ? low.lessThan(high) : low.greaterThan(high)) {	×
UNCOV 103	yield low;	×
UNCOV 104	low = low.add(unit, step);	×
105	}
106	}
107
108	export function* generateMonth(value: DayParameter, firstWeekDay: number) {
UNCOV 109	const { year, month } = toCalendarDay(value);	×
110
UNCOV 111	const start = new CalendarDay({ year, month });	×
UNCOV 112	const offset = modulo(start.day - firstWeekDay, daysInWeek);	×
UNCOV 113	yield* calendarRange({	×
114	start: start.add("day", -offset),
115	end: 42,
116	});
117	}
118
119	export function getYearRange(current: DayParameter, range: number) {
UNCOV 120	const year = toCalendarDay(current).year;	×
UNCOV 121	const start = Math.floor(year / range) * range;	×
UNCOV 122	return { start, end: start + range - 1 };	×
123	}
124
125	export function isDateInRanges(
126	date: DayParameter,
127	ranges: DateRangeDescriptor[],
128	) {
UNCOV 129	const value = toCalendarDay(date);	×
130
UNCOV 131	return ranges.some((range) => {	×
UNCOV 132	const days = (range.dateRange ?? []).map((day) => toCalendarDay(day));	×
133
UNCOV 134	switch (range.type) {	×
135	case DateRangeType.After:
UNCOV 136	return value.greaterThan(first(days));	×
137
138	case DateRangeType.Before:
UNCOV 139	return value.lessThan(first(days));	×
140
141	case DateRangeType.Between: {
UNCOV 142	const min = Math.min(	×
143	first(days).timestamp,
144	last(days).timestamp,
145	);
UNCOV 146	const max = Math.max(	×
147	first(days).timestamp,
148	last(days).timestamp,
149	);
UNCOV 150	return value.timestamp >= min && value.timestamp <= max;	×
151	}
152
153	case DateRangeType.Specific:
UNCOV 154	return days.some((day) => day.equalTo(value));	×
155
156	case DateRangeType.Weekdays:
UNCOV 157	return !value.weekend;	×
158
159	case DateRangeType.Weekends:
UNCOV 160	return value.weekend;	×
161
162	default:
163	return false;	×
164	}
165	});
166	}
167
168	export function formatToParts(
169	date: Date,
170	locale: string,
171	options: Intl.DateTimeFormatOptions,
172	parts: string[],
173	): Record<string, any> {
UNCOV 174	const formatter = new Intl.DateTimeFormat(locale, options);	×
UNCOV 175	const result: Record<string, any> = {	×
176	date,
177	full: formatter.format(date),
178	};
179
UNCOV 180	const getFormattedPart = (	×
181	formattedParts: Intl.DateTimeFormatPart[],
182	partType: string,
183	): IFormattedParts => {
UNCOV 184	const part = formattedParts.find(({ type }) => type === partType);	×
UNCOV 185	const nextPart = formattedParts[formattedParts.indexOf(part) + 1];	×
UNCOV 186	const value = part?.value \|\| "";	×
UNCOV 187	const literal = nextPart?.type === "literal" ? nextPart.value : "";	×
UNCOV 188	return {	×
189	value,
190	literal,
191	combined: value + literal,
192	};
193	};
194
UNCOV 195	if ("formatToParts" in formatter) {	×
UNCOV 196	const formattedParts = formatter.formatToParts(date);	×
UNCOV 197	parts.forEach(	×
UNCOV 198	(part) => (result[part] = getFormattedPart(formattedParts, part)),	×
199	);
200	} else {
201	parts.forEach(	×
202	(part) => (result[part] = { value: "", literal: "", combined: "" }),	×
203	);
204	}
205
UNCOV 206	return result;	×
207	}

IgniteUI / igniteui-angular / 13331632524

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous