feat: add MapValidator

README.md

@@ -361,7 +361,7 @@ s.enum('Red', 'Green', 'Blue');
 // s.union(s.literal('Red'), s.literal('Green'), s.literal('Blue'));
 ```
 
-#### Maps // TODO
+#### Maps
 
 ```typescript
 const map = s.map(s.string, s.number);

src/lib/Shapes.ts

@@ -14,7 +14,8 @@ import {
 	SetValidator,
 	StringValidator,
 	UnionValidator,
-	RecordValidator
+	RecordValidator,
+	MapValidator
 } from '../validators/imports';
 import type { Constructor, MappedObjectValidator } from './util-types';
 
@@ -95,4 +96,8 @@ export class Shapes {
 	public record<T>(validator: BaseValidator<T>) {
 		return new RecordValidator(validator);
 	}
+
+	public map<T, U>(keyValidator: BaseValidator<T>, valueValidator: BaseValidator<U>) {
+		return new MapValidator(keyValidator, valueValidator);
+	}
 }

src/type-exports.ts

@@ -44,3 +44,4 @@ export type { RecordValidator } from './validators/RecordValidator';
 export type { SetValidator } from './validators/SetValidator';
 export type { StringValidator } from './validators/StringValidator';
 export type { UnionValidator } from './validators/UnionValidator';
+export type { MapValidator } from './validators/MapValidator';

src/validators/MapValidator.ts

@@ -0,0 +1,41 @@
+import type { IConstraint } from '../constraints/base/IConstraint';
+import { ValidationError } from '../lib/errors/ValidationError';
+import { Result } from '../lib/Result';
+import { BaseValidator } from './imports';
+
+export class MapValidator<K, V> extends BaseValidator<Map<K, V>> {
+	private readonly keyValidator: BaseValidator<K>;
+	private readonly valueValidator: BaseValidator<V>;
+
+	public constructor(keyValidator: BaseValidator<K>, valueValidator: BaseValidator<V>, constraints: readonly IConstraint<Map<K, V>>[] = []) {
+		super(constraints);
+		this.keyValidator = keyValidator;
+		this.valueValidator = valueValidator;
+	}
+
+	protected override clone(): this {
+		return Reflect.construct(this.constructor, [this.keyValidator, this.valueValidator, this.constraints]);
+	}
+
+	protected handle(value: unknown): Result<Map<K, V>, ValidationError | AggregateError> {
+		if (!(value instanceof Map)) {
+			return Result.err(new ValidationError('MapValidator', 'Expected a map', value));
+		}
+
+		const errors: Error[] = [];
+		const transformed = new Map<K, V>();
+
+		for (const [key, val] of value.entries()) {
+			const keyResult = this.keyValidator.run(key);
+			const valueResult = this.valueValidator.run(val);
+			const { length } = errors;
+			if (keyResult.isErr()) errors.push(keyResult.error);
+			if (valueResult.isErr()) errors.push(valueResult.error);
+			if (errors.length === length) transformed.set(keyResult.value!, valueResult.value!);
+		}
+
+		return errors.length === 0 //
+			? Result.ok(transformed)
+			: Result.err(new AggregateError(errors, 'Failed to validate at least one entry'));
+	}
+}

src/validators/imports.ts

@@ -15,3 +15,4 @@ export * from './RecordValidator';
 export * from './SetValidator';
 export * from './StringValidator';
 export * from './UnionValidator';
+export * from './MapValidator';

tests/validators/map.test.ts

@@ -0,0 +1,38 @@
+import { s, ValidationError } from '../../src';
+
+describe('MapValidator', () => {
+	const value = new Map([
+		['a', 1],
+		['b', 2]
+	]);
+	const predicate = s.map(s.string, s.number);
+
+	test('GIVEN a non-map THEN throws ValidationError', () => {
+		expect(() => predicate.parse(false)).toThrow(new ValidationError('MapValidator', 'Expected a map', false));
+	});
+
+	test('GIVEN a matching map THEN returns a map', () => {
+		expect(predicate.parse(value)).toStrictEqual(value);
+	});
+
+	test('GIVEN a non-matching map THEN throws AggregateError', () => {
+		// @ts-ignore Purposefully invalid
+		const map = new Map([
+			['fizz', 1],
+			[2, 3],
+			['foo', 'bar'],
+			[4, 'buzz']
+		]);
+		expect(() => predicate.parse(map)).toThrow(
+			new AggregateError(
+				[
+					new ValidationError('StringValidator', 'Expected a string primitive', 2),
+					new ValidationError('NumberValidator', 'Expected a number primitive', 'bar'),
+					new ValidationError('StringValidator', 'Expected a string primitive', 4),
+					new ValidationError('NumberValidator', 'Expected a number primitive', 'buzz')
+				],
+				'Failed to validate at least one entry'
+			)
+		);
+	});
+});