@markuplint/types 1.0.0-dev.20211213.0

package/src/whatwg/check-datetime/duration-string.ts

@@ -0,0 +1,399 @@
+import type { CustomSyntaxChecker } from '../../types';
+
+import { log } from '../../debug';
+import { matched, unmatched } from '../../match-result';
+import { TokenCollection } from '../../token';
+
+import { datetimeTokenCheck } from './datetime-tokens';
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#durations
+ */
+export const checkDurationISO8601LikeString: CustomSyntaxChecker = () =>
+	function checkDurationISO8601LikeString(value) {
+		log('CHECK: duration-string (ISO8601 like)');
+
+		// PnDTnHnMnS
+		const tokens = TokenCollection.fromPatterns(value, [
+			// Start sign P
+			/[^0-9T]?/,
+			// date part
+			/[^T]*/,
+			// Time sign T
+			/[^0-9]?/,
+			// Time part
+			/.*/,
+		]);
+
+		log('Duration ISO8601: "%s" => %O', tokens.value, tokens);
+
+		const res = tokens.eachCheck(
+			p => {
+				if (!p || !p.value) {
+					return unmatched('', 'missing-token', {
+						expects: [{ type: 'const', value: 'P' }],
+						partName: 'duration',
+					});
+				}
+
+				if (!p.match('P', false)) {
+					return p.unmatched({
+						reason: 'unexpected-token',
+						expects: [{ type: 'const', value: 'P' }],
+						partName: 'duration',
+					});
+				}
+			},
+			d => {
+				if (!d || !d.value) {
+					return;
+				}
+
+				const [num, sign, extra] = TokenCollection.fromPatterns(d, [/[0-9]+/, /./]);
+
+				log('Date part: "%s" => %O', d.value, { num, sign });
+
+				if (!num.match(/^[0-9]+$/)) {
+					return num.unmatched({
+						reason: 'unexpected-token',
+						expects: [],
+						partName: 'date',
+					});
+				}
+
+				if (!sign || !sign.value) {
+					return unmatched('', 'missing-token', {
+						expects: [{ type: 'const', value: 'D' }],
+						partName: 'date',
+					});
+				}
+
+				if (!sign.match('D', false)) {
+					return sign.unmatched({
+						reason: 'unexpected-token',
+						expects: [{ type: 'const', value: 'D' }],
+						partName: 'date',
+					});
+				}
+
+				if (extra && extra.value) {
+					return extra.unmatched({
+						reason: 'unexpected-token',
+						expects: [{ type: 'const', value: 'T' }],
+					});
+				}
+			},
+			t => {
+				if (!t || !t.value) {
+					return unmatched('', 'missing-token', {
+						expects: [{ type: 'const', value: 'T' }],
+					});
+				}
+
+				if (!t.match('T', false)) {
+					return t.unmatched({
+						reason: 'unexpected-token',
+						expects: [{ type: 'const', value: 'T' }],
+					});
+				}
+			},
+			time => {
+				if (!time) {
+					return unmatched('', 'missing-token', {
+						expects: [
+							{ type: 'common', value: 'hour' },
+							{ type: 'common', value: 'minute' },
+							{ type: 'common', value: 'second' },
+						],
+						partName: 'time',
+					});
+				}
+
+				const timeTokens = TokenCollection.fromPatterns(time, [
+					// Hour part
+					/[0-9]+(\.[0-9]*)?[^0-9]?/,
+					// Minute part
+					/[0-9]+(\.[0-9]*)?[^0-9]?/,
+					// Second part
+					/[0-9]+(\.[0-9]*)?[^0-9]?/,
+				]);
+
+				log('Time part: "%s" => %O', timeTokens.value, timeTokens);
+
+				const [h, m, s] = timeTokens;
+
+				if ((h?.value || '') + (m?.value || '') + (s?.value || '') === '') {
+					return unmatched('', 'missing-token', {
+						expects: [
+							{ type: 'common', value: 'hour' },
+							{ type: 'common', value: 'minute' },
+							{ type: 'common', value: 'second' },
+						],
+					});
+				}
+
+				const specified = new Set<'H' | 'M' | 'S'>();
+
+				for (const t of timeTokens) {
+					if (!t || !t.value) {
+						continue;
+					}
+
+					if (specified.has('S')) {
+						return t.unmatched({
+							reason: 'extra-token',
+						});
+					}
+
+					const [num, dpfp, sign] = TokenCollection.fromPatterns(t, [/[0-9]+/, /(\.[0-9]*)?/, /[^0-9]+/]);
+
+					log('Time part (h|m|s): "%s" => %O', t.value, { num, dpfp, sign });
+
+					if (!num.match(/^[0-9]+$/)) {
+						return num.unmatched({
+							reason: 'unexpected-token',
+							expects: [{ type: 'common', value: 'number' }],
+							partName: 'time',
+						});
+					}
+
+					if (dpfp && dpfp.value) {
+						const [dp, fp] = TokenCollection.fromPatterns(dpfp, [/\./, /[0-9]+/]);
+
+						log('Second fractional part (h|m|s): "%s" => %O', dpfp.value, { dp, fp });
+
+						if (!dp.match('.')) {
+							return dp.unmatched({
+								reason: 'unexpected-token',
+								expects: [],
+								partName: 'decimal point',
+							});
+						}
+
+						if (!fp || !fp.value) {
+							return unmatched('', 'missing-token', {
+								expects: [{ type: 'common', value: 'fractional part' }],
+								partName: 'second',
+							});
+						}
+
+						if (!fp.match(/^[0-9]+$/)) {
+							return fp.unmatched({
+								reason: 'unexpected-token',
+								expects: [],
+								partName: 'fractional part',
+							});
+						}
+
+						if (!(1 <= fp.length && fp.length <= 3)) {
+							return fp.unmatched({
+								reason: { type: 'out-of-range-length-digit', gte: 1, lte: 3 },
+								expects: [],
+								partName: 'fractional part',
+							});
+						}
+					}
+
+					const expects = [
+						{ type: 'const', value: 'H' },
+						{ type: 'const', value: 'M' },
+						{ type: 'const', value: 'S' },
+					] as const;
+
+					if (!sign || !sign.value) {
+						return unmatched('', 'missing-token', {
+							expects: expects.filter(e => !specified.has(e.value)),
+							partName: 'time',
+						});
+					}
+
+					if (specified.has('M') && sign.match('H', false)) {
+						return sign.unmatched({
+							reason: 'unexpected-token',
+							expects: [{ type: 'const', value: 'S' }],
+							partName: 'time',
+						});
+					}
+
+					if (
+						!sign.match(['H', 'M', 'S'], false) ||
+						(sign.match('H', false) && specified.has('H')) ||
+						(sign.match('M', false) && specified.has('M'))
+					) {
+						return sign.unmatched({
+							reason: 'unexpected-token',
+							expects: expects.filter(e => !specified.has(e.value)),
+							partName: 'time',
+						});
+					}
+
+					specified.add(sign.value as 'H' | 'M' | 'S');
+				}
+			},
+			datetimeTokenCheck.extra,
+		);
+
+		if (!res.matched) {
+			log('Failed: %O', res);
+		}
+
+		return res;
+	};
+
+export const checkDurationComponentListString: CustomSyntaxChecker = () =>
+	function checkDurationComponentListString(value) {
+		log('CHECK: duration-string (duration component list)');
+
+		if (!value) {
+			return unmatched('', 'empty-token', {
+				expects: [{ type: 'common', value: 'time' }],
+			});
+		}
+
+		const patterns = [
+			// 1. Zero or more ASCII whitespace.
+			/\s*/,
+			// 2. One or more ASCII digits, representing a number of time units,
+			// scaled by the duration time component scale specified (see below)
+			// to represent a number of seconds.
+			/[0-9]+/,
+			// 3. If the duration time component scale specified is 1 (i.e. the units are seconds),
+			// then, optionally, a U+002E FULL STOP character (.) followed by
+			// one, two, or three ASCII digits, representing a fraction of a second.
+			/(\.[0-9]*)?/,
+			// 4. Zero or more ASCII whitespace.
+			/\s*/,
+			// 5. One of the following characters, representing the duration time component scale
+			// of the time unit used in the numeric part of the duration time component:
+			/[^0-9]/,
+			// 6. Zero or more ASCII whitespace.
+			/\s*/,
+		];
+
+		const tokens = TokenCollection.fromPatterns(value, patterns, { repeat: true });
+		const components = tokens.chunk(patterns.length);
+
+		const specified = new Set<'w' | 'd' | 'h' | 'm' | 's'>();
+
+		for (const component of components) {
+			log('Duration Component: "%s" => %O', component.value, component);
+
+			const [, , dpfp, , unit] = component;
+
+			const res = component.eachCheck(
+				ws => {},
+				num => {
+					if (!num || !num.value) {
+						const reason = dpfp?.value || unit?.value ? 'unexpected-token' : 'missing-token';
+						return unmatched('', reason, {
+							expects: [{ type: 'common', value: 'time' }],
+						});
+					}
+				},
+				dpfp => {
+					if (!dpfp || !dpfp.value) {
+						return;
+					}
+
+					const unitExpects = (
+						[
+							{ type: 'const', value: 'w' },
+							{ type: 'const', value: 'd' },
+							{ type: 'const', value: 'h' },
+							{ type: 'const', value: 'm' },
+							{ type: 'const', value: 's' },
+						] as const
+					).filter(e => !specified.has(e.value));
+
+					if (specified.has('s')) {
+						return dpfp.unmatched({
+							reason: 'unexpected-token',
+							expects: unitExpects,
+							partName: 'unit',
+						});
+					}
+
+					const [, fp] = TokenCollection.fromPatterns(dpfp, [/\./, /[0-9]+/]);
+
+					if (!fp || !fp.value) {
+						return unmatched('', 'missing-token', {
+							expects: [{ type: 'common', value: 'fractional part' }],
+							partName: 'fractional part',
+						});
+					}
+
+					if (!fp.match(/[0-9]+/)) {
+						return fp.unmatched({
+							reason: 'unexpected-token',
+							expects: [{ type: 'common', value: 'fractional part' }],
+							partName: 'fractional part',
+						});
+					}
+
+					if (!(1 <= fp.length && fp.length <= 3)) {
+						return fp.unmatched({
+							reason: { type: 'out-of-range-length-digit', gte: 1, lte: 3 },
+							expects: [],
+							partName: 'fractional part',
+						});
+					}
+				},
+				ws => {},
+				unit => {
+					const expects = (
+						[
+							{ type: 'const', value: 'w' },
+							{ type: 'const', value: 'd' },
+							{ type: 'const', value: 'h' },
+							{ type: 'const', value: 'm' },
+							{ type: 'const', value: 's' },
+						] as const
+					).filter(e => !specified.has(e.value));
+
+					if (!unit || !unit.value) {
+						return unmatched('', 'missing-token', {
+							expects,
+							partName: 'unit',
+						});
+					}
+
+					const unitVal = unit.value.toLowerCase() as 'w' | 'd' | 'h' | 'm' | 's';
+
+					if (specified.has(unitVal)) {
+						return unit.unmatched({
+							reason: 'duplicated',
+							expects,
+							partName: 'unit',
+						});
+					}
+
+					if (dpfp && dpfp.value && unit.match(['w', 'd', 'h', 'm'])) {
+						return unit.unmatched({
+							reason: 'unexpected-token',
+							expects: [{ type: 'const', value: 's' }],
+							partName: 'unit',
+						});
+					}
+
+					if (!unit.match(['w', 'd', 'h', 'm', 's'])) {
+						return unit.unmatched({
+							reason: 'unexpected-token',
+							expects,
+							partName: 'unit',
+						});
+					}
+
+					specified.add(unitVal);
+				},
+				ws => {},
+			);
+
+			if (!res.matched) {
+				log('Failed: %O', res);
+
+				return res;
+			}
+		}
+
+		return matched();
+	};

package/src/whatwg/check-datetime/global-date-and-time-string.ts

@@ -0,0 +1,96 @@
+import type { CustomSyntaxChecker } from '../../types';
+
+import { log } from '../../debug';
+import { unmatched } from '../../match-result';
+import { TokenCollection } from '../../token';
+
+import { datetimeTokenCheck } from './datetime-tokens';
+import { parseTimeZone } from './time-zone-offset-string';
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#global-dates-and-times
+ */
+export const checkGlobalDateAndTimeString: CustomSyntaxChecker = () =>
+	function checkGlobalDateAndTimeString(value) {
+		log('CHECK: global-date-and-time-string');
+
+		const tokens = TokenCollection.fromPatterns(value, [
+			// YYYY
+			/[^-]*/,
+			// -
+			/[^0-9]?/,
+			// MM
+			/[^-]*/,
+			// -
+			/[^0-9]?/,
+			// DD
+			/[^T\s]*/,
+			// T \s
+			/[^0-9]?/,
+			// hh
+			/[^:]*/,
+			// :
+			/[^0-9]?/,
+			// mm
+			/[^:Z+-]*/,
+			// :ss.sss
+			/(:[^Z+-]*)?/,
+			// time-zone
+			/.*/,
+		]);
+
+		log('Global Date and Time "%s" => %O', tokens.value, tokens);
+
+		const res = tokens.eachCheck(
+			datetimeTokenCheck.year,
+			datetimeTokenCheck.hyphen,
+			datetimeTokenCheck.month,
+			datetimeTokenCheck.hyphen,
+			datetimeTokenCheck.date,
+			datetimeTokenCheck.localDateTimeSeparator,
+			datetimeTokenCheck.hour,
+			datetimeTokenCheck.coron,
+			datetimeTokenCheck.minute,
+			second => {
+				if (!second || !second.value) {
+					return;
+				}
+
+				const secondTokens = TokenCollection.fromPatterns(second, [/:?/, /[0-9]*/, /\.?/, /[0-9]*/]);
+
+				log('Scond Part: "%s" => %O', secondTokens.value, secondTokens);
+
+				const res = secondTokens.eachCheck(
+					datetimeTokenCheck.coron,
+					datetimeTokenCheck.second,
+					datetimeTokenCheck.decimalPointOrEnd,
+					datetimeTokenCheck.secondFractionalPart,
+				);
+
+				if (!res.matched) {
+					return res;
+				}
+			},
+			zone => {
+				if (!zone || !zone.value) {
+					return unmatched(value, 'missing-token', {
+						expects: [{ type: 'common', value: 'time-zone' }],
+						partName: 'time-zone',
+					});
+				}
+
+				const res = parseTimeZone(zone);
+
+				if (!res.matched) {
+					return res;
+				}
+			},
+			datetimeTokenCheck.extra,
+		);
+
+		if (!res.matched) {
+			log('Failed: %O', res);
+		}
+
+		return res;
+	};