3960146668

Build Type

push

github

Committed by GitHub

Commit Message

Bump karma from 6.3.17 to 6.4.1

Run Details

4882 of 5680 branches covered (85.95%)

Branch coverage included in aggregate %.

10480 of 11118 relevant lines covered (94.26%)

32587.23 hits per line

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

57.78

/src/expressions/functions/builtInFunctions_datetime.ts

import createAtomicValue from '../dataTypes/createAtomicValue';
import sequenceFactory from '../dataTypes/sequenceFactory';
import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
import DateTime from '../dataTypes/valueTypes/DateTime';
import DayTimeDuration from '../dataTypes/valueTypes/DayTimeDuration';
import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
import { BuiltinDeclarationType } from './builtInFunctions';
import FunctionDefinitionType from './FunctionDefinitionType';

const fnDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence,
        arg2
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        if (arg2.isEmpty()) {
                return arg2;
        }

        const date = sequence.first().value;
        const time = arg2.first().value;

        const dateTimezone = date.getTimezone();
        const timeTimezone = time.getTimezone();
        let timezoneToUse: DayTimeDuration | null;

        if (!dateTimezone && !timeTimezone) {
                timezoneToUse = null;
        } else if (dateTimezone && !timeTimezone) {
                timezoneToUse = dateTimezone;
        } else if (!dateTimezone && timeTimezone) {
                timezoneToUse = timeTimezone;
        } else if (dateTimezone.equals(timeTimezone)) {
                timezoneToUse = dateTimezone;
        } else {
                throw new Error(
                        'FORG0008: fn:dateTime: got a date and time value with different timezones.'
                );
        }

        const dateTime = new DateTime(
                date.getYear(),
                date.getMonth(),
                date.getDay(),
                time.getHours(),
                time.getMinutes(),
                time.getSeconds(),
                time.getSecondFraction(),
                timezoneToUse
        );
        return sequenceFactory.singleton(createAtomicValue(dateTime, ValueType.XSDATETIME));
};

const fnYearFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getYear(), ValueType.XSINTEGER)
        );
};

const fnMonthFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getMonth(), ValueType.XSINTEGER)
        );
};

const fnDayFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getDay(), ValueType.XSINTEGER)
        );
};

const fnHoursFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getHours(), ValueType.XSINTEGER)
        );
};

const fnMinutesFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getMinutes(), ValueType.XSINTEGER)
        );
};

const fnSecondsFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getFullSeconds(), ValueType.XSDECIMAL)
        );
};
const fnTimezoneFromDateTime: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }

        const timezone = sequence.first().value.getTimezone();
        if (!timezone) {
                return sequenceFactory.empty();
        }

        return sequenceFactory.singleton(createAtomicValue(timezone, ValueType.XSDAYTIMEDURATION));
};

const declarations: BuiltinDeclarationType[] = [
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'dateTime',
                argumentTypes: [
                        { type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE },
                        { type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE },
                ],
                returnType: { type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'year-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnYearFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'month-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnMonthFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'day-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnDayFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'hours-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnHoursFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'minutes-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnMinutesFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'seconds-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSDECIMAL, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnSecondsFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'timezone-from-dateTime',
                argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: {
                        type: ValueType.XSDAYTIMEDURATION,
                        mult: SequenceMultiplicity.ZERO_OR_ONE,
                },
                callFunction: fnTimezoneFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'year-from-date',
                argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnYearFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'month-from-date',
                argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnMonthFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'day-from-date',
                argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnDayFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'timezone-from-date',
                argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: {
                        type: ValueType.XSDAYTIMEDURATION,
                        mult: SequenceMultiplicity.ZERO_OR_ONE,
                },
                callFunction: fnTimezoneFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'hours-from-time',
                argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnHoursFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'minutes-from-time',
                argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnMinutesFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'seconds-from-time',
                argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSDECIMAL, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnSecondsFromDateTime,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'timezone-from-time',
                argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: {
                        type: ValueType.XSDAYTIMEDURATION,
                        mult: SequenceMultiplicity.ZERO_OR_ONE,
                },
                callFunction: fnTimezoneFromDateTime,
        },
];

export default {
        declarations,
};

1	import createAtomicValue from '../dataTypes/createAtomicValue';	3✔
2	import sequenceFactory from '../dataTypes/sequenceFactory';	3✔
3	import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
4	import DateTime from '../dataTypes/valueTypes/DateTime';	3✔
5	import DayTimeDuration from '../dataTypes/valueTypes/DayTimeDuration';
6	import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
7	import { BuiltinDeclarationType } from './builtInFunctions';
8	import FunctionDefinitionType from './FunctionDefinitionType';
9
10	const fnDateTime: FunctionDefinitionType = (	3✔
11	_dynamicContext,
12	_executionParameters,
13	_staticContext,
14	sequence,
15	arg2
16	) => {
17	if (sequence.isEmpty()) {	2!
18	return sequence;	×
19	}
20	if (arg2.isEmpty()) {	2!
21	return arg2;	×
22	}
23
24	const date = sequence.first().value;	2✔
25	const time = arg2.first().value;	2✔
26
27	const dateTimezone = date.getTimezone();	2✔
28	const timeTimezone = time.getTimezone();	2✔
29	let timezoneToUse: DayTimeDuration \| null;
30
31	if (!dateTimezone && !timeTimezone) {	2!
32	timezoneToUse = null;	2✔
33	} else if (dateTimezone && !timeTimezone) {	×
34	timezoneToUse = dateTimezone;	×
35	} else if (!dateTimezone && timeTimezone) {	×
36	timezoneToUse = timeTimezone;	×
37	} else if (dateTimezone.equals(timeTimezone)) {	×
38	timezoneToUse = dateTimezone;	×
39	} else {
40	throw new Error(	×
41	'FORG0008: fn:dateTime: got a date and time value with different timezones.'
42	);
43	}
44
45	const dateTime = new DateTime(	2✔
46	date.getYear(),
47	date.getMonth(),
48	date.getDay(),
49	time.getHours(),
50	time.getMinutes(),
51	time.getSeconds(),
52	time.getSecondFraction(),
53	timezoneToUse
54	);
55	return sequenceFactory.singleton(createAtomicValue(dateTime, ValueType.XSDATETIME));	2✔
56	};
57
58	const fnYearFromDateTime: FunctionDefinitionType = (	3✔
59	_dynamicContext,
60	_executionParameters,
61	_staticContext,
62	sequence
63	) => {
64	if (sequence.isEmpty()) {	2!
65	return sequence;	×
66	}
67	return sequenceFactory.singleton(	2✔
68	createAtomicValue(sequence.first().value.getYear(), ValueType.XSINTEGER)
69	);
70	};
71
72	const fnMonthFromDateTime: FunctionDefinitionType = (	3✔
73	_dynamicContext,
74	_executionParameters,
75	_staticContext,
76	sequence
77	) => {
78	if (sequence.isEmpty()) {	2!
79	return sequence;	×
80	}
81	return sequenceFactory.singleton(	2✔
82	createAtomicValue(sequence.first().value.getMonth(), ValueType.XSINTEGER)
83	);
84	};
85
86	const fnDayFromDateTime: FunctionDefinitionType = (	3✔
87	_dynamicContext,
88	_executionParameters,
89	_staticContext,
90	sequence
91	) => {
92	if (sequence.isEmpty()) {	2!
93	return sequence;	×
94	}
95	return sequenceFactory.singleton(	2✔
96	createAtomicValue(sequence.first().value.getDay(), ValueType.XSINTEGER)
97	);
98	};
99
100	const fnHoursFromDateTime: FunctionDefinitionType = (	3✔
101	_dynamicContext,
102	_executionParameters,
103	_staticContext,
104	sequence
105	) => {
106	if (sequence.isEmpty()) {	2!
107	return sequence;	×
108	}
109	return sequenceFactory.singleton(	2✔
110	createAtomicValue(sequence.first().value.getHours(), ValueType.XSINTEGER)
111	);
112	};
113
114	const fnMinutesFromDateTime: FunctionDefinitionType = (	3✔
115	_dynamicContext,
116	_executionParameters,
117	_staticContext,
118	sequence
119	) => {
120	if (sequence.isEmpty()) {	2!
121	return sequence;	×
122	}
123	return sequenceFactory.singleton(	2✔
124	createAtomicValue(sequence.first().value.getMinutes(), ValueType.XSINTEGER)
125	);
126	};
127
128	const fnSecondsFromDateTime: FunctionDefinitionType = (	3✔
129	_dynamicContext,
130	_executionParameters,
131	_staticContext,
132	sequence
133	) => {
134	if (sequence.isEmpty()) {	2!
135	return sequence;	×
136	}
137	return sequenceFactory.singleton(	2✔
138	createAtomicValue(sequence.first().value.getFullSeconds(), ValueType.XSDECIMAL)
139	);
140	};
141	const fnTimezoneFromDateTime: FunctionDefinitionType = (	3✔
142	_dynamicContext,
143	_executionParameters,
144	_staticContext,
145	sequence
146	) => {
147	if (sequence.isEmpty()) {	3!
148	return sequence;	×
149	}
150
151	const timezone = sequence.first().value.getTimezone();	3✔
152	if (!timezone) {	3!
153	return sequenceFactory.empty();	×
154	}
155
156	return sequenceFactory.singleton(createAtomicValue(timezone, ValueType.XSDAYTIMEDURATION));	3✔
157	};
158
159	const declarations: BuiltinDeclarationType[] = [	3✔
160	{
161	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
162	localName: 'dateTime',
163	argumentTypes: [
164	{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE },
165	{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE },
166	],
167	returnType: { type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE },
168	callFunction: fnDateTime,
169	},
170	{
171	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
172	localName: 'year-from-dateTime',
173	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
174	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
175	callFunction: fnYearFromDateTime,
176	},
177	{
178	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
179	localName: 'month-from-dateTime',
180	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
181	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
182	callFunction: fnMonthFromDateTime,
183	},
184	{
185	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
186	localName: 'day-from-dateTime',
187	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
188	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
189	callFunction: fnDayFromDateTime,
190	},
191	{
192	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
193	localName: 'hours-from-dateTime',
194	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
195	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
196	callFunction: fnHoursFromDateTime,
197	},
198	{
199	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
200	localName: 'minutes-from-dateTime',
201	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
202	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
203	callFunction: fnMinutesFromDateTime,
204	},
205	{
206	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
207	localName: 'seconds-from-dateTime',
208	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
209	returnType: { type: ValueType.XSDECIMAL, mult: SequenceMultiplicity.ZERO_OR_ONE },
210	callFunction: fnSecondsFromDateTime,
211	},
212	{
213	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
214	localName: 'timezone-from-dateTime',
215	argumentTypes: [{ type: ValueType.XSDATETIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
216	returnType: {
217	type: ValueType.XSDAYTIMEDURATION,
218	mult: SequenceMultiplicity.ZERO_OR_ONE,
219	},
220	callFunction: fnTimezoneFromDateTime,
221	},
222	{
223	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
224	localName: 'year-from-date',
225	argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
226	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
227	callFunction: fnYearFromDateTime,
228	},
229	{
230	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
231	localName: 'month-from-date',
232	argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
233	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
234	callFunction: fnMonthFromDateTime,
235	},
236	{
237	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
238	localName: 'day-from-date',
239	argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
240	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
241	callFunction: fnDayFromDateTime,
242	},
243	{
244	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
245	localName: 'timezone-from-date',
246	argumentTypes: [{ type: ValueType.XSDATE, mult: SequenceMultiplicity.ZERO_OR_ONE }],
247	returnType: {
248	type: ValueType.XSDAYTIMEDURATION,
249	mult: SequenceMultiplicity.ZERO_OR_ONE,
250	},
251	callFunction: fnTimezoneFromDateTime,
252	},
253	{
254	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
255	localName: 'hours-from-time',
256	argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
257	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
258	callFunction: fnHoursFromDateTime,
259	},
260	{
261	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
262	localName: 'minutes-from-time',
263	argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
264	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
265	callFunction: fnMinutesFromDateTime,
266	},
267	{
268	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
269	localName: 'seconds-from-time',
270	argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
271	returnType: { type: ValueType.XSDECIMAL, mult: SequenceMultiplicity.ZERO_OR_ONE },
272	callFunction: fnSecondsFromDateTime,
273	},
274	{
275	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
276	localName: 'timezone-from-time',
277	argumentTypes: [{ type: ValueType.XSTIME, mult: SequenceMultiplicity.ZERO_OR_ONE }],
278	returnType: {
279	type: ValueType.XSDAYTIMEDURATION,
280	mult: SequenceMultiplicity.ZERO_OR_ONE,
281	},
282	callFunction: fnTimezoneFromDateTime,
283	},
284	];
285
286	export default {	3✔
287	declarations,
288	};

FontoXML / fontoxpath / 3960146668

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