11283403636

Committed 10 Oct 2024 11:13PM CUT coverage: 91.567%. Remained the same

Build # 11283403636

Build Type

Pull #656

github

Committed by

web-flow

Commit Message

Bump cookie and socket.io

Bumps [cookie](https://github.com/jshttp/cookie) and [socket.io](https://github.com/socketio/socket.io). These dependencies needed to be updated together.

Updates `cookie` from 0.4.2 to 0.7.2
- [Release notes](https://github.com/jshttp/cookie/releases)
- [Commits](https://github.com/jshttp/cookie/compare/v0.4.2...v0.7.2)

Updates `socket.io` from 4.7.2 to 4.8.0
- [Release notes](https://github.com/socketio/socket.io/releases)
- [Changelog](https://github.com/socketio/socket.io/blob/main/CHANGELOG.md)
- [Commits](https://github.com/socketio/socket.io/compare/4.7.2...socket.io@4.8.0)

---
updated-dependencies:
- dependency-name: cookie
  dependency-type: indirect
- dependency-name: socket.io
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #656: Bump cookie and socket.io

Run Details

5002 of 5811 branches covered (86.08%)

Branch coverage included in aggregate %.

10775 of 11419 relevant lines covered (94.36%)

96665.11 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';	15✔
2	import sequenceFactory from '../dataTypes/sequenceFactory';	15✔
3	import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
4	import DateTime from '../dataTypes/valueTypes/DateTime';	15✔
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 = (	15✔
11	_dynamicContext,
12	_executionParameters,
13	_staticContext,
14	sequence,
15	arg2,
16	) => {
17	if (sequence.isEmpty()) {	6!
18	return sequence;	×
19	}
20	if (arg2.isEmpty()) {	6!
21	return arg2;	×
22	}
23
24	const date = sequence.first().value;	6✔
25	const time = arg2.first().value;	6✔
26
27	const dateTimezone = date.getTimezone();	6✔
28	const timeTimezone = time.getTimezone();	6✔
29	let timezoneToUse: DayTimeDuration \| null;
30
31	if (!dateTimezone && !timeTimezone) {	6!
32	timezoneToUse = null;	6✔
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(	6✔
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));	6✔
56	};
57
58	const fnYearFromDateTime: FunctionDefinitionType = (	15✔
59	_dynamicContext,
60	_executionParameters,
61	_staticContext,
62	sequence,
63	) => {
64	if (sequence.isEmpty()) {	6!
65	return sequence;	×
66	}
67	return sequenceFactory.singleton(	6✔
68	createAtomicValue(sequence.first().value.getYear(), ValueType.XSINTEGER),
69	);
70	};
71
72	const fnMonthFromDateTime: FunctionDefinitionType = (	15✔
73	_dynamicContext,
74	_executionParameters,
75	_staticContext,
76	sequence,
77	) => {
78	if (sequence.isEmpty()) {	6!
79	return sequence;	×
80	}
81	return sequenceFactory.singleton(	6✔
82	createAtomicValue(sequence.first().value.getMonth(), ValueType.XSINTEGER),
83	);
84	};
85
86	const fnDayFromDateTime: FunctionDefinitionType = (	15✔
87	_dynamicContext,
88	_executionParameters,
89	_staticContext,
90	sequence,
91	) => {
92	if (sequence.isEmpty()) {	6!
93	return sequence;	×
94	}
95	return sequenceFactory.singleton(	6✔
96	createAtomicValue(sequence.first().value.getDay(), ValueType.XSINTEGER),
97	);
98	};
99
100	const fnHoursFromDateTime: FunctionDefinitionType = (	15✔
101	_dynamicContext,
102	_executionParameters,
103	_staticContext,
104	sequence,
105	) => {
106	if (sequence.isEmpty()) {	6!
107	return sequence;	×
108	}
109	return sequenceFactory.singleton(	6✔
110	createAtomicValue(sequence.first().value.getHours(), ValueType.XSINTEGER),
111	);
112	};
113
114	const fnMinutesFromDateTime: FunctionDefinitionType = (	15✔
115	_dynamicContext,
116	_executionParameters,
117	_staticContext,
118	sequence,
119	) => {
120	if (sequence.isEmpty()) {	6!
121	return sequence;	×
122	}
123	return sequenceFactory.singleton(	6✔
124	createAtomicValue(sequence.first().value.getMinutes(), ValueType.XSINTEGER),
125	);
126	};
127
128	const fnSecondsFromDateTime: FunctionDefinitionType = (	15✔
129	_dynamicContext,
130	_executionParameters,
131	_staticContext,
132	sequence,
133	) => {
134	if (sequence.isEmpty()) {	6!
135	return sequence;	×
136	}
137	return sequenceFactory.singleton(	6✔
138	createAtomicValue(sequence.first().value.getFullSeconds(), ValueType.XSDECIMAL),
139	);
140	};
141	const fnTimezoneFromDateTime: FunctionDefinitionType = (	15✔
142	_dynamicContext,
143	_executionParameters,
144	_staticContext,
145	sequence,
146	) => {
147	if (sequence.isEmpty()) {	9!
148	return sequence;	×
149	}
150
151	const timezone = sequence.first().value.getTimezone();	9✔
152	if (!timezone) {	9!
153	return sequenceFactory.empty();	×
154	}
155
156	return sequenceFactory.singleton(createAtomicValue(timezone, ValueType.XSDAYTIMEDURATION));	9✔
157	};
158
159	const declarations: BuiltinDeclarationType[] = [	15✔
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 {	15✔
287	declarations,
288	};

FontoXML / fontoxpath / 11283403636

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