978118701

Build Type

github

Committed by GitHub

Commit Message

Merge 07dda40c1 into c7bcbb79b

Pull Request Pull Request #384: Fix errors on ValueTypes that are not stringified nicely

Run Details

4630 of 4972 branches covered (93.12%)

Branch coverage included in aggregate %.

20 of 24 new or added lines in 10 files covered. (83.33%)

4 existing lines in 2 files now uncovered.

9272 of 9497 relevant lines covered (97.63%)

5738115.24 hits per line

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

98.1

/src/expressions/dataTypes/valueTypes/DateTime.ts

import { ValueType, valueTypeToString } from '../Value';
import AbstractDuration from './AbstractDuration';
import DayTimeDuration from './DayTimeDuration';

function parseMatch(match: string | undefined): number | null {
        return match ? parseInt(match, 10) : null;
}

function convertYearToString(year: number): string {
        let yearString = year + '';
        const isNegative = yearString.startsWith('-');
        if (isNegative) {
                yearString = yearString.substring(1);
        }
        return (isNegative ? '-' : '') + yearString.padStart(4, '0');
}

function convertToTwoCharString(value: number): string {
        const valueString = value + '';
        return valueString.padStart(2, '0');
}

function convertSecondsToString(seconds: number): string {
        let secondsString = seconds + '';
        if (secondsString.split('.')[0].length === 1) {
                secondsString = secondsString.padStart(secondsString.length + 1, '0');
        }
        return secondsString;
}

function isUTC(timezone: DayTimeDuration): boolean {
        return timezone.getHours() === 0 && timezone.getMinutes() === 0;
}

function timezoneToString(timezone: DayTimeDuration): string {
        if (isUTC(timezone)) {
                return 'Z';
        }

        return (
                (timezone.isPositive() ? '+' : '-') +
                convertToTwoCharString(Math.abs(timezone.getHours())) +
                ':' +
                convertToTwoCharString(Math.abs(timezone.getMinutes()))
        );
}

class DateTime {
        public static fromString: (str: any) => DateTime;
        public secondFraction: number;
        public type: ValueType;
        protected _days: number;
        protected _hours: number;
        protected _minutes: number;
        protected _months: number;
        protected _seconds: number;
        protected _timezone: DayTimeDuration;
        protected _years: number;
        constructor(
                years: number,
                months: number,
                days: number,
                hours: number,
                minutes: number,
                seconds: number,
                secondFraction: number,
                timezone: DayTimeDuration,
                type: ValueType = ValueType.XSDATETIME
        ) {
                this._years = years;
                this._months = months;
                this._days = days + (hours === 24 ? 1 : 0);
                this._hours = hours === 24 ? 0 : hours;
                this._minutes = minutes;
                this._seconds = seconds;
                this.secondFraction = secondFraction;
                this._timezone = timezone;

                this.type = type;
        }

        public convertToType(type: ValueType) {
                // xs:date       xxxx-xx-xxT00:00:00
                // xs:time       1972-12-31Txx:xx:xx
                // xs:gYearMonth xxxx-xx-01T00:00:00
                // xs:gYear      xxxx-01-01T00:00:00
                // xs:gMonthDay  1972-xx-xxT00:00:00
                // xs:gMonth     1972-xx-01T00:00:00
                // xs:gDay       1972-12-xxT00:00:00

                switch (type) {
                        case ValueType.XSGDAY:
                                return new DateTime(
                                        1972,
                                        12,
                                        this._days,
                                        0,
                                        0,
                                        0,
                                        0,
                                        this._timezone,
                                        ValueType.XSGDAY
                                );
                        case ValueType.XSGMONTH:
                                return new DateTime(
                                        1972,
                                        this._months,
                                        1,
                                        0,
                                        0,
                                        0,
                                        0,
                                        this._timezone,
                                        ValueType.XSGMONTH
                                );
                        case ValueType.XSGYEAR:
                                return new DateTime(
                                        this._years,
                                        1,
                                        1,
                                        0,
                                        0,
                                        0,
                                        0,
                                        this._timezone,
                                        ValueType.XSGYEAR
                                );
                        case ValueType.XSGMONTHDAY:
                                return new DateTime(
                                        1972,
                                        this._months,
                                        this._days,
                                        0,
                                        0,
                                        0,
                                        0,
                                        this._timezone,
                                        ValueType.XSGMONTHDAY
                                );
                        case ValueType.XSGYEARMONTH:
                                return new DateTime(
                                        this._years,
                                        this._months,
                                        1,
                                        0,
                                        0,
                                        0,
                                        0,
                                        this._timezone,
                                        ValueType.XSGYEARMONTH
                                );
                        case ValueType.XSTIME:
                                return new DateTime(
                                        1972,
                                        12,
                                        31,
                                        this._hours,
                                        this._minutes,
                                        this._seconds,
                                        this.secondFraction,
                                        this._timezone,
                                        ValueType.XSTIME
                                );
                        case ValueType.XSDATE:
                                return new DateTime(
                                        this._years,
                                        this._months,
                                        this._days,
                                        0,
                                        0,
                                        0,
                                        0,
                                        this._timezone,
                                        ValueType.XSDATE
                                );
                        case ValueType.XSDATETIME:
                        default:
                                return new DateTime(
                                        this._years,
                                        this._months,
                                        this._days,
                                        this._hours,
                                        this._minutes,
                                        this._seconds,
                                        this.secondFraction,
                                        this._timezone,
                                        ValueType.XSDATETIME
                                );
                }
        }

        public getDay() {
                return this._days;
        }

        public getFullSeconds() {
                return this._seconds + this.secondFraction;
        }

        public getHours() {
                return this._hours;
        }

        public getMinutes() {
                return this._minutes;
        }

        public getMonth() {
                return this._months;
        }

        public getSecondFraction() {
                return this.secondFraction;
        }

        public getSeconds() {
                return this._seconds;
        }

        public getTimezone() {
                return this._timezone;
        }

        public getYear() {
                return this._years;
        }

        public isPositive() {
                return this._years >= 0;
        }

        public toJavaScriptDate(implicitTimezone?: DayTimeDuration): Date {
                const timezoneToUse =
                        this._timezone || implicitTimezone || DayTimeDuration.fromTimezoneString('Z');
                return new Date(
                        Date.UTC(
                                this._years,
                                this._months - 1,
                                this._days,
                                this._hours - timezoneToUse.getHours(),
                                this._minutes - timezoneToUse.getMinutes(),
                                this._seconds + this.secondFraction
                        )
                );
        }

        public toString() {
                switch (this.type) {
                        case ValueType.XSDATETIME:
                                return (
                                        convertYearToString(this._years) +
                                        '-' +
                                        convertToTwoCharString(this._months) +
                                        '-' +
                                        convertToTwoCharString(this._days) +
                                        'T' +
                                        convertToTwoCharString(this._hours) +
                                        ':' +
                                        convertToTwoCharString(this._minutes) +
                                        ':' +
                                        convertSecondsToString(this._seconds + this.secondFraction) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSDATE:
                                return (
                                        convertYearToString(this._years) +
                                        '-' +
                                        convertToTwoCharString(this._months) +
                                        '-' +
                                        convertToTwoCharString(this._days) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSTIME:
                                return (
                                        convertToTwoCharString(this._hours) +
                                        ':' +
                                        convertToTwoCharString(this._minutes) +
                                        ':' +
                                        convertSecondsToString(this._seconds + this.secondFraction) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSGDAY:
                                return (
                                        '---' +
                                        convertToTwoCharString(this._days) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSGMONTH:
                                return (
                                        '--' +
                                        convertToTwoCharString(this._months) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSGMONTHDAY:
                                return (
                                        '--' +
                                        convertToTwoCharString(this._months) +
                                        '-' +
                                        convertToTwoCharString(this._days) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSGYEAR:
                                return (
                                        convertYearToString(this._years) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                        case ValueType.XSGYEARMONTH:
                                return (
                                        convertYearToString(this._years) +
                                        '-' +
                                        convertToTwoCharString(this._months) +
                                        (this._timezone ? timezoneToString(this._timezone) : '')
                                );
                }
                throw new Error('Unexpected subType');
        }
}

// dateTime    | (-)yyyy-mm-ddThh:mm:ss.ss(Z|[+-]hh:mm)
// time        |               hh:mm:ss.ss(Z|[+-]hh:mm)
// date        | (-)yyyy-mm-dd            (Z|[+-]hh:mm)
// gYearMonth  | (-)yyyy-mm               (Z|[+-]hh:mm)
// gYear       | (-)yyyy                  (Z|[+-]hh:mm)
// gMonthDay   |       --mm-dd            (Z|[+-]hh:mm)
// gDay        |         ---dd            (Z|[+-]hh:mm)
// gMonth      |       --mm               (Z|[+-]hh:mm)
DateTime.fromString = (dateString: string): DateTime => {
        const regex = /^(?:(-?\d{4,}))?(?:--?(\d\d))?(?:-{1,3}(\d\d))?(T)?(?:(\d\d):(\d\d):(\d\d))?(\.\d+)?(Z|(?:[+-]\d\d:\d\d))?$/;
        const match = regex.exec(dateString);

        const years = match[1] ? parseInt(match[1], 10) : null;
        const months = parseMatch(match[2]);
        const days = parseMatch(match[3]);
        const t = match[4];
        const hours = parseMatch(match[5]);
        const minutes = parseMatch(match[6]);
        const seconds = parseMatch(match[7]);
        const secondFraction = match[8] ? parseFloat(match[8]) : 0;
        const timezone = match[9] ? DayTimeDuration.fromTimezoneString(match[9]) : null;

        if (years && (years < -271821 || years > 273860)) {
                // These are the JavaScript bounds for date (https://tc39.github.io/ecma262/#sec-time-values-and-time-range)
                throw new Error('FODT0001: Datetime year is out of bounds');
        }

        if (t) {
                // There is a T separating the date and time components -> dateTime
                return new DateTime(
                        years,
                        months,
                        days,
                        hours,
                        minutes,
                        seconds,
                        secondFraction,
                        timezone,
                        ValueType.XSDATETIME
                );
        }

        if (hours !== null && minutes !== null && seconds !== null) {
                // There is no T separator, but there is a time component -> time
                return new DateTime(
                        1972,
                        12,
                        31,
                        hours,
                        minutes,
                        seconds,
                        secondFraction,
                        timezone,
                        ValueType.XSTIME
                );
        }

        if (years !== null && months !== null && days !== null) {
                // There is no T separator, but there is a complete date component -> date
                return new DateTime(years, months, days, 0, 0, 0, 0, timezone, ValueType.XSDATE);
        }

        if (years !== null && months !== null) {
                // There is no complete date component, but there is a year and a month -> gYearMonth
                return new DateTime(years, months, 1, 0, 0, 0, 0, timezone, ValueType.XSGYEARMONTH);
        }

        if (months !== null && days !== null) {
                // There is no complete date component, but there is a month and a day -> gMonthDay
                return new DateTime(1972, months, days, 0, 0, 0, 0, timezone, ValueType.XSGMONTHDAY);
        }

        if (years !== null) {
                // There is only a year -> gYear
                return new DateTime(years, 1, 1, 0, 0, 0, 0, timezone, ValueType.XSGYEAR);
        }

        if (months !== null) {
                // There is only a month -> gMonth
                return new DateTime(1972, months, 1, 0, 0, 0, 0, timezone, ValueType.XSGMONTH);
        }

        // There is only one option left -> gDay
        return new DateTime(1972, 12, days, 0, 0, 0, 0, timezone, ValueType.XSGDAY);
};

export function compare(
        dateTime1: DateTime,
        dateTime2: DateTime,
        implicitTimezone?: DayTimeDuration | null
): number {
        const jsTime1 = dateTime1.toJavaScriptDate(implicitTimezone).getTime();
        const jsTime2 = dateTime2.toJavaScriptDate(implicitTimezone).getTime();

        if (jsTime1 === jsTime2) {
                // We should break the tie on the secondFraction property, which has no counterpart in JS dates
                if (dateTime1.secondFraction === dateTime2.secondFraction) {
                        return 0;
                }
                if (dateTime1.secondFraction > dateTime2.secondFraction) {
                        return 1;
                }
                return -1;
        }

        if (jsTime1 > jsTime2) {
                return 1;
        }

        return -1;
}

export function equal(
        dateTime1: DateTime,
        dateTime2: DateTime,
        implicitTimezone?: DayTimeDuration | null
): boolean {
        return compare(dateTime1, dateTime2, implicitTimezone) === 0;
}

export function lessThan(
        dateTime1: DateTime,
        dateTime2: DateTime,
        implicitTimezone?: DayTimeDuration | null
): boolean {
        return compare(dateTime1, dateTime2, implicitTimezone) < 0;
}

export function greaterThan(
        dateTime1: DateTime,
        dateTime2: DateTime,
        implicitTimezone?: DayTimeDuration | null
): boolean {
        return compare(dateTime1, dateTime2, implicitTimezone) > 0;
}

export function subtract(
        dateTime1: DateTime,
        dateTime2: DateTime,
        implicitTimezone?: DayTimeDuration | null
): DayTimeDuration {
        // Divided by 1000 because date subtraction results in milliseconds
        const secondsOfDuration =
                (dateTime1.toJavaScriptDate(implicitTimezone).getTime() -
                        dateTime2.toJavaScriptDate(implicitTimezone).getTime()) /
                1000;
        return new DayTimeDuration(secondsOfDuration);
}

export function addDuration(dateTime: DateTime, _duration: AbstractDuration): DateTime {
        throw new Error(`Not implemented: adding durations to ${valueTypeToString(dateTime.type)}`);
}

export function subtractDuration(dateTime: DateTime, _duration: AbstractDuration): DateTime {
        throw new Error(
                `Not implemented: subtracting durations from ${valueTypeToString(dateTime.type)}`
        );
}

export default DateTime;

1	import { ValueType, valueTypeToString } from '../Value';	18✔
2	import AbstractDuration from './AbstractDuration';
3	import DayTimeDuration from './DayTimeDuration';	18✔
4
5	function parseMatch(match: string \| undefined): number \| null {
6	return match ? parseInt(match, 10) : null;	145,875✔
7	}
8
9	function convertYearToString(year: number): string {
10	let yearString = year + '';	1,563✔
11	const isNegative = yearString.startsWith('-');	1,563✔
12	if (isNegative) {	1,563✔
13	yearString = yearString.substring(1);	168✔
14	}
15	return (isNegative ? '-' : '') + yearString.padStart(4, '0');	1,563✔
16	}
17
18	function convertToTwoCharString(value: number): string {
19	const valueString = value + '';	7,005✔
20	return valueString.padStart(2, '0');	7,005✔
21	}
22
23	function convertSecondsToString(seconds: number): string {
24	let secondsString = seconds + '';	1,245✔
25	if (secondsString.split('.')[0].length === 1) {	1,245✔
26	secondsString = secondsString.padStart(secondsString.length + 1, '0');	658✔
27	}
28	return secondsString;	1,245✔
29	}
30
31	function isUTC(timezone: DayTimeDuration): boolean {
32	return timezone.getHours() === 0 && timezone.getMinutes() === 0;	1,764✔
33	}
34
35	function timezoneToString(timezone: DayTimeDuration): string {
36	if (isUTC(timezone)) {	1,764✔
37	return 'Z';	1,143✔
38	}
39
40	return (	621✔
41	(timezone.isPositive() ? '+' : '-') +	621✔
42	convertToTwoCharString(Math.abs(timezone.getHours())) +
43	':' +
44	convertToTwoCharString(Math.abs(timezone.getMinutes()))
45	);
46	}
47
48	class DateTime {
49	public static fromString: (str: any) => DateTime;
50	public secondFraction: number;
51	public type: ValueType;
52	protected _days: number;
53	protected _hours: number;
54	protected _minutes: number;
55	protected _months: number;
56	protected _seconds: number;
57	protected _timezone: DayTimeDuration;
58	protected _years: number;
59	constructor(
60	years: number,
61	months: number,
62	days: number,
63	hours: number,
64	minutes: number,
65	seconds: number,
66	secondFraction: number,
67	timezone: DayTimeDuration,
68	type: ValueType = ValueType.XSDATETIME	315✔
69	) {
70	this._years = years;	33,966✔
71	this._months = months;	33,966✔
72	this._days = days + (hours === 24 ? 1 : 0);	33,966✔
73	this._hours = hours === 24 ? 0 : hours;	33,966✔
74	this._minutes = minutes;	33,966✔
75	this._seconds = seconds;	33,966✔
76	this.secondFraction = secondFraction;	33,966✔
77	this._timezone = timezone;	33,966✔
78
79	this.type = type;	33,966✔
80	}
81
82	public convertToType(type: ValueType) {
83	// xs:date xxxx-xx-xxT00:00:00
84	// xs:time 1972-12-31Txx:xx:xx
85	// xs:gYearMonth xxxx-xx-01T00:00:00
86	// xs:gYear xxxx-01-01T00:00:00
87	// xs:gMonthDay 1972-xx-xxT00:00:00
88	// xs:gMonth 1972-xx-01T00:00:00
89	// xs:gDay 1972-12-xxT00:00:00
90
91	switch (type) {	4,644✔
92	case ValueType.XSGDAY:	4,698✔
93	return new DateTime(	99✔
94	1972,
95	12,
96	this._days,
97	0,
98	0,
99	0,
100	0,
101	this._timezone,
102	ValueType.XSGDAY
103	);
104	case ValueType.XSGMONTH:
105	return new DateTime(	117✔
106	1972,
107	this._months,
108	1,
109	0,
110	0,
111	0,
112	0,
113	this._timezone,
114	ValueType.XSGMONTH
115	);
116	case ValueType.XSGYEAR:
117	return new DateTime(	129✔
118	this._years,
119	1,
120	1,
121	0,
122	0,
123	0,
124	0,
125	this._timezone,
126	ValueType.XSGYEAR
127	);
128	case ValueType.XSGMONTHDAY:
129	return new DateTime(	129✔
130	1972,
131	this._months,
132	this._days,
133	0,
134	0,
135	0,
136	0,
137	this._timezone,
138	ValueType.XSGMONTHDAY
139	);
140	case ValueType.XSGYEARMONTH:
141	return new DateTime(	99✔
142	this._years,
143	this._months,
144	1,
145	0,
146	0,
147	0,
148	0,
149	this._timezone,
150	ValueType.XSGYEARMONTH
151	);
152	case ValueType.XSTIME:
153	return new DateTime(	1,521✔
154	1972,
155	12,
156	31,
157	this._hours,
158	this._minutes,
159	this._seconds,
160	this.secondFraction,
161	this._timezone,
162	ValueType.XSTIME
163	);
164	case ValueType.XSDATE:
165	return new DateTime(	2,496✔
166	this._years,
167	this._months,
168	this._days,
169	0,
170	0,
171	0,
172	0,
173	this._timezone,
174	ValueType.XSDATE
175	);
176	case ValueType.XSDATETIME:
177	default:
178	return new DateTime(	54✔
179	this._years,
180	this._months,
181	this._days,
182	this._hours,
183	this._minutes,
184	this._seconds,
185	this.secondFraction,
186	this._timezone,
187	ValueType.XSDATETIME
188	);
189	}
190	}
191
192	public getDay() {
193	return this._days;	792✔
194	}
195
196	public getFullSeconds() {
197	return this._seconds + this.secondFraction;	486✔
198	}
199
200	public getHours() {
201	return this._hours;	834✔
202	}
203
204	public getMinutes() {
205	return this._minutes;	786✔
206	}
207
208	public getMonth() {
209	return this._months;	2,004✔
210	}
211
212	public getSecondFraction() {
213	return this.secondFraction;	300✔
214	}
215
216	public getSeconds() {
217	return this._seconds;	300✔
218	}
219
220	public getTimezone() {
221	return this._timezone;	1,587✔
222	}
223
224	public getYear() {
225	return this._years;	1,614✔
226	}
227
228	public isPositive() {
229	return this._years >= 0;	×
230	}
231
232	public toJavaScriptDate(implicitTimezone?: DayTimeDuration): Date {
233	const timezoneToUse =
234	this._timezone \|\| implicitTimezone \|\| DayTimeDuration.fromTimezoneString('Z');	12,957✔
235	return new Date(	12,957✔
236	Date.UTC(
237	this._years,
238	this._months - 1,
239	this._days,
240	this._hours - timezoneToUse.getHours(),
241	this._minutes - timezoneToUse.getMinutes(),
242	this._seconds + this.secondFraction
243	)
244	);
245	}
246
247	public toString() {
248	switch (this.type) {	2,790✔
249	case ValueType.XSDATETIME:	2,790✔
250	return (	579✔
251	convertYearToString(this._years) +
252	'-' +
253	convertToTwoCharString(this._months) +
254	'-' +
255	convertToTwoCharString(this._days) +
256	'T' +
257	convertToTwoCharString(this._hours) +
258	':' +
259	convertToTwoCharString(this._minutes) +
260	':' +
261	convertSecondsToString(this._seconds + this.secondFraction) +
262	(this._timezone ? timezoneToString(this._timezone) : '')	579✔
263	);
264	case ValueType.XSDATE:
265	return (	588✔
266	convertYearToString(this._years) +
267	'-' +
268	convertToTwoCharString(this._months) +
269	'-' +
270	convertToTwoCharString(this._days) +
271	(this._timezone ? timezoneToString(this._timezone) : '')	588✔
272	);
273	case ValueType.XSTIME:
274	return (	666✔
275	convertToTwoCharString(this._hours) +
276	':' +
277	convertToTwoCharString(this._minutes) +
278	':' +
279	convertSecondsToString(this._seconds + this.secondFraction) +
280	(this._timezone ? timezoneToString(this._timezone) : '')	666✔
281	);
282	case ValueType.XSGDAY:
283	return (	177✔
284	'---' +
285	convertToTwoCharString(this._days) +
286	(this._timezone ? timezoneToString(this._timezone) : '')	177✔
287	);
288	case ValueType.XSGMONTH:
289	return (	189✔
290	'--' +
291	convertToTwoCharString(this._months) +
292	(this._timezone ? timezoneToString(this._timezone) : '')	189✔
293	);
294	case ValueType.XSGMONTHDAY:
295	return (	195✔
296	'--' +
297	convertToTwoCharString(this._months) +
298	'-' +
299	convertToTwoCharString(this._days) +
300	(this._timezone ? timezoneToString(this._timezone) : '')	195✔
301	);
302	case ValueType.XSGYEAR:
303	return (	213✔
304	convertYearToString(this._years) +
305	(this._timezone ? timezoneToString(this._timezone) : '')	213✔
306	);
307	case ValueType.XSGYEARMONTH:
308	return (	183✔
309	convertYearToString(this._years) +
310	'-' +
311	convertToTwoCharString(this._months) +
312	(this._timezone ? timezoneToString(this._timezone) : '')	183✔
313	);
314	}
315	throw new Error('Unexpected subType');	×
316	}
317	}
318
319	// dateTime \| (-)yyyy-mm-ddThh:mm:ss.ss(Z\|[+-]hh:mm)
320	// time \| hh:mm:ss.ss(Z\|[+-]hh:mm)
321	// date \| (-)yyyy-mm-dd (Z\|[+-]hh:mm)
322	// gYearMonth \| (-)yyyy-mm (Z\|[+-]hh:mm)
323	// gYear \| (-)yyyy (Z\|[+-]hh:mm)
324	// gMonthDay \| --mm-dd (Z\|[+-]hh:mm)
325	// gDay \| ---dd (Z\|[+-]hh:mm)
326	// gMonth \| --mm (Z\|[+-]hh:mm)
327	DateTime.fromString = (dateString: string): DateTime => {	18✔
328	const regex = /^(?:(-?\d{4,}))?(?:--?(\d\d))?(?:-{1,3}(\d\d))?(T)?(?:(\d\d):(\d\d):(\d\d))?(\.\d+)?(Z\|(?:[+-]\d\d:\d\d))?$/;	29,175✔
329	const match = regex.exec(dateString);	29,175✔
330
331	const years = match[1] ? parseInt(match[1], 10) : null;	29,175✔
332	const months = parseMatch(match[2]);	29,175✔
333	const days = parseMatch(match[3]);	29,175✔
334	const t = match[4];	29,175✔
335	const hours = parseMatch(match[5]);	29,175✔
336	const minutes = parseMatch(match[6]);	29,175✔
337	const seconds = parseMatch(match[7]);	29,175✔
338	const secondFraction = match[8] ? parseFloat(match[8]) : 0;	29,175✔
339	const timezone = match[9] ? DayTimeDuration.fromTimezoneString(match[9]) : null;	29,175✔
340
341	if (years && (years < -271821 \|\| years > 273860)) {	29,175✔
342	// These are the JavaScript bounds for date (https://tc39.github.io/ecma262/#sec-time-values-and-time-range)
343	throw new Error('FODT0001: Datetime year is out of bounds');	168✔
344	}
345
346	if (t) {	29,007✔
347	// There is a T separating the date and time components -> dateTime
348	return new DateTime(	11,496✔
349	years,
350	months,
351	days,
352	hours,
353	minutes,
354	seconds,
355	secondFraction,
356	timezone,
357	ValueType.XSDATETIME
358	);
359	}
360
361	if (hours !== null && minutes !== null && seconds !== null) {	17,511✔
362	// There is no T separator, but there is a time component -> time
363	return new DateTime(	3,021✔
364	1972,
365	12,
366	31,
367	hours,
368	minutes,
369	seconds,
370	secondFraction,
371	timezone,
372	ValueType.XSTIME
373	);
374	}
375
376	if (years !== null && months !== null && days !== null) {	14,490✔
377	// There is no T separator, but there is a complete date component -> date
378	return new DateTime(years, months, days, 0, 0, 0, 0, timezone, ValueType.XSDATE);	7,161✔
379	}
380
381	if (years !== null && months !== null) {	7,329✔
382	// There is no complete date component, but there is a year and a month -> gYearMonth
383	return new DateTime(years, months, 1, 0, 0, 0, 0, timezone, ValueType.XSGYEARMONTH);	1,455✔
384	}
385
386	if (months !== null && days !== null) {	5,874✔
387	// There is no complete date component, but there is a month and a day -> gMonthDay
388	return new DateTime(1972, months, days, 0, 0, 0, 0, timezone, ValueType.XSGMONTHDAY);	1,509✔
389	}
390
391	if (years !== null) {	4,365✔
392	// There is only a year -> gYear
393	return new DateTime(years, 1, 1, 0, 0, 0, 0, timezone, ValueType.XSGYEAR);	1,467✔
394	}
395
396	if (months !== null) {	2,898✔
397	// There is only a month -> gMonth
398	return new DateTime(1972, months, 1, 0, 0, 0, 0, timezone, ValueType.XSGMONTH);	1,419✔
399	}
400
401	// There is only one option left -> gDay
402	return new DateTime(1972, 12, days, 0, 0, 0, 0, timezone, ValueType.XSGDAY);	1,479✔
403	};
404
405	export function compare(	18✔
406	dateTime1: DateTime,
407	dateTime2: DateTime,
408	implicitTimezone?: DayTimeDuration \| null
409	): number {
410	const jsTime1 = dateTime1.toJavaScriptDate(implicitTimezone).getTime();	5,592✔
411	const jsTime2 = dateTime2.toJavaScriptDate(implicitTimezone).getTime();	5,592✔
412
413	if (jsTime1 === jsTime2) {	5,592✔
414	// We should break the tie on the secondFraction property, which has no counterpart in JS dates
415	if (dateTime1.secondFraction === dateTime2.secondFraction) {	1,734✔
416	return 0;	1,710✔
417	}
418	if (dateTime1.secondFraction > dateTime2.secondFraction) {	24✔
419	return 1;	9✔
420	}
421	return -1;	15✔
422	}
423
424	if (jsTime1 > jsTime2) {	3,858✔
425	return 1;	2,289✔
426	}
427
428	return -1;	1,569✔
429	}
430
431	export function equal(	18✔
432	dateTime1: DateTime,
433	dateTime2: DateTime,
434	implicitTimezone?: DayTimeDuration \| null
435	): boolean {
436	return compare(dateTime1, dateTime2, implicitTimezone) === 0;	3,546✔
437	}
438
439	export function lessThan(	18✔
440	dateTime1: DateTime,
441	dateTime2: DateTime,
442	implicitTimezone?: DayTimeDuration \| null
443	): boolean {
444	return compare(dateTime1, dateTime2, implicitTimezone) < 0;	741✔
445	}
446
447	export function greaterThan(	18✔
448	dateTime1: DateTime,
449	dateTime2: DateTime,
450	implicitTimezone?: DayTimeDuration \| null
451	): boolean {
452	return compare(dateTime1, dateTime2, implicitTimezone) > 0;	1,305✔
453	}
454
455	export function subtract(	18✔
456	dateTime1: DateTime,
457	dateTime2: DateTime,
458	implicitTimezone?: DayTimeDuration \| null
459	): DayTimeDuration {
460	// Divided by 1000 because date subtraction results in milliseconds
461	const secondsOfDuration =
462	(dateTime1.toJavaScriptDate(implicitTimezone).getTime() -	867✔
463	dateTime2.toJavaScriptDate(implicitTimezone).getTime()) /
464	1000;
465	return new DayTimeDuration(secondsOfDuration);	867✔
466	}
467
468	export function addDuration(dateTime: DateTime, _duration: AbstractDuration): DateTime {	18✔
NEW 469	throw new Error(`Not implemented: adding durations to ${valueTypeToString(dateTime.type)}`);	×
470	}
471
472	export function subtractDuration(dateTime: DateTime, _duration: AbstractDuration): DateTime {	18✔
NEW 473	throw new Error(	×
474	`Not implemented: subtracting durations from ${valueTypeToString(dateTime.type)}`
475	);
476	}
477
478	export default DateTime;	18✔

FontoXML / fontoxpath / 978118701

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