311f48c5-7208-41f5-bcb8-eee40e52d891

Committed 13 Dec 2023 03:39AM UTC coverage: 90.336% (-0.06%) from 90.396%

Build # 311f48c5-7208-41f5-bcb8-eee40e52d891

Build Type

Pull #2967

circleci

Committed by

web-flow

Commit Message

Merge branch 'master' into cmq/feat-#INFR-10719

Pull Request Pull Request #2967: feat(datePicker): date-picker support quarter(#INFR-10719)

Run Details

5377 of 6616 branches covered (0.0%)

Branch coverage included in aggregate %.

70 of 83 new or added lines in 7 files covered. (84.34%)

15 existing lines in 4 files now uncovered.

13403 of 14173 relevant lines covered (94.57%)

968.54 hits per line

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

94.29

/src/util/date/tiny-date.ts

import {
    differenceInCalendarDays,
    differenceInCalendarMonths,
    differenceInCalendarYears,
    differenceInCalendarQuarters,
    differenceInWeeks,
    differenceInHours,
    differenceInMinutes,
    differenceInSeconds,
    isSameDay,
    isSameHour,
    isSameMinute,
    isSameMonth,
    isSameSecond,
    isSameYear,
    isSameQuarter,
    isToday,
    isTomorrow,
    isValid,
    setYear,
    startOfMonth,
    startOfWeek,
    addMonths,
    addYears,
    setDay,
    setMonth,
    setQuarter,
    getUnixTime,
    startOfDay,
    endOfDay,
    fromUnixTime,
    isWeekend,
    getWeek,
    getDaysInMonth,
    addSeconds,
    addMinutes,
    addHours,
    addWeeks,
    addQuarters,
    startOfQuarter,
    startOfYear,
    endOfWeek,
    endOfMonth,
    endOfQuarter,
    endOfYear,
    format,
    getQuarter,
    addDays
} from './functions';

import { Locale } from 'date-fns';

export type TinyDateCompareGrain = 'decade' | 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';

export type WeekDayIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6;

export type TinyDateType = TinyDate | Date | null;

export function sortRangeValue(rangeValue: TinyDate[]): TinyDate[] {
    if (Array.isArray(rangeValue)) {
        const [start, end] = rangeValue;
        return start && end && start.isAfterSecond(end) ? [end, start] : [start, end];
    }
    return rangeValue;
}

export class TinyDate implements Record<string, any> {
    nativeDate: Date;

    constructor(date?: Date | string | number) {
        if (date) {
            if (date instanceof Date) {
                this.nativeDate = date;
            } else if (typeof date === 'string' || typeof date === 'number') {
                this.nativeDate = new Date(date);
            } else if (typeof ngDevMode === 'undefined' || ngDevMode) {
                throw new Error(
                    `The input date type is not supported expect Date | string | number | { date: number; with_time: 0 | 1}, actual ${JSON.stringify(
                        date
                    )}`
                );
            }
        } else {
            this.nativeDate = new Date();
        }
    }

    static fromUnixTime(unixTime: number): TinyDate {
        return new TinyDate(fromUnixTime(unixTime));
    }

    // get
    getTime(): number {
        return this.nativeDate.getTime();
    }

    getDate(): number {
        return this.nativeDate.getDate();
    }

    getYear(): number {
        return this.nativeDate.getFullYear();
    }

    getQuarter(): number {
        return getQuarter(this.nativeDate);
    }

    getMonth(): number {
        return this.nativeDate.getMonth();
    }

    getWeek(options: { locale?: Locale; weekStartsOn?: WeekDayIndex } = { weekStartsOn: 1 }): number {
        return getWeek(this.nativeDate, options);
    }

    getDay(): number {
        return this.nativeDate.getDay();
    }

    getHours(): number {
        return this.nativeDate.getHours();
    }

    getMinutes(): number {
        return this.nativeDate.getMinutes();
    }

    getSeconds(): number {
        return this.nativeDate.getSeconds();
    }

    getMilliseconds(): number {
        return this.nativeDate.getMilliseconds();
    }

    getDaysInMonth() {
        return getDaysInMonth(this.nativeDate);
    }

    getDaysInQuarter() {
        return differenceInCalendarDays(this.endOfQuarter().addSeconds(1).nativeDate, this.startOfQuarter().nativeDate);
    }

    // set
    setDate(amount: number): TinyDate {
        const date = new Date(this.nativeDate);
        date.setDate(amount);
        return new TinyDate(date);
    }

    setHms(hour: number, minute: number, second: number): TinyDate {
        const date = new Date(this.nativeDate);
        date.setHours(hour, minute, second);
        return new TinyDate(date);
    }

    setYear(year: number): TinyDate {
        return new TinyDate(setYear(this.nativeDate, year));
    }

    setMonth(month: number): TinyDate {
        return new TinyDate(setMonth(this.nativeDate, month));
    }

    setQuarter(quarter: number) {
        return new TinyDate(setQuarter(this.nativeDate, quarter));
    }

    setDay(day: number, options?: { weekStartsOn: WeekDayIndex }): TinyDate {
        return new TinyDate(setDay(this.nativeDate, day, options));
    }

    // add
    addYears(amount: number): TinyDate {
        return new TinyDate(addYears(this.nativeDate, amount));
    }

    addQuarters(amount: number): TinyDate {
        return new TinyDate(addQuarters(this.nativeDate, amount));
    }

    addMonths(amount: number): TinyDate {
        return new TinyDate(addMonths(this.nativeDate, amount));
    }

    addWeeks(amount: number): TinyDate {
        return new TinyDate(addWeeks(this.nativeDate, amount));
    }

    addDays(amount: number): TinyDate {
        return new TinyDate(addDays(this.nativeDate, amount));
    }
    addHours(amount: number): TinyDate {
        return new TinyDate(addHours(this.nativeDate, amount));
    }

    addSeconds(amount: number): TinyDate {
        return new TinyDate(addSeconds(this.nativeDate, amount));
    }

    addMinutes(amount: number): TinyDate {
        return new TinyDate(addMinutes(this.nativeDate, amount));
    }

    // isSame

    isSame(date: TinyDateType, grain: TinyDateCompareGrain = 'day'): boolean {
        let fn;
        switch (grain) {
            case 'decade':
                fn = (pre: Date, next: Date) => Math.abs(pre.getFullYear() - next.getFullYear()) < 11;
                break;
            case 'year':
                fn = isSameYear;
                break;
            case 'month':
                fn = isSameMonth;
                break;
            case 'quarter':
                fn = isSameQuarter;
                break;
            case 'day':
                fn = isSameDay;
                break;
            case 'hour':
                fn = isSameHour;
                break;
            case 'minute':
                fn = isSameMinute;
                break;
            case 'second':
                fn = isSameSecond;
                break;
            default:
                fn = isSameDay;
                break;
        }
        return fn(this.nativeDate, this.toNativeDate(date));
    }

    isSameYear(date: TinyDateType): boolean {
        return this.isSame(date, 'year');
    }

    isSameMonth(date: TinyDateType): boolean {
        return this.isSame(date, 'month');
    }

    isSameQuarter(date: TinyDateType): boolean {
        return this.isSame(date, 'quarter');
    }

    isSameDay(date: TinyDateType): boolean {
        return this.isSame(date, 'day');
    }

    isSameHour(date: TinyDateType): boolean {
        return this.isSame(date, 'hour');
    }

    isSameMinute(date: TinyDateType): boolean {
        return this.isSame(date, 'minute');
    }

    isSameSecond(date: TinyDateType): boolean {
        return this.isSame(date, 'second');
    }

    // isBefore and isAfter
    isBeforeYear(date: TinyDateType): boolean {
        return this.compare(date, 'year');
    }

    isBeforeQuarter(date: TinyDate): boolean {
        return this.compare(date, 'quarter');
    }

    isBeforeMonth(date: TinyDateType): boolean {
        return this.compare(date, 'month');
    }

    isBeforeWeek(date: TinyDateType): boolean {
        return this.compare(date, 'week');
    }

    isBeforeDay(date: TinyDateType): boolean {
        return this.compare(date, 'day');
    }

    isBeforeHour(date: TinyDateType): boolean {
        return this.compare(date, 'hour');
    }

    isBeforeMinute(date: TinyDateType): boolean {
        return this.compare(date, 'minute');
    }

    isBeforeSecond(date: TinyDateType): boolean {
        return this.compare(date, 'second');
    }

    isAfterYear(date: TinyDateType): boolean {
        return this.compare(date, 'year', false);
    }

    isAfterQuarter(date: TinyDate): boolean {
        return this.compare(date, 'quarter', false);
    }

    isAfterMonth(date: TinyDateType): boolean {
        return this.compare(date, 'month', false);
    }

    isAfterWeek(date: TinyDateType): boolean {
        return this.compare(date, 'week', false);
    }

    isAfterDay(date: TinyDateType): boolean {
        return this.compare(date, 'day', false);
    }

    isAfterHour(date: TinyDateType): boolean {
        return this.compare(date, 'hour', false);
    }

    isAfterMinute(date: TinyDateType): boolean {
        return this.compare(date, 'minute', false);
    }

    isAfterSecond(date: TinyDateType): boolean {
        return this.compare(date, 'second', false);
    }

    // is
    isWeekend() {
        return isWeekend(this.nativeDate);
    }

    isToday(): boolean {
        return isToday(this.nativeDate);
    }

    isTomorrow(): boolean {
        return isTomorrow(this.nativeDate);
    }

    isValid(): boolean {
        return isValid(this.nativeDate);
    }

    // startOf and endOf
    startOfYear(): TinyDate {
        return new TinyDate(startOfYear(this.nativeDate));
    }

    startOfQuarter(): TinyDate {
        return new TinyDate(startOfQuarter(this.nativeDate));
    }

    startOfMonth(): TinyDate {
        return new TinyDate(startOfMonth(this.nativeDate));
    }

    startOfWeek(options?: { locale?: Locale; weekStartsOn?: WeekDayIndex }): TinyDate {
        return new TinyDate(startOfWeek(this.nativeDate, options));
    }

    startOfDay(): TinyDate {
        return new TinyDate(startOfDay(this.nativeDate));
    }

    endOfYear(): TinyDate {
        return new TinyDate(endOfYear(this.nativeDate));
    }

    endOfQuarter(): TinyDate {
        return new TinyDate(endOfQuarter(this.nativeDate));
    }

    endOfMonth(): TinyDate {
        return new TinyDate(endOfMonth(this.nativeDate));
    }

    endOfWeek(options?: { locale?: Locale; weekStartsOn?: WeekDayIndex }): TinyDate {
        return new TinyDate(endOfWeek(this.nativeDate, options));
    }

    endOfDay(): TinyDate {
        return new TinyDate(endOfDay(this.nativeDate));
    }

    // other
    format(
        mat: string,
        options?: {
            locale?: Locale;
            weekStartsOn?: WeekDayIndex;
            firstWeekContainsDate?: number;
            useAdditionalWeekYearTokens?: boolean;
            useAdditionalDayOfYearTokens?: boolean;
        }
    ) {
        return format(this.nativeDate, mat, options);
    }

    calendarStart(options?: { weekStartsOn: WeekDayIndex | undefined }): TinyDate {
        return new TinyDate(startOfWeek(startOfMonth(this.nativeDate), options));
    }

    clone(): TinyDate {
        return new TinyDate(new Date(this.nativeDate));
    }

    getUnixTime(): number {
        return getUnixTime(this.nativeDate);
    }

    compare(date: TinyDateType, grain: TinyDateCompareGrain = 'day', isBefore: boolean = true): boolean {
        if (date === null) {
            return false;
        }
        let fn;
        switch (grain) {
            case 'year':
                fn = differenceInCalendarYears;
                break;
            case 'quarter':
                fn = differenceInCalendarQuarters;
                break;
            case 'month':
                fn = differenceInCalendarMonths;
                break;
            case 'day':
                fn = differenceInCalendarDays;
                break;
            case 'week':
                fn = differenceInWeeks;
                break;
            case 'hour':
                fn = differenceInHours;
                break;
            case 'minute':
                fn = differenceInMinutes;
                break;
            case 'second':
                fn = differenceInSeconds;
                break;
            default:
                fn = differenceInCalendarDays;
                break;
        }
        return isBefore ? fn(this.nativeDate, this.toNativeDate(date)) < 0 : fn(this.nativeDate, this.toNativeDate(date)) > 0;
    }

    private toNativeDate(date: any): Date {
        return date instanceof TinyDate ? date.nativeDate : date;
    }
}

1	import {
2	differenceInCalendarDays,
3	differenceInCalendarMonths,	13✔
4	differenceInCalendarYears,	12✔
5	differenceInCalendarQuarters,	12✔
6	differenceInWeeks,
7	differenceInHours,	1✔
8	differenceInMinutes,
9	differenceInSeconds,
10	isSameDay,
11	isSameHour,	39,497✔
12	isSameMinute,	37,286✔
13	isSameMonth,	37,025✔
14	isSameSecond,
15	isSameYear,	261✔
16	isSameQuarter,	260✔
17	isToday,
18	isTomorrow,	1!
19	isValid,	1✔
20	setYear,
21	startOfMonth,
22	startOfWeek,
23	addMonths,	2,211✔
24	addYears,
25	setDay,
26	setMonth,
27	setQuarter,	1✔
28	getUnixTime,
29	startOfDay,
30	endOfDay,
31	fromUnixTime,	826✔
32	isWeekend,
33	getWeek,
34	getDaysInMonth,	20,630✔
35	addSeconds,
36	addMinutes,
37	addHours,	7,093✔
38	addWeeks,
39	addQuarters,
40	startOfQuarter,	339✔
41	startOfYear,
42	endOfWeek,
43	endOfMonth,	1,134✔
44	endOfQuarter,
45	endOfYear,	2✔
46	format,	2✔
47	getQuarter,
48	addDays
49	} from './functions';	3✔
50
51	import { Locale } from 'date-fns';
52		26✔
53	export type TinyDateCompareGrain = 'decade' \| 'year' \| 'quarter' \| 'month' \| 'week' \| 'day' \| 'hour' \| 'minute' \| 'second';
54
55	export type WeekDayIndex = 0 \| 1 \| 2 \| 3 \| 4 \| 5 \| 6;	26✔
56
57	export type TinyDateType = TinyDate \| Date \| null;
58		26✔
59	export function sortRangeValue(rangeValue: TinyDate[]): TinyDate[] {
60	if (Array.isArray(rangeValue)) {
61	const [start, end] = rangeValue;	1✔
62	return start && end && start.isAfterSecond(end) ? [end, start] : [start, end];
63	}
64	return rangeValue;	1✔
65	}
66
67	export class TinyDate implements Record<string, any> {	1✔
68	nativeDate: Date;
69
70	constructor(date?: Date \| string \| number) {
71	if (date) {	31✔
72	if (date instanceof Date) {	31✔
73	this.nativeDate = date;	31✔
74	} else if (typeof date === 'string' \|\| typeof date === 'number') {
75	this.nativeDate = new Date(date);
76	} else if (typeof ngDevMode === 'undefined' \|\| ngDevMode) {	103✔
77	throw new Error(	103✔
78	`The input date type is not supported expect Date \| string \| number \| { date: number; with_time: 0 \| 1}, actual ${JSON.stringify(	103✔
79	date
80	)}`
81	);	542✔
82	}
83	} else {
84	this.nativeDate = new Date();	1,238✔
85	}
86	}
87		120✔
88	static fromUnixTime(unixTime: number): TinyDate {
89	return new TinyDate(fromUnixTime(unixTime));
90	}	1✔
91
92	// get
93	getTime(): number {
94	return this.nativeDate.getTime();	388✔
95	}
96
97	getDate(): number {	438✔
98	return this.nativeDate.getDate();
99	}
100		624✔
101	getYear(): number {
102	return this.nativeDate.getFullYear();
103	}	1✔
104
105	getQuarter(): number {
106	return getQuarter(this.nativeDate);	26,732✔
107	}
108
109	getMonth(): number {	1✔
110	return this.nativeDate.getMonth();
111	}
112		2✔
113	getWeek(options: { locale?: Locale; weekStartsOn?: WeekDayIndex } = { weekStartsOn: 1 }): number {
114	return getWeek(this.nativeDate, options);
115	}	1✔
116
117	getDay(): number {
118	return this.nativeDate.getDay();	×
119	}
120		49,174!
121	getHours(): number {
122	return this.nativeDate.getHours();	×
UNCOV 123	}	×
124
125	getMinutes(): number {	617✔
126	return this.nativeDate.getMinutes();	617✔
127	}
128		1,353✔
129	getSeconds(): number {	1,353✔
130	return this.nativeDate.getSeconds();
131	}	318✔
132		318✔
133	getMilliseconds(): number {
134	return this.nativeDate.getMilliseconds();	46,879✔
135	}	46,879✔
136
137	getDaysInMonth() {	2✔
138	return getDaysInMonth(this.nativeDate);	2✔
139	}
140		2✔
141	getDaysInQuarter() {	2✔
142	return differenceInCalendarDays(this.endOfQuarter().addSeconds(1).nativeDate, this.startOfQuarter().nativeDate);
143	}	2✔
144		2✔
145	// set
146	setDate(amount: number): TinyDate {	1✔
147	const date = new Date(this.nativeDate);	1✔
148	date.setDate(amount);
149	return new TinyDate(date);	49,174✔
150	}
151
152	setHms(hour: number, minute: number, second: number): TinyDate {	607✔
153	const date = new Date(this.nativeDate);
154	date.setHours(hour, minute, second);
155	return new TinyDate(date);	1,313✔
156	}
157
158	setYear(year: number): TinyDate {	318✔
159	return new TinyDate(setYear(this.nativeDate, year));
160	}
161		46,878✔
162	setMonth(month: number): TinyDate {
163	return new TinyDate(setMonth(this.nativeDate, month));
164	}	1✔
165
166	setQuarter(quarter: number) {
167	return new TinyDate(setQuarter(this.nativeDate, quarter));	1✔
168	}
169
170	setDay(day: number, options?: { weekStartsOn: WeekDayIndex }): TinyDate {	1✔
171	return new TinyDate(setDay(this.nativeDate, day, options));
172	}
173
174	// add	30✔
175	addYears(amount: number): TinyDate {
176	return new TinyDate(addYears(this.nativeDate, amount));
177	}	26✔
178
179	addQuarters(amount: number): TinyDate {
180	return new TinyDate(addQuarters(this.nativeDate, amount));	20,557✔
181	}
182
183	addMonths(amount: number): TinyDate {	1✔
184	return new TinyDate(addMonths(this.nativeDate, amount));
185	}
186		5,623✔
187	addWeeks(amount: number): TinyDate {
188	return new TinyDate(addWeeks(this.nativeDate, amount));
189	}	1✔
190
191	addDays(amount: number): TinyDate {
192	return new TinyDate(addDays(this.nativeDate, amount));	1✔
193	}
194	addHours(amount: number): TinyDate {
195	return new TinyDate(addHours(this.nativeDate, amount));	1✔
196	}
197
198	addSeconds(amount: number): TinyDate {	2✔
199	return new TinyDate(addSeconds(this.nativeDate, amount));
200	}
UNCOV 201		×
202	addMinutes(amount: number): TinyDate {
203	return new TinyDate(addMinutes(this.nativeDate, amount));
204	}	20,413✔
205
206	// isSame
207		1✔
208	isSame(date: TinyDateType, grain: TinyDateCompareGrain = 'day'): boolean {
209	let fn;
210	switch (grain) {	3✔
211	case 'decade':
212	fn = (pre: Date, next: Date) => Math.abs(pre.getFullYear() - next.getFullYear()) < 11;
213	break;	1✔
214	case 'year':
215	fn = isSameYear;
216	break;	1✔
217	case 'month':
218	fn = isSameMonth;
219	break;	13✔
220	case 'quarter':
221	fn = isSameQuarter;
222	break;
223	case 'day':	2✔
224	fn = isSameDay;
225	break;
226	case 'hour':	40,826✔
227	fn = isSameHour;
228	break;
229	case 'minute':	2✔
230	fn = isSameMinute;
231	break;
232	case 'second':	2✔
233	fn = isSameSecond;
234	break;
235	default:
236	fn = isSameDay;	377✔
237	break;
238	}
239	return fn(this.nativeDate, this.toNativeDate(date));	201✔
240	}
241
242	isSameYear(date: TinyDateType): boolean {	236✔
243	return this.isSame(date, 'year');
244	}
245		34✔
246	isSameMonth(date: TinyDateType): boolean {
247	return this.isSame(date, 'month');
248	}	1,965✔
249
250	isSameQuarter(date: TinyDateType): boolean {
251	return this.isSame(date, 'quarter');	111✔
252	}
253
254	isSameDay(date: TinyDateType): boolean {	146✔
255	return this.isSame(date, 'day');
256	}
257		180✔
258	isSameHour(date: TinyDateType): boolean {
259	return this.isSame(date, 'hour');
260	}	35✔
261
262	isSameMinute(date: TinyDateType): boolean {
263	return this.isSame(date, 'minute');	1,638✔
264	}
265
266	isSameSecond(date: TinyDateType): boolean {
267	return this.isSame(date, 'second');	221✔
268	}
269
270	// isBefore and isAfter	973✔
271	isBeforeYear(date: TinyDateType): boolean {
272	return this.compare(date, 'year');
273	}	107✔
274
275	isBeforeQuarter(date: TinyDate): boolean {
276	return this.compare(date, 'quarter');	103✔
277	}
278		26,240!
279	isBeforeMonth(date: TinyDateType): boolean {	46,674✔
280	return this.compare(date, 'month');	2✔
281	}
282
283	isBeforeWeek(date: TinyDateType): boolean {	46,672!
284	return this.compare(date, 'week');
285	}	30✔
286		30✔
287	isBeforeDay(date: TinyDateType): boolean {
288	return this.compare(date, 'day');	26✔
289	}	26✔
290
291	isBeforeHour(date: TinyDateType): boolean {	40,970✔
292	return this.compare(date, 'hour');	40,970✔
293	}
294		5,626✔
295	isBeforeMinute(date: TinyDateType): boolean {	5,626✔
296	return this.compare(date, 'minute');
297	}	2✔
298		2✔
299	isBeforeSecond(date: TinyDateType): boolean {
300	return this.compare(date, 'second');	2✔
301	}	2✔
302
303	isAfterYear(date: TinyDateType): boolean {	2✔
304	return this.compare(date, 'year', false);	2✔
305	}
306		14✔
307	isAfterQuarter(date: TinyDate): boolean {	14✔
308	return this.compare(date, 'quarter', false);
NEW 309	}	×
NEW 310		×
311	isAfterMonth(date: TinyDateType): boolean {
312	return this.compare(date, 'month', false);	46,672✔
313	}
314
315	isAfterWeek(date: TinyDateType): boolean {	95,846✔
316	return this.compare(date, 'week', false);
317	}
318
319	isAfterDay(date: TinyDateType): boolean {
320	return this.compare(date, 'day', false);
321	}
322
323	isAfterHour(date: TinyDateType): boolean {
324	return this.compare(date, 'hour', false);
325	}
326
327	isAfterMinute(date: TinyDateType): boolean {
328	return this.compare(date, 'minute', false);
329	}
330
331	isAfterSecond(date: TinyDateType): boolean {
332	return this.compare(date, 'second', false);
333	}
334
335	// is
336	isWeekend() {
337	return isWeekend(this.nativeDate);
338	}
339
340	isToday(): boolean {
341	return isToday(this.nativeDate);
342	}
343
344	isTomorrow(): boolean {
345	return isTomorrow(this.nativeDate);
346	}
347
348	isValid(): boolean {
349	return isValid(this.nativeDate);
350	}
351
352	// startOf and endOf
353	startOfYear(): TinyDate {
354	return new TinyDate(startOfYear(this.nativeDate));
355	}
356
357	startOfQuarter(): TinyDate {
358	return new TinyDate(startOfQuarter(this.nativeDate));
359	}
360
361	startOfMonth(): TinyDate {
362	return new TinyDate(startOfMonth(this.nativeDate));
363	}
364
365	startOfWeek(options?: { locale?: Locale; weekStartsOn?: WeekDayIndex }): TinyDate {
366	return new TinyDate(startOfWeek(this.nativeDate, options));
367	}
368
369	startOfDay(): TinyDate {
370	return new TinyDate(startOfDay(this.nativeDate));
371	}
372
373	endOfYear(): TinyDate {
374	return new TinyDate(endOfYear(this.nativeDate));
375	}
376
377	endOfQuarter(): TinyDate {
378	return new TinyDate(endOfQuarter(this.nativeDate));
379	}
380
381	endOfMonth(): TinyDate {
382	return new TinyDate(endOfMonth(this.nativeDate));
383	}
384
385	endOfWeek(options?: { locale?: Locale; weekStartsOn?: WeekDayIndex }): TinyDate {
386	return new TinyDate(endOfWeek(this.nativeDate, options));
387	}
388
389	endOfDay(): TinyDate {
390	return new TinyDate(endOfDay(this.nativeDate));
391	}
392
393	// other
394	format(
395	mat: string,
396	options?: {
397	locale?: Locale;
398	weekStartsOn?: WeekDayIndex;
399	firstWeekContainsDate?: number;
400	useAdditionalWeekYearTokens?: boolean;
401	useAdditionalDayOfYearTokens?: boolean;
402	}
403	) {
404	return format(this.nativeDate, mat, options);
405	}
406
407	calendarStart(options?: { weekStartsOn: WeekDayIndex \| undefined }): TinyDate {
408	return new TinyDate(startOfWeek(startOfMonth(this.nativeDate), options));
409	}
410
411	clone(): TinyDate {
412	return new TinyDate(new Date(this.nativeDate));
413	}
414
415	getUnixTime(): number {
416	return getUnixTime(this.nativeDate);
417	}
418
419	compare(date: TinyDateType, grain: TinyDateCompareGrain = 'day', isBefore: boolean = true): boolean {
420	if (date === null) {
421	return false;
422	}
423	let fn;
424	switch (grain) {
425	case 'year':
426	fn = differenceInCalendarYears;
427	break;
428	case 'quarter':
429	fn = differenceInCalendarQuarters;
430	break;
431	case 'month':
432	fn = differenceInCalendarMonths;
433	break;
434	case 'day':
435	fn = differenceInCalendarDays;
436	break;
437	case 'week':
438	fn = differenceInWeeks;
439	break;
440	case 'hour':
441	fn = differenceInHours;
442	break;
443	case 'minute':
444	fn = differenceInMinutes;
445	break;
446	case 'second':
447	fn = differenceInSeconds;
448	break;
449	default:
450	fn = differenceInCalendarDays;
451	break;
452	}
453	return isBefore ? fn(this.nativeDate, this.toNativeDate(date)) < 0 : fn(this.nativeDate, this.toNativeDate(date)) > 0;
454	}
455
456	private toNativeDate(date: any): Date {
457	return date instanceof TinyDate ? date.nativeDate : date;
458	}
459	}

atinc / ngx-tethys / 311f48c5-7208-41f5-bcb8-eee40e52d891

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