cd64db52-e563-41a3-85f3-a0adb87ce135

Committed 30 Oct 2024 08:03AM UTC coverage: 90.402% (-0.04%) from 90.438%

Build # cd64db52-e563-41a3-85f3-a0adb87ce135

Build Type

push

circleci

Committed by

web-flow

Commit Message

refactor: refactor constructor to the inject function (#3222)

Run Details

5503 of 6730 branches covered (81.77%)

Branch coverage included in aggregate %.

422 of 429 new or added lines in 170 files covered. (98.37%)

344 existing lines in 81 files now uncovered.

13184 of 13941 relevant lines covered (94.57%)

997.19 hits per line

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

90.15

/src/date-picker/lib/date-carousel/date-carousel.component.ts

import { NgClass, NgTemplateOutlet } from '@angular/common';
import {
    ChangeDetectionStrategy,
    ChangeDetectorRef,
    Component,
    forwardRef,
    HostBinding,
    Input,
    OnDestroy,
    OnInit,
    inject
} from '@angular/core';
import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
import { ThyButton } from 'ngx-tethys/button';
import { ThyIcon } from 'ngx-tethys/icon';
import { TinyDate } from 'ngx-tethys/util';
import { Subject } from 'rxjs';
import { AdvancedSelectableCell, RangeAdvancedValue } from '../../inner-types';
import { DatePickerAdvancedShowYearTipPipe } from '../../picker.pipes';
import { ThyDateGranularity } from '../../standard-types';

/**
 * @private
 */
@Component({
    // eslint-disable-next-line @angular-eslint/component-selector
    selector: 'date-carousel',
    templateUrl: './date-carousel.component.html',
    changeDetection: ChangeDetectionStrategy.OnPush,
    providers: [
        {
            provide: NG_VALUE_ACCESSOR,
            multi: true,
            useExisting: forwardRef(() => DateCarousel)
        }
    ],
    standalone: true,
    imports: [NgTemplateOutlet, ThyButton, ThyIcon, NgClass, DatePickerAdvancedShowYearTipPipe]
})
export class DateCarousel implements OnInit, ControlValueAccessor, OnDestroy {
    private cdr = inject(ChangeDetectorRef);

    @HostBinding('class') className = 'thy-date-picker-advanced-carousel';

    @Input() activeDate: TinyDate;

    set defaultValue(value: RangeAdvancedValue) {
        this.dateGranularity = value.dateGranularity;
        this.buildSelectableData(value.begin);

        if (value.begin && value.end) {
            const shouldBeSelectValue = this.getShouldBeToggleValue(value.begin, value.end);
            this.select(...shouldBeSelectValue);
        } else {
            this.clearSelect(true);
        }
        this.initialized = true;
    }

    selectableData: { year?: AdvancedSelectableCell[]; quarter?: AdvancedSelectableCell[]; month?: AdvancedSelectableCell[] } = {};

    dateGranularity: ThyDateGranularity;

    selectedValue: AdvancedSelectableCell[] = [];

    private initialized = false;

    private selectedValueChange$ = new Subject<RangeAdvancedValue>();

    private _onChange: (value: RangeAdvancedValue) => void;

    private _onTouched: (value: RangeAdvancedValue) => void;

    ngOnInit(): void {
        this.selectedValueChange$.subscribe(() => {
            if (this.selectedValue.length) {
                this.buildSelectableData(this.selectedValue[0]?.startValue, this.dateGranularity);
            }
            this.selectableData.year.forEach(item => (item.classMap = this.getClassMap(item)));
            this.selectableData.quarter.forEach(item => (item.classMap = this.getClassMap(item)));
            this.selectableData.month.forEach(item => (item.classMap = this.getClassMap(item)));
            if (this.initialized) {
                if (this.isSelectEmpty()) {
                    this._onChange({
                        dateGranularity: null,
                        begin: null,
                        end: null
                    });
                } else {
                    const selctedValue = this.selectedValue;
                    this._onChange({
                        dateGranularity: this.dateGranularity,
                        begin: selctedValue[0]?.startValue,
                        end: selctedValue[selctedValue.length - 1]?.endValue
                    });
                }
            }
        });
    }

    writeValue(value: RangeAdvancedValue): void {
        if (value) {
            this.defaultValue = value;
        }
    }

    registerOnChange(fn: any): void {
        this._onChange = fn;
    }

    registerOnTouched(fn: any): void {
        this._onTouched = fn;
    }

    getClassMap(cell: AdvancedSelectableCell) {
        return {
            [`active`]: this.isSelected(cell),
            [`indeterminate`]: this.isCellIndeterminate(this.selectedValue, cell),
            [`type-active`]: this.isTypeActive(this.selectedValue, cell),
            ['in-hover-range']: cell.isInRange,
            ['out-range']: cell.isOutRange
        };
    }

    isTypeActive(originalValue: AdvancedSelectableCell[], value: AdvancedSelectableCell) {
        return originalValue?.length && originalValue[0].type === value.type;
    }

    isCellIndeterminate(originalValue: AdvancedSelectableCell[], value: AdvancedSelectableCell) {
        if (originalValue[0]?.type === value.type) {
            return false;
        } else {
            if (originalValue[0]?.type === 'year') {
                return !!originalValue.find(item => item.startValue.isSameYear(value.startValue));
            } else {
                return value.type === 'year'
                    ? !!originalValue.find(item => item.startValue.isSameYear(value.startValue))
                    : !!originalValue.find(item => item.startValue.isSameQuarter(value.startValue));
            }
        }
    }

    isSelected(value: AdvancedSelectableCell) {
        return this.selectedValue.find(item => item.startValue.isSameDay(value.startValue)) && this.dateGranularity === value.type;
    }

    isSelectEmpty() {
        return this.selectedValue.length == 0;
    }

    selectSort() {
        this.selectedValue.sort((a, b) => a.startValue.getTime() - b.startValue.getTime());
    }

    select(...value: AdvancedSelectableCell[]) {
        value.forEach(item => {
            if (!this.isSelected(item)) {
                this.selectedValue.push(...value);
            }
        });
        this.selectSort();
        this.selectedValueChange$.next(undefined);
    }

    deselect(...value: AdvancedSelectableCell[]) {
        value.forEach(item => {
            this.selectedValue = this.selectedValue.filter(selected => !selected.startValue.isSameDay(item.startValue));
        });
        this.selectSort();
        this.selectedValueChange$.next(undefined);
    }

    clearSelect(hidden?: boolean) {
        this.selectedValue = [];
        if (!hidden) {
            this.selectedValueChange$.next(undefined);
        }
    }

    getShouldBeToggleValue(begin: TinyDate, end: TinyDate) {
        let selectedValue: AdvancedSelectableCell[] = [];
        switch (this.dateGranularity) {
            case 'year':
                this.dateGranularity = 'year';
                if (begin.isSameYear(end)) {
                    selectedValue.push(this.getSelectableYear(begin));
                } else {
                    selectedValue.push(this.getSelectableYear(begin));
                    while (!begin.isSameYear(end)) {
                        begin = begin.addYears(1);
                        selectedValue.push(this.getSelectableYear(begin));
                    }
                }
                break;
            case 'month':
                this.dateGranularity = 'month';
                if (begin.isSameMonth(end)) {
                    selectedValue.push(this.getSelectableMonth(begin));
                } else {
                    selectedValue.push(this.getSelectableMonth(begin));
                    while (!begin.isSameMonth(end)) {
                        begin = begin.addMonths(1);
                        selectedValue.push(this.getSelectableMonth(begin));
                    }
                }
                break;
            case 'quarter':
                this.dateGranularity = 'quarter';
                if (begin.isSameQuarter(end)) {
                    selectedValue.push(this.getSelectableQuarter(begin));
                } else {
                    selectedValue.push(this.getSelectableQuarter(begin));
                    while (!begin.isSameQuarter(end)) {
                        begin = begin.addQuarters(1);
                        selectedValue.push(this.getSelectableQuarter(begin));
                    }
                }
        }
        return selectedValue;
    }

    buildSelectableData(startDate: TinyDate, excludeGranularity?: ThyDateGranularity) {
        const buildGranularity = ['year', 'month', 'quarter'].filter(item => item !== excludeGranularity);
        buildGranularity.forEach(granularity => {
            switch (granularity) {
                case 'year':
                    this.selectableData.year = [...Array(3).keys()].map((item, index) => {
                        return this.getSelectableYear(startDate, index);
                    });
                    break;
                case 'quarter':
                    this.selectableData.quarter = [...Array(4).keys()].map((item, index) => {
                        return this.getSelectableQuarter(startDate, index);
                    });
                    break;
                case 'month':
                    this.selectableData.month = [...Array(4).keys()].map((item, index) => {
                        return this.getSelectableMonth(startDate, index);
                    });
                    break;
            }
        });
        this.cdr.markForCheck();
    }

    getSelectableYear(currentDate: TinyDate, preOrNextcount: number = 0): AdvancedSelectableCell {
        currentDate = currentDate || this.activeDate || new TinyDate().startOfYear();
        return {
            type: 'year',
            content: `${currentDate.addYears(preOrNextcount).getYear()}`,
            startValue: currentDate.startOfYear().addYears(preOrNextcount),
            endValue: currentDate.endOfYear().addYears(preOrNextcount),
            classMap: {}
        };
    }

    getSelectableQuarter(currentDate: TinyDate, preOrNextcount: number = 0): AdvancedSelectableCell {
        currentDate = currentDate || this.activeDate || new TinyDate().startOfQuarter();
        return {
            type: 'quarter',
            content: `Q${currentDate.addQuarters(preOrNextcount).getQuarter()}`,
            startValue: currentDate.startOfQuarter().addQuarters(preOrNextcount),
            endValue: currentDate.endOfQuarter().addQuarters(preOrNextcount),
            classMap: {}
        };
    }

    getSelectableMonth(currentDate: TinyDate, preOrNextcount: number = 0): AdvancedSelectableCell {
        currentDate = currentDate || this.activeDate || new TinyDate().startOfMonth();
        const cell: AdvancedSelectableCell = {
            type: 'month',
            content: `${currentDate.addMonths(preOrNextcount).getMonth() + 1}月`,
            startValue: currentDate.startOfMonth().addMonths(preOrNextcount),
            endValue: currentDate.endOfMonth().addMonths(preOrNextcount),
            classMap: {}
        };
        return cell;
    }

    prevClick(type: ThyDateGranularity) {
        switch (type) {
            case 'year':
                this.selectableData.year = this.selectableData.year.map(item => this.getSelectableYear(item.startValue, -1));
                break;
            case 'quarter':
                this.selectableData.quarter = this.selectableData.quarter.map(item => this.getSelectableQuarter(item.startValue, -2));
                break;
            case 'month':
                this.selectableData.month = this.selectableData.month.map(item => this.getSelectableMonth(item.startValue, -2));
        }
        this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
    }

    nextClick(type: ThyDateGranularity) {
        switch (type) {
            case 'year':
                this.selectableData.year = this.selectableData.year.map(item => this.getSelectableYear(item.startValue, 1));
                break;
            case 'quarter':
                this.selectableData.quarter = this.selectableData.quarter.map(item => this.getSelectableQuarter(item.startValue, 2));
                break;
            case 'month':
                this.selectableData.month = this.selectableData.month.map(item => this.getSelectableMonth(item.startValue, 2));
        }
        this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
    }

    selectDate(type: ThyDateGranularity, value: AdvancedSelectableCell) {
        this.selectableData[type].forEach(item => {
            item.isInRange = false;
            item.isOutRange = false;
        });

        if (this.isSelectEmpty()) {
            this.dateGranularity = type;
            this.select(value);
            // this.selectedValueChange$.next();
            return;
        }
        if (this.isSelected(value)) {
            this.toggleSelect(value);
            if (this.isSelectEmpty()) {
                this.dateGranularity = null;
            }
            return;
        }

        if (this.dateGranularity === value.type) {
            const { rangeStart, rangeEnd } = this.getActualStartAndEnd(value);
            const shouldBeSelectValue = this.getShouldBeToggleValue(rangeStart, rangeEnd);
            this.select(...shouldBeSelectValue);
            // this.selectedValueChange$.next();
        } else {
            this.dateGranularity = type;
            this.clearSelect(true);
            this.select(value);
            // this.selectedValueChange$.next();
        }
    }
    toggleSelect(value: AdvancedSelectableCell) {
        if (value.startValue.isSameDay(this.selectedValue[0].startValue)) {
            // only deselect first one
            this.deselect(value);
        } else {
            // deselect current and all after current
            const rangeStart = value.startValue;
            const rangeEnd = this.selectedValue[this.selectedValue.length - 1].endValue;
            const shouldBeDeselectValue = this.getShouldBeToggleValue(rangeStart, rangeEnd);
            this.deselect(...shouldBeDeselectValue);
        }
    }

    onMouseenter(event: Event, type: ThyDateGranularity, value: AdvancedSelectableCell) {
        if (this.isSelectEmpty() || this.dateGranularity !== type) {
            return;
        }
        if (this.isSelected(value)) {
            value.isInRange = true;
            if (value.startValue.isSameDay(this.selectedValue[0].startValue)) {
                value.isOutRange = true;
            } else {
                const rangeStart = value.startValue;
                const rangeEnd = this.selectedValue[this.selectedValue.length - 1].endValue;
                this.selectableData[type].forEach((item: AdvancedSelectableCell) => {
                    if (item.startValue.getTime() >= rangeStart.getTime() && item.startValue.getTime() < rangeEnd.getTime()) {
                        item.isOutRange = true;
                    } else {
                        item.isOutRange = false;
                    }
                });
            }
        } else {
            const { rangeStart, rangeEnd } = this.getActualStartAndEnd(value);
            this.selectableData[type].forEach((item: AdvancedSelectableCell) => {
                if (item.startValue.getTime() >= rangeStart.getTime() && item.startValue.getTime() < rangeEnd.getTime()) {
                    item.isInRange = true;
                } else {
                    item.isInRange = false;
                }
            });
        }
        this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
    }

    onMouseleave(event: Event, type: ThyDateGranularity, value: AdvancedSelectableCell) {
        if (value.isInRange) {
            this.selectableData[type].forEach(item => (item.isInRange = false));
        }
        if (value.isOutRange) {
            this.selectableData[type].forEach(item => (item.isOutRange = false));
        }
        this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
    }

    getActualStartAndEnd(value: AdvancedSelectableCell) {
        const selectedStart = this.selectedValue[0].startValue;
        const selectedEnd = this.selectedValue[this.selectedValue.length - 1].endValue;
        let rangeStart: TinyDate, rangeEnd: TinyDate;
        if (value.startValue.isBeforeDay(selectedStart)) {
            rangeStart = value.startValue;
            rangeEnd = selectedStart;
        }
        if (value.startValue.isAfterDay(selectedEnd)) {
            rangeStart = selectedEnd;
            rangeEnd = value.endValue;
        }
        return { rangeStart, rangeEnd };
    }

    ngOnDestroy(): void {
        this.selectedValueChange$.complete();
    }
}

1	import { NgClass, NgTemplateOutlet } from '@angular/common';
2	import {
3	ChangeDetectionStrategy,
4	ChangeDetectorRef,
5	Component,
6	forwardRef,
7	HostBinding,
8	Input,
9	OnDestroy,
10	OnInit,
11	inject
12	} from '@angular/core';
13	import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
14	import { ThyButton } from 'ngx-tethys/button';	1✔
15	import { ThyIcon } from 'ngx-tethys/icon';
16	import { TinyDate } from 'ngx-tethys/util';	17✔
17	import { Subject } from 'rxjs';	17✔
18	import { AdvancedSelectableCell, RangeAdvancedValue } from '../../inner-types';	17✔
19	import { DatePickerAdvancedShowYearTipPipe } from '../../picker.pipes';	17✔
20	import { ThyDateGranularity } from '../../standard-types';	17✔
21		17✔
22	/**
23	* @private
24	*/	24✔
25	@Component({	24✔
26	// eslint-disable-next-line @angular-eslint/component-selector	24✔
27	selector: 'date-carousel',	6✔
28	templateUrl: './date-carousel.component.html',	6✔
29	changeDetection: ChangeDetectionStrategy.OnPush,
30	providers: [
31	{	18✔
32	provide: NG_VALUE_ACCESSOR,
33	multi: true,	24✔
34	useExisting: forwardRef(() => DateCarousel)
35	}
36	],	17✔
37	standalone: true,	14✔
38	imports: [NgTemplateOutlet, ThyButton, ThyIcon, NgClass, DatePickerAdvancedShowYearTipPipe]	13✔
39	})
40	export class DateCarousel implements OnInit, ControlValueAccessor, OnDestroy {	42✔
41	private cdr = inject(ChangeDetectorRef);	56✔
42		56✔
43	@HostBinding('class') className = 'thy-date-picker-advanced-carousel';	14✔
44		11✔
45	@Input() activeDate: TinyDate;	1✔
46
47	set defaultValue(value: RangeAdvancedValue) {
48	this.dateGranularity = value.dateGranularity;
49	this.buildSelectableData(value.begin);
50
51	if (value.begin && value.end) {
52	const shouldBeSelectValue = this.getShouldBeToggleValue(value.begin, value.end);	10✔
53	this.select(...shouldBeSelectValue);	10✔
54	} else {
55	this.clearSelect(true);
56	}
57	this.initialized = true;
58	}
59
60	selectableData: { year?: AdvancedSelectableCell[]; quarter?: AdvancedSelectableCell[]; month?: AdvancedSelectableCell[] } = {};
61
62	dateGranularity: ThyDateGranularity;
63		41✔
64	selectedValue: AdvancedSelectableCell[] = [];	24✔
65
66	private initialized = false;
67
68	private selectedValueChange$ = new Subject<RangeAdvancedValue>();	17✔
69
70	private _onChange: (value: RangeAdvancedValue) => void;
71		17✔
72	private _onTouched: (value: RangeAdvancedValue) => void;
73
74	ngOnInit(): void {	192✔
75	this.selectedValueChange$.subscribe(() => {
76	if (this.selectedValue.length) {
77	this.buildSelectableData(this.selectedValue[0]?.startValue, this.dateGranularity);
78	}
79	this.selectableData.year.forEach(item => (item.classMap = this.getClassMap(item)));
80	this.selectableData.quarter.forEach(item => (item.classMap = this.getClassMap(item)));
81	this.selectableData.month.forEach(item => (item.classMap = this.getClassMap(item)));
82	if (this.initialized) {
83	if (this.isSelectEmpty()) {	192✔
84	this._onChange({
85	dateGranularity: null,
86	begin: null,	192✔
87	end: null	56✔
88	});
89	} else {
90	const selctedValue = this.selectedValue;	136✔
91	this._onChange({	32✔
92	dateGranularity: this.dateGranularity,
93	begin: selctedValue[0]?.startValue,
94	end: selctedValue[selctedValue.length - 1]?.endValue	104✔
95	});	41✔
96	}	65✔
97	}
98	});
99	}
100
101	writeValue(value: RangeAdvancedValue): void {	299✔
102	if (value) {
103	this.defaultValue = value;
104	}	22✔
105	}
106
107	registerOnChange(fn: any): void {	14✔
108	this._onChange = fn;
109	}
110		13✔
111	registerOnTouched(fn: any): void {	19✔
112	this._onTouched = fn;	13✔
113	}
114
115	getClassMap(cell: AdvancedSelectableCell) {	13✔
116	return {	13✔
117	[`active`]: this.isSelected(cell),
118	[`indeterminate`]: this.isCellIndeterminate(this.selectedValue, cell),
119	[`type-active`]: this.isTypeActive(this.selectedValue, cell),	1✔
120	['in-hover-range']: cell.isInRange,	1✔
121	['out-range']: cell.isOutRange
122	};	1✔
123	}	1✔
124
125	isTypeActive(originalValue: AdvancedSelectableCell[], value: AdvancedSelectableCell) {
126	return originalValue?.length && originalValue[0].type === value.type;	20✔
127	}	20!
UNCOV 128		×
129	isCellIndeterminate(originalValue: AdvancedSelectableCell[], value: AdvancedSelectableCell) {
130	if (originalValue[0]?.type === value.type) {
131	return false;
132	} else {	7✔
133	if (originalValue[0]?.type === 'year') {	7✔
134	return !!originalValue.find(item => item.startValue.isSameYear(value.startValue));
135	} else {	1✔
136	return value.type === 'year'	1!
UNCOV 137	? !!originalValue.find(item => item.startValue.isSameYear(value.startValue))	×
138	: !!originalValue.find(item => item.startValue.isSameQuarter(value.startValue));
139	}
140	}	1✔
141	}	1✔
142		1✔
143	isSelected(value: AdvancedSelectableCell) {	1✔
144	return this.selectedValue.find(item => item.startValue.isSameDay(value.startValue)) && this.dateGranularity === value.type;
145	}
146		1✔
147	isSelectEmpty() {
148	return this.selectedValue.length == 0;	3✔
149	}	3!
UNCOV 150		×
151	selectSort() {
152	this.selectedValue.sort((a, b) => a.startValue.getTime() - b.startValue.getTime());
153	}	3✔
154		3✔
155	select(...value: AdvancedSelectableCell[]) {	5✔
156	value.forEach(item => {	5✔
157	if (!this.isSelected(item)) {
158	this.selectedValue.push(...value);
159	}	3✔
160	});
161	this.selectSort();	3✔
162	this.selectedValueChange$.next(undefined);	3!
163	}	3✔
164
165	deselect(...value: AdvancedSelectableCell[]) {
UNCOV 166	value.forEach(item => {	×
UNCOV 167	this.selectedValue = this.selectedValue.filter(selected => !selected.startValue.isSameDay(item.startValue));	×
UNCOV 168	});	×
UNCOV 169	this.selectSort();	×
170	this.selectedValueChange$.next(undefined);
171	}
172
173	clearSelect(hidden?: boolean) {	7✔
174	this.selectedValue = [];
175	if (!hidden) {
176	this.selectedValueChange$.next(undefined);	111✔
177	}	37✔
178	}	98✔
179
180	getShouldBeToggleValue(begin: TinyDate, end: TinyDate) {	33✔
181	let selectedValue: AdvancedSelectableCell[] = [];	99✔
182	switch (this.dateGranularity) {
183	case 'year':	33✔
184	this.dateGranularity = 'year';
185	if (begin.isSameYear(end)) {	33✔
186	selectedValue.push(this.getSelectableYear(begin));	132✔
187	} else {
188	selectedValue.push(this.getSelectableYear(begin));	33✔
189	while (!begin.isSameYear(end)) {
190	begin = begin.addYears(1);	32✔
191	selectedValue.push(this.getSelectableYear(begin));	128✔
192	}
193	}	32✔
194	break;
195	case 'month':
196	this.dateGranularity = 'month';	37✔
197	if (begin.isSameMonth(end)) {
198	selectedValue.push(this.getSelectableMonth(begin));	2✔
199	} else {	107✔
200	selectedValue.push(this.getSelectableMonth(begin));	107✔
201	while (!begin.isSameMonth(end)) {
202	begin = begin.addMonths(1);
203	selectedValue.push(this.getSelectableMonth(begin));
204	}
205	}
206	break;
207	case 'quarter':
208	this.dateGranularity = 'quarter';	3✔
209	if (begin.isSameQuarter(end)) {	143✔
210	selectedValue.push(this.getSelectableQuarter(begin));	143✔
211	} else {
212	selectedValue.push(this.getSelectableQuarter(begin));
213	while (!begin.isSameQuarter(end)) {
214	begin = begin.addQuarters(1);
215	selectedValue.push(this.getSelectableQuarter(begin));
216	}
217	}
218	}	8✔
219	return selectedValue;	144✔
220	}	144✔
221
222	buildSelectableData(startDate: TinyDate, excludeGranularity?: ThyDateGranularity) {
223	const buildGranularity = ['year', 'month', 'quarter'].filter(item => item !== excludeGranularity);
224	buildGranularity.forEach(granularity => {
225	switch (granularity) {
226	case 'year':
227	this.selectableData.year = [...Array(3).keys()].map((item, index) => {	144✔
228	return this.getSelectableYear(startDate, index);
229	});
230	break;	3✔
231	case 'quarter':
232	this.selectableData.quarter = [...Array(4).keys()].map((item, index) => {	3✔
233	return this.getSelectableQuarter(startDate, index);	1✔
234	});
235	break;	4✔
236	case 'month':	1✔
237	this.selectableData.month = [...Array(4).keys()].map((item, index) => {
238	return this.getSelectableMonth(startDate, index);	4✔
239	});
240	break;	11✔
241	}
242	});
243	this.cdr.markForCheck();	3✔
244	}
245		3✔
246	getSelectableYear(currentDate: TinyDate, preOrNextcount: number = 0): AdvancedSelectableCell {	1✔
247	currentDate = currentDate \|\| this.activeDate \|\| new TinyDate().startOfYear();
248	return {	4✔
249	type: 'year',	1✔
250	content: `${currentDate.addYears(preOrNextcount).getYear()}`,
251	startValue: currentDate.startOfYear().addYears(preOrNextcount),	4✔
252	endValue: currentDate.endOfYear().addYears(preOrNextcount),
253	classMap: {}	11✔
254	};
255	}
256		8✔
257	getSelectableQuarter(currentDate: TinyDate, preOrNextcount: number = 0): AdvancedSelectableCell {	28✔
258	currentDate = currentDate \|\| this.activeDate \|\| new TinyDate().startOfQuarter();	28✔
259	return {
260	type: 'quarter',	8✔
261	content: `Q${currentDate.addQuarters(preOrNextcount).getQuarter()}`,	4✔
262	startValue: currentDate.startOfQuarter().addQuarters(preOrNextcount),	4✔
263	endValue: currentDate.endOfQuarter().addQuarters(preOrNextcount),
264	classMap: {}	4✔
265	};
266	}	4✔
267		1✔
268	getSelectableMonth(currentDate: TinyDate, preOrNextcount: number = 0): AdvancedSelectableCell {	1!
269	currentDate = currentDate \|\| this.activeDate \|\| new TinyDate().startOfMonth();	1✔
270	const cell: AdvancedSelectableCell = {
271	type: 'month',	1✔
272	content: `${currentDate.addMonths(preOrNextcount).getMonth() + 1}月`,
273	startValue: currentDate.startOfMonth().addMonths(preOrNextcount),	3✔
274	endValue: currentDate.endOfMonth().addMonths(preOrNextcount),	1✔
275	classMap: {}	1✔
276	};	1✔
277	return cell;
278	}
279
280	prevClick(type: ThyDateGranularity) {	2✔
281	switch (type) {	2✔
282	case 'year':	2✔
283	this.selectableData.year = this.selectableData.year.map(item => this.getSelectableYear(item.startValue, -1));
284	break;
285	case 'quarter':
286	this.selectableData.quarter = this.selectableData.quarter.map(item => this.getSelectableQuarter(item.startValue, -2));
287	break;	1!
288	case 'month':
289	this.selectableData.month = this.selectableData.month.map(item => this.getSelectableMonth(item.startValue, -2));	1✔
290	}
291	this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
292	}
UNCOV 293		×
UNCOV 294	nextClick(type: ThyDateGranularity) {	×
UNCOV 295	switch (type) {	×
UNCOV 296	case 'year':	×
297	this.selectableData.year = this.selectableData.year.map(item => this.getSelectableYear(item.startValue, 1));
298	break;
299	case 'quarter':
300	this.selectableData.quarter = this.selectableData.quarter.map(item => this.getSelectableQuarter(item.startValue, 2));	2!
UNCOV 301	break;	×
302	case 'month':
303	this.selectableData.month = this.selectableData.month.map(item => this.getSelectableMonth(item.startValue, 2));	2✔
304	}	1✔
305	this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));	1!
306	}	×
307
308	selectDate(type: ThyDateGranularity, value: AdvancedSelectableCell) {
309	this.selectableData[type].forEach(item => {	1✔
310	item.isInRange = false;	1✔
311	item.isOutRange = false;	1✔
312	});	4✔
313		2✔
314	if (this.isSelectEmpty()) {
315	this.dateGranularity = type;
316	this.select(value);	2✔
317	// this.selectedValueChange$.next();
318	return;
319	}
320	if (this.isSelected(value)) {
321	this.toggleSelect(value);
322	if (this.isSelectEmpty()) {	1✔
323	this.dateGranularity = null;	1✔
324	}	4✔
325	return;	1✔
326	}
327
328	if (this.dateGranularity === value.type) {	3✔
329	const { rangeStart, rangeEnd } = this.getActualStartAndEnd(value);
330	const shouldBeSelectValue = this.getShouldBeToggleValue(rangeStart, rangeEnd);
331	this.select(...shouldBeSelectValue);
332	// this.selectedValueChange$.next();	8✔
333	} else {
334	this.dateGranularity = type;
335	this.clearSelect(true);	2!
336	this.select(value);	8✔
337	// this.selectedValueChange$.next();
338	}	2✔
339	}	4✔
340	toggleSelect(value: AdvancedSelectableCell) {
341	if (value.startValue.isSameDay(this.selectedValue[0].startValue)) {	8✔
342	// only deselect first one
343	this.deselect(value);
344	} else {	2✔
345	// deselect current and all after current	2✔
346	const rangeStart = value.startValue;
347	const rangeEnd = this.selectedValue[this.selectedValue.length - 1].endValue;	2!
UNCOV 348	const shouldBeDeselectValue = this.getShouldBeToggleValue(rangeStart, rangeEnd);	×
UNCOV 349	this.deselect(...shouldBeDeselectValue);	×
350	}
351	}	2!
352		2✔
353	onMouseenter(event: Event, type: ThyDateGranularity, value: AdvancedSelectableCell) {	2✔
354	if (this.isSelectEmpty() \|\| this.dateGranularity !== type) {
355	return;	2✔
356	}
357	if (this.isSelected(value)) {
358	value.isInRange = true;	17✔
359	if (value.startValue.isSameDay(this.selectedValue[0].startValue)) {
360	value.isOutRange = true;	1✔
361	} else {
362	const rangeStart = value.startValue;
363	const rangeEnd = this.selectedValue[this.selectedValue.length - 1].endValue;
364	this.selectableData[type].forEach((item: AdvancedSelectableCell) => {
365	if (item.startValue.getTime() >= rangeStart.getTime() && item.startValue.getTime() < rangeEnd.getTime()) {	1✔
366	item.isOutRange = true;
367	} else {
368	item.isOutRange = false;
369	}
370	});
371	}
372	} else {
373	const { rangeStart, rangeEnd } = this.getActualStartAndEnd(value);
374	this.selectableData[type].forEach((item: AdvancedSelectableCell) => {
375	if (item.startValue.getTime() >= rangeStart.getTime() && item.startValue.getTime() < rangeEnd.getTime()) {	17✔
376	item.isInRange = true;
377	} else {
378	item.isInRange = false;
379	}
380	});
381	}
382	this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
383	}
384
385	onMouseleave(event: Event, type: ThyDateGranularity, value: AdvancedSelectableCell) {
386	if (value.isInRange) {
387	this.selectableData[type].forEach(item => (item.isInRange = false));
388	}
389	if (value.isOutRange) {
390	this.selectableData[type].forEach(item => (item.isOutRange = false));
391	}
392	this.selectableData[type].forEach(item => (item.classMap = this.getClassMap(item)));
393	}
394
395	getActualStartAndEnd(value: AdvancedSelectableCell) {
396	const selectedStart = this.selectedValue[0].startValue;
397	const selectedEnd = this.selectedValue[this.selectedValue.length - 1].endValue;
398	let rangeStart: TinyDate, rangeEnd: TinyDate;
399	if (value.startValue.isBeforeDay(selectedStart)) {
400	rangeStart = value.startValue;
401	rangeEnd = selectedStart;
402	}
403	if (value.startValue.isAfterDay(selectedEnd)) {
404	rangeStart = selectedEnd;
405	rangeEnd = value.endValue;
406	}
407	return { rangeStart, rangeEnd };
408	}
409
410	ngOnDestroy(): void {
411	this.selectedValueChange$.complete();
412	}
413	}

atinc / ngx-tethys / cd64db52-e563-41a3-85f3-a0adb87ce135

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