21812409980

Committed 09 Feb 2026 04:29AM UTC coverage: 91.737% (+0.9%) from 90.868%

Build # 21812409980

Build Type

Pull #336

github

Committed by

web-flow

Commit Message

Merge 026eca1de into 87b824610

Pull Request Pull Request #336: feat!: new api, see docs for changes

Run Details

489 of 499 branches covered (98.0%)

Branch coverage included in aggregate %.

160 of 184 new or added lines in 8 files covered. (86.96%)

4 existing lines in 1 file now uncovered.

1454 of 1619 relevant lines covered (89.81%)

25020.31 hits per line

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

86.71

/src/format-validators.ts

import isEmailModule from 'validator/lib/isEmail.js';
import isIPModule from 'validator/lib/isIP.js';
import isURLModule from 'validator/lib/isURL.js';

import { sortedKeys } from './utils/json.js';

export type FormatValidatorFn = (input: unknown) => boolean | Promise<boolean>;

const dateValidator: FormatValidatorFn = (date: unknown) => {
  if (typeof date !== 'string') {
    return true;
  }
  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
  const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
  if (matches === null) {
    return false;
  }
  // var year = matches[1];
  // var month = matches[2];
  // var day = matches[3];
  if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
    return false;
  }
  return true;
};

const dateTimeValidator: FormatValidatorFn = (dateTime: unknown) => {
  if (typeof dateTime !== 'string') {
    return true;
  }
  // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
  const s = dateTime.toLowerCase().split('t');
  if (s.length !== 2) {
    return false;
  }
  const datePart = s[0];
  const timePart = s[1];
  // Check date
  const dateMatches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(datePart);
  if (dateMatches === null) {
    return false;
  }
  const year = parseInt(dateMatches[1], 10);
  const month = parseInt(dateMatches[2], 10);
  const day = parseInt(dateMatches[3], 10);
  if (month < 1 || month > 12 || day < 1 || day > 31) {
    return false;
  }
  // Check if date is valid
  const date = new Date(year, month - 1, day);
  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
    return false;
  }
  // Check time
  const timeMatches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(timePart);
  if (timeMatches === null) {
    return false;
  }
  const hour = parseInt(timeMatches[1], 10);
  const minute = parseInt(timeMatches[2], 10);
  const second = parseInt(timeMatches[3], 10);
  if (hour > 23 || minute > 59 || second > 60) {
    return false;
  }
  // Check offset
  let utcHour = hour;
  if (timeMatches[5] !== 'z') {
    const offset = timeMatches[5];
    const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(offset);
    if (offsetMatches === null) {
      return false;
    }
    const offsetSign = offsetMatches[1];
    const offsetHour = parseInt(offsetMatches[2], 10);
    const offsetMinute = parseInt(offsetMatches[3], 10);
    if (offsetHour > 23 || offsetMinute > 59) {
      return false;
    }
    if (offsetSign === '+') {
      utcHour = hour - offsetHour;
    } else {
      utcHour = hour + offsetHour;
    }
    utcHour = ((utcHour % 24) + 24) % 24;
  }
  // Leap second only at 23:59:60 UTC
  if (second === 60) {
    if (utcHour !== 23 || minute !== 59) {
      return false;
    }
  }
  return true;
};

const emailValidator: FormatValidatorFn = (email: unknown) => {
  if (typeof email !== 'string') {
    return true;
  }
  return isEmailModule.default(email, { require_tld: true });
};

const hostnameValidator: FormatValidatorFn = (hostname: unknown) => {
  if (typeof hostname !== 'string') {
    return true;
  }
  /*
          http://json-schema.org/latest/json-schema-validation.html#anchor114
          A string instance is valid against this attribute if it is a valid
          representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].

          http://tools.ietf.org/html/rfc1034#section-3.5

          <digit> ::= any one of the ten digits 0 through 9
          var digit = /[0-9]/;

          <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
          var letter = /[a-zA-Z]/;

          <let-dig> ::= <letter> | <digit>
          var letDig = /[0-9a-zA-Z]/;

          <let-dig-hyp> ::= <let-dig> | "-"
          var letDigHyp = /[-0-9a-zA-Z]/;

          <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
          var ldhStr = /[-0-9a-zA-Z]+/;

          <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
          var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;

          <subdomain> ::= <label> | <subdomain> "." <label>
          var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;

          <domain> ::= <subdomain> | " "
          var domain = null;
      */
  const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
  if (valid) {
    // the sum of all label octets and label lengths is limited to 255.
    if (hostname.length > 255) {
      return false;
    }
    // Each node has a label, which is zero to 63 octets in length
    const labels = hostname.split('.');
    for (let i = 0; i < labels.length; i++) {
      if (labels[i].length > 63) {
        return false;
      }
    }
  }
  return valid;
};

const ipv4Validator: FormatValidatorFn = (ipv4: unknown) => {
  if (typeof ipv4 !== 'string') {
    return true;
  }
  return isIPModule.default(ipv4, 4);
};

const ipv6Validator: FormatValidatorFn = (ipv6: unknown) => {
  if (typeof ipv6 !== 'string') {
    return true;
  }
  if (ipv6.includes('%')) {
    return false;
  }
  return isIPModule.default(ipv6, 6);
};

const regexValidator: FormatValidatorFn = (input: unknown) => {
  if (typeof input !== 'string') {
    return false;
  }
  try {
    RegExp(input);
    return true;
  } catch (_e) {
    return false;
  }
};

const strictUriValidator: FormatValidatorFn = (uri: unknown) => typeof uri !== 'string' || isURLModule.default(uri);

const uriValidator: FormatValidatorFn = function (uri: unknown) {
  if (typeof uri !== 'string') return true;
  // eslint-disable-next-line no-control-regex
  if (/[^\x00-\x7F]/.test(uri)) return false;
  const match = uri.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/([^/]*)/);
  if (match) {
    const authority = match[2];
    const atIndex = authority.indexOf('@');
    if (atIndex > 0) {
      const userinfo = authority.substring(0, atIndex);
      if (userinfo.includes('[') || userinfo.includes(']')) {
        return false;
      }
    }
  }
  return /^[a-zA-Z][a-zA-Z0-9+.-]*:[^"\\<>^{}^`| ]*$/.test(uri);
};

export interface FormatValidatorsOptions {
  strictUris?: boolean;
  customFormats?: Record<string, FormatValidatorFn | null>;
}

const inbuiltValidators: Record<string, FormatValidatorFn> = {
  date: dateValidator,
  'date-time': dateTimeValidator,
  email: emailValidator,
  hostname: hostnameValidator,
  'host-name': hostnameValidator,
  ipv4: ipv4Validator,
  ipv6: ipv6Validator,
  regex: regexValidator,
  uri: uriValidator,
  'strict-uri': strictUriValidator,
} as const;

const customValidators: Record<string, FormatValidatorFn> = {};

export function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn> {
  return {
    ...inbuiltValidators,
    ...(options?.strictUris ? { uri: strictUriValidator } : {}),
    ...customValidators,
    ...(options?.customFormats || {}),
  };
}

export function registerFormat(name: string, validatorFunction: FormatValidatorFn) {
  customValidators[name] = validatorFunction;
}

export function unregisterFormat(name: string) {
  delete customValidators[name];
}

export function getSupportedFormats(customFormats?: Record<string, FormatValidatorFn | null>) {
  const merged = {
    ...inbuiltValidators,
    ...customValidators,
    ...customFormats,
  };
  const keys = sortedKeys(merged);
  return keys.filter((key) => merged[key] != null);
}

export function isFormatSupported(name: string, customFormats?: Record<string, FormatValidatorFn | null>): boolean {
  const supported = getSupportedFormats(customFormats);
  return supported.includes(name);
}

export function getRegisteredFormats() {
  return sortedKeys(customValidators);
}

1	import isEmailModule from 'validator/lib/isEmail.js';
2	import isIPModule from 'validator/lib/isIP.js';
3	import isURLModule from 'validator/lib/isURL.js';
4
5	import { sortedKeys } from './utils/json.js';
6
7	export type FormatValidatorFn = (input: unknown) => boolean \| Promise<boolean>;
8
9	const dateValidator: FormatValidatorFn = (date: unknown) => {	73✔
10	if (typeof date !== 'string') {	×
11	return true;	×
12	}
13	// full-date from http://tools.ietf.org/html/rfc3339#section-5.6
14	const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);	×
15	if (matches === null) {	×
16	return false;	×
17	}
18	// var year = matches[1];
19	// var month = matches[2];
20	// var day = matches[3];
21	if (matches[2] < '01' \|\| matches[2] > '12' \|\| matches[3] < '01' \|\| matches[3] > '31') {	×
22	return false;	×
23	}
24	return true;	×
25	};
26
27	const dateTimeValidator: FormatValidatorFn = (dateTime: unknown) => {	73✔
28	if (typeof dateTime !== 'string') {	128✔
29	return true;	48✔
30	}
31	// date-time from http://tools.ietf.org/html/rfc3339#section-5.6
32	const s = dateTime.toLowerCase().split('t');	80✔
33	if (s.length !== 2) {	80✔
34	return false;	×
35	}
36	const datePart = s[0];	80✔
37	const timePart = s[1];	80✔
38	// Check date
39	const dateMatches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(datePart);	80✔
40	if (dateMatches === null) {	80✔
41	return false;	24✔
42	}
43	const year = parseInt(dateMatches[1], 10);	56✔
44	const month = parseInt(dateMatches[2], 10);	56✔
45	const day = parseInt(dateMatches[3], 10);	56✔
46	if (month < 1 \|\| month > 12 \|\| day < 1 \|\| day > 31) {	56✔
NEW 47	return false;	×
48	}
49	// Check if date is valid
50	const date = new Date(year, month - 1, day);	56✔
51	if (date.getFullYear() !== year \|\| date.getMonth() !== month - 1 \|\| date.getDate() !== day) {	56✔
52	return false;	4✔
53	}
54	// Check time
55	const timeMatches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z\|([+-][0-9]{2}:[0-9]{2}))$/.exec(timePart);	52✔
56	if (timeMatches === null) {	52✔
57	return false;	8✔
58	}
59	const hour = parseInt(timeMatches[1], 10);	44✔
60	const minute = parseInt(timeMatches[2], 10);	44✔
61	const second = parseInt(timeMatches[3], 10);	44✔
62	if (hour > 23 \|\| minute > 59 \|\| second > 60) {	44✔
63	return false;	4✔
64	}
65	// Check offset
66	let utcHour = hour;	40✔
67	if (timeMatches[5] !== 'z') {	40✔
68	const offset = timeMatches[5];	16✔
69	const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(offset);	16✔
70	if (offsetMatches === null) {	16✔
NEW 71	return false;	×
72	}
73	const offsetSign = offsetMatches[1];	16✔
74	const offsetHour = parseInt(offsetMatches[2], 10);	16✔
75	const offsetMinute = parseInt(offsetMatches[3], 10);	16✔
76	if (offsetHour > 23 \|\| offsetMinute > 59) {	16✔
77	return false;	4✔
78	}
79	if (offsetSign === '+') {	12✔
80	utcHour = hour - offsetHour;	4✔
81	} else {
82	utcHour = hour + offsetHour;	8✔
83	}
84	utcHour = ((utcHour % 24) + 24) % 24;	12✔
85	}
86	// Leap second only at 23:59:60 UTC
87	if (second === 60) {	36✔
88	if (utcHour !== 23 \|\| minute !== 59) {	16✔
89	return false;	8✔
90	}
91	}
92	return true;	28✔
93	};
94
95	const emailValidator: FormatValidatorFn = (email: unknown) => {	73✔
96	if (typeof email !== 'string') {	120✔
97	return true;	48✔
98	}
99	return isEmailModule.default(email, { require_tld: true });	72✔
100	};
101
102	const hostnameValidator: FormatValidatorFn = (hostname: unknown) => {	73✔
103	if (typeof hostname !== 'string') {	136✔
104	return true;	48✔
105	}
106	/*
107	http://json-schema.org/latest/json-schema-validation.html#anchor114
108	A string instance is valid against this attribute if it is a valid
109	representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
110
111	http://tools.ietf.org/html/rfc1034#section-3.5
112
113	<digit> ::= any one of the ten digits 0 through 9
114	var digit = /[0-9]/;
115
116	<letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
117	var letter = /[a-zA-Z]/;
118
119	<let-dig> ::= <letter> \| <digit>
120	var letDig = /[0-9a-zA-Z]/;
121
122	<let-dig-hyp> ::= <let-dig> \| "-"
123	var letDigHyp = /[-0-9a-zA-Z]/;
124
125	<ldh-str> ::= <let-dig-hyp> \| <let-dig-hyp> <ldh-str>
126	var ldhStr = /[-0-9a-zA-Z]+/;
127
128	<label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
129	var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
130
131	<subdomain> ::= <label> \| <subdomain> "." <label>
132	var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
133
134	<domain> ::= <subdomain> \| " "
135	var domain = null;
136	*/
137	const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);	88✔
138	if (valid) {	88✔
139	// the sum of all label octets and label lengths is limited to 255.
140	if (hostname.length > 255) {	36✔
141	return false;	×
142	}
143	// Each node has a label, which is zero to 63 octets in length
144	const labels = hostname.split('.');	36✔
145	for (let i = 0; i < labels.length; i++) {	36✔
146	if (labels[i].length > 63) {	52✔
147	return false;	8✔
148	}
149	}
150	}
151	return valid;	80✔
152	};
153
154	const ipv4Validator: FormatValidatorFn = (ipv4: unknown) => {	73✔
155	if (typeof ipv4 !== 'string') {	92✔
156	return true;	48✔
157	}
158	return isIPModule.default(ipv4, 4);	44✔
159	};
160
161	const ipv6Validator: FormatValidatorFn = (ipv6: unknown) => {	73✔
162	if (typeof ipv6 !== 'string') {	188✔
163	return true;	48✔
164	}
165	if (ipv6.includes('%')) {	140✔
166	return false;	4✔
167	}
168	return isIPModule.default(ipv6, 6);	136✔
169	};
170
171	const regexValidator: FormatValidatorFn = (input: unknown) => {	73✔
172	if (typeof input !== 'string') {	72✔
173	return false;	×
174	}
175	try {	72✔
176	RegExp(input);	72✔
177	return true;	72✔
178	} catch (_e) {
179	return false;	×
180	}
181	};
182
183	const strictUriValidator: FormatValidatorFn = (uri: unknown) => typeof uri !== 'string' \|\| isURLModule.default(uri);	73✔
184
185	const uriValidator: FormatValidatorFn = function (uri: unknown) {	73✔
186	if (typeof uri !== 'string') return true;	168✔
187	// eslint-disable-next-line no-control-regex
188	if (/[^\x00-\x7F]/.test(uri)) return false;	120✔
189	const match = uri.match(/^([a-zA-Z][a-zA-Z0-9+.-]):\/\/([^/])/);	116✔
190	if (match) {	116✔
191	const authority = match[2];	76✔
192	const atIndex = authority.indexOf('@');	76✔
193	if (atIndex > 0) {	76✔
194	const userinfo = authority.substring(0, atIndex);	8✔
195	if (userinfo.includes('[') \|\| userinfo.includes(']')) {	8✔
196	return false;	4✔
197	}
198	}
199	}
200	return /^[a-zA-Z][a-zA-Z0-9+.-]:[^"\\<>^{}^`\| ]$/.test(uri);	112✔
201	};
202
203	export interface FormatValidatorsOptions {
204	strictUris?: boolean;
205	customFormats?: Record<string, FormatValidatorFn \| null>;
206	}
207
208	const inbuiltValidators: Record<string, FormatValidatorFn> = {	73✔
209	date: dateValidator,
210	'date-time': dateTimeValidator,
211	email: emailValidator,
212	hostname: hostnameValidator,
213	'host-name': hostnameValidator,
214	ipv4: ipv4Validator,
215	ipv6: ipv6Validator,
216	regex: regexValidator,
217	uri: uriValidator,
218	'strict-uri': strictUriValidator,
219	} as const;
220
221	const customValidators: Record<string, FormatValidatorFn> = {};	73✔
222
223	export function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn> {
224	return {	1,250✔
225	...inbuiltValidators,
226	...(options?.strictUris ? { uri: strictUriValidator } : {}),
227	...customValidators,
228	...(options?.customFormats \|\| {}),
229	};
230	}
231
232	export function registerFormat(name: string, validatorFunction: FormatValidatorFn) {
233	customValidators[name] = validatorFunction;	116✔
234	}
235
236	export function unregisterFormat(name: string) {
237	delete customValidators[name];	×
238	}
239
240	export function getSupportedFormats(customFormats?: Record<string, FormatValidatorFn \| null>) {
241	const merged = {	5,121✔
242	...inbuiltValidators,
243	...customValidators,
244	...customFormats,
245	};
246	const keys = sortedKeys(merged);	5,121✔
247	return keys.filter((key) => merged[key] != null);	56,026✔
248	}
249
250	export function isFormatSupported(name: string, customFormats?: Record<string, FormatValidatorFn \| null>): boolean {
251	const supported = getSupportedFormats(customFormats);	5,109✔
252	return supported.includes(name);	5,109✔
253	}
254
255	export function getRegisteredFormats() {
256	return sortedKeys(customValidators);	×
257	}

zaggino / z-schema / 21812409980

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