@tldraw/validate 5.1.1 → 5.2.0-canary.05c017c18b15

package/src/test/dicts.test.ts

@@ -0,0 +1,86 @@
+import * as T from '../lib/validation'
+import { ValidationError } from '../lib/validation'
+
+describe('§11 Dictionaries', () => {
+	it('[DI1] dict validates every key and value, prefixing the key on failure', () => {
+		const validator = T.dict(T.string, T.number)
+		const value = { alice: 100, bob: 85 }
+		expect(validator.validate(value)).toBe(value)
+
+		expect(() => validator.validate({ alice: 'x' })).toThrow(
+			'At alice: Expected number, got a string'
+		)
+
+		const shortKeys = T.dict(
+			T.string.check((key) => {
+				if (key.length > 2) throw new ValidationError('key too long')
+			}),
+			T.number
+		)
+		expect(() => shortKeys.validate({ abc: 1 })).toThrow('At abc: key too long')
+	})
+
+	it('[DI1] non-objects and null are rejected; arrays pass the object check', () => {
+		const validator = T.dict(T.string, T.number)
+		expect(() => validator.validate(null)).toThrow('Expected object, got null')
+		expect(() => validator.validate('x')).toThrow('Expected object, got a string')
+
+		const arr = [1, 2]
+		expect(validator.validate(arr)).toBe(arr)
+	})
+
+	it('[DI2] jsonDict validates string keys and JSON values', () => {
+		const value = { a: 'x', b: 42, c: ['a', 'b'], d: { nested: true }, e: null }
+		expect(T.jsonDict().validate(value)).toBe(value)
+		expect(() => T.jsonDict().validate({ a: () => {} })).toThrow(
+			'At a: Expected json serializable value, got function'
+		)
+	})
+
+	it('[DI3] known-good validation returns the known-good object when nothing changed', () => {
+		const validator = T.dict(T.string, T.number)
+		const knownGood = validator.validate({ a: 1, b: 2 })
+		expect(validator.validateUsingKnownGoodVersion(knownGood, { a: 1, b: 2 })).toBe(knownGood)
+	})
+
+	it('[DI3] added keys are fully validated and produce the new object', () => {
+		const validator = T.dict(T.string, T.number)
+		const knownGood = validator.validate({ a: 1, b: 2 })
+
+		const added = { a: 1, b: 2, c: 3 }
+		expect(validator.validateUsingKnownGoodVersion(knownGood, added)).toBe(added)
+		expect(() =>
+			validator.validateUsingKnownGoodVersion(knownGood, { a: 1, b: 2, c: 'x' })
+		).toThrow('At c: Expected number, got a string')
+	})
+
+	it('[DI3] removed keys are detected', () => {
+		const validator = T.dict(T.string, T.number)
+		const knownGood = validator.validate({ a: 1, b: 2 })
+		const removed = { a: 1 }
+		expect(validator.validateUsingKnownGoodVersion(knownGood, removed)).toBe(removed)
+
+		// a swap (one removed, one added) is also detected
+		const swapped = { a: 1, c: 2 }
+		expect(validator.validateUsingKnownGoodVersion(knownGood, swapped)).toBe(swapped)
+	})
+
+	it('[DI3] changed values are revalidated incrementally', () => {
+		let calls = 0
+		const counting = new T.Validator<number>((value) => {
+			calls++
+			return T.number.validate(value)
+		})
+		const validator = T.dict(T.string, counting)
+		const knownGood = validator.validate({ a: 1, b: 2 })
+		calls = 0
+
+		const next = { a: 1, b: 3 }
+		expect(validator.validateUsingKnownGoodVersion(knownGood, next)).toBe(next)
+		expect(calls).toBe(1)
+
+		expect(() => validator.validateUsingKnownGoodVersion(knownGood, { a: 1, b: 'x' })).toThrow(
+			'At b: Expected number, got a string'
+		)
+	})
+})

package/src/test/enums.test.ts

@@ -0,0 +1,28 @@
+import * as T from '../lib/validation'
+
+describe('§8 Enums', () => {
+	it('[EN1] setEnum accepts exactly the set members', () => {
+		const validator = T.setEnum(new Set(['red', 'green', 'blue']))
+		expect(validator.validate('red')).toBe('red')
+		expect(validator.validate('blue')).toBe('blue')
+		expect(() => validator.validate('yellow')).toThrow(
+			'Expected "red" or "green" or "blue", got yellow'
+		)
+	})
+
+	it('[EN1] the failure message JSON-stringifies the allowed values and string-interpolates the actual one', () => {
+		expect(() => T.setEnum(new Set([1, 2])).validate(3)).toThrow('Expected 1 or 2, got 3')
+		expect(() => T.setEnum(new Set(['a', 'b'])).validate({ toString: () => 'OBJ' })).toThrow(
+			'Expected "a" or "b", got OBJ'
+		)
+	})
+
+	it('[EN2] literalEnum behaves as a setEnum over its arguments', () => {
+		const validator = T.literalEnum('light', 'dark', 'auto')
+		expect(validator.validate('light')).toBe('light')
+		expect(validator.validate('auto')).toBe('auto')
+		expect(() => validator.validate('blue')).toThrow(
+			'Expected "light" or "dark" or "auto", got blue'
+		)
+	})
+})

package/src/test/errors.test.ts

@@ -0,0 +1,124 @@
+import * as T from '../lib/validation'
+import { ValidationError } from '../lib/validation'
+
+describe('§2 Validation errors and paths', () => {
+	it('[E1] exposes name, rawMessage, and path', () => {
+		const error = new ValidationError('msg', ['a', 0, 'b'])
+		expect(error).toBeInstanceOf(Error)
+		expect(error.name).toBe('ValidationError')
+		expect(error.rawMessage).toBe('msg')
+		expect(error.path).toEqual(['a', 0, 'b'])
+
+		const noPath = new ValidationError('msg')
+		expect(noPath.path).toEqual([])
+	})
+
+	it('[E2] prefixes the formatted path onto the message when the path is non-empty', () => {
+		expect(new ValidationError('msg', ['a', 0, 'b']).message).toBe('At a.0.b: msg')
+	})
+
+	it('[E2] uses the raw message alone when the path is empty', () => {
+		expect(new ValidationError('msg').message).toBe('msg')
+		expect(new ValidationError('msg', []).message).toBe('msg')
+
+		try {
+			T.string.validate(5)
+			throw new Error('should have thrown')
+		} catch (error) {
+			expect((error as Error).message).toBe('Expected string, got a number')
+		}
+	})
+
+	it('[E3] joins string segments with dots and renders numeric indices', () => {
+		const validator = T.object({
+			toad: T.object({
+				friends: T.arrayOf(T.object({ name: T.string })),
+			}),
+		})
+
+		expect(() =>
+			validator.validate({ toad: { friends: [{ name: 'bird' }, { name: 1235 }] } })
+		).toThrow('At toad.friends.1.name: Expected string, got a number')
+	})
+
+	it('[E4] appends parenthesized segments without a dot', () => {
+		const animal = T.union('type', {
+			cat: T.object({ type: T.literal('cat'), id: T.string, meow: T.boolean }),
+			dog: T.object({ type: T.literal('dog'), id: T.string, bark: T.boolean }),
+		})
+		const nested = T.object({ animal })
+
+		expect(() => nested.validate({ animal: { type: 'cat', meow: 'yes', id: 'abc123' } })).toThrow(
+			'At animal(type = cat).meow: Expected boolean, got a string'
+		)
+	})
+
+	it('[E4] merges consecutive parenthesized segments into one group', () => {
+		const validator = T.union('type', {
+			cat: T.object({ type: T.literal('cat'), n: T.number }).check('named', () => {
+				throw new ValidationError('boom')
+			}),
+		})
+
+		expect(() => validator.validate({ type: 'cat', n: 1 })).toThrow(
+			'At (type = cat, check named): boom'
+		)
+	})
+
+	it('[E5] strips id = … content from formatted paths', () => {
+		const validator = T.object({
+			thing: T.union('id', {
+				foo: T.object({ id: T.literal('foo'), n: T.number }),
+			}),
+		})
+
+		expect(() => validator.validate({ thing: { id: 'foo', n: 'bad' } })).toThrow(
+			'At thing().n: Expected number, got a string'
+		)
+	})
+
+	it('[E6] indents every line after the first in multi-line messages', () => {
+		const validator = T.object({
+			x: T.number.check(() => {
+				throw new ValidationError('line1\nline2\nline3')
+			}),
+		})
+
+		expect(() => validator.validate({ x: 1 })).toThrow('At x: line1\n  line2\n  line3')
+	})
+
+	it('[E7] accumulates the path outside-in while preserving rawMessage', () => {
+		const validator = T.object({
+			users: T.arrayOf(T.object({ email: T.string })),
+		})
+
+		try {
+			validator.validate({ users: [{ email: 'a@b.com' }, { email: 42 }] })
+			throw new Error('should have thrown')
+		} catch (error) {
+			expect(error).toBeInstanceOf(ValidationError)
+			expect((error as ValidationError).rawMessage).toBe('Expected string, got a number')
+			expect((error as ValidationError).path).toEqual(['users', 1, 'email'])
+			expect((error as ValidationError).message).toBe(
+				'At users.1.email: Expected string, got a number'
+			)
+		}
+	})
+
+	it('[E7] wraps non-ValidationError exceptions using their toString', () => {
+		const validator = T.object({
+			x: T.number.check(() => {
+				throw new Error('plain')
+			}),
+		})
+
+		try {
+			validator.validate({ x: 1 })
+			throw new Error('should have thrown')
+		} catch (error) {
+			expect(error).toBeInstanceOf(ValidationError)
+			expect((error as ValidationError).rawMessage).toBe('Error: plain')
+			expect((error as ValidationError).path).toEqual(['x'])
+		}
+	})
+})

package/src/test/index-key.test.ts

@@ -0,0 +1,15 @@
+import * as T from '../lib/validation'
+
+describe('§16 Index keys', () => {
+	it('[IK1] accepts valid fractional index keys', () => {
+		expect(T.indexKey.validate('a0')).toBe('a0')
+		expect(T.indexKey.validate('a1J')).toBe('a1J')
+	})
+
+	it('[IK1] rejects invalid index keys', () => {
+		expect(() => T.indexKey.validate('a')).toThrow('Expected an index key, got "a"')
+		expect(() => T.indexKey.validate('a00')).toThrow('Expected an index key, got "a00"')
+		expect(() => T.indexKey.validate('')).toThrow('Expected an index key, got ""')
+		expect(() => T.indexKey.validate(5)).toThrow('Expected string, got a number')
+	})
+})

package/src/test/json.test.ts

@@ -0,0 +1,108 @@
+import * as T from '../lib/validation'
+
+describe('§13 JSON values', () => {
+	it('[J1] accepts JSON scalars, arrays, and plain objects recursively', () => {
+		const value = { name: 'Alice', scores: [1, 2, 3], active: true, meta: null, nested: { a: 'b' } }
+		expect(T.jsonValue.validate(value)).toBe(value)
+		expect(T.jsonValue.validate('x')).toBe('x')
+		expect(T.jsonValue.validate(42)).toBe(42)
+		expect(T.jsonValue.validate(false)).toBe(false)
+		expect(T.jsonValue.validate(null)).toBe(null)
+	})
+
+	it('[J1] accepts non-finite numbers', () => {
+		expect(T.jsonValue.validate(NaN)).toBe(NaN)
+		expect(T.jsonValue.validate(Infinity)).toBe(Infinity)
+	})
+
+	it('[J2] rejects non-JSON values anywhere in the structure', () => {
+		class Foo {}
+		expect(T.jsonValue.isValid(undefined)).toBe(false)
+		expect(T.jsonValue.isValid(() => {})).toBe(false)
+		expect(T.jsonValue.isValid(1n)).toBe(false)
+		expect(T.jsonValue.isValid(Symbol('s'))).toBe(false)
+		expect(T.jsonValue.isValid(new Foo())).toBe(false)
+		expect(T.jsonValue.isValid({ a: undefined })).toBe(false)
+		expect(T.jsonValue.isValid([1, () => {}])).toBe(false)
+		expect(T.jsonValue.isValid({ deep: { deeper: [1n] } })).toBe(false)
+	})
+
+	it('[J2] rejects sparse arrays, whose holes read as undefined', () => {
+		// eslint-disable-next-line no-sparse-arrays
+		expect(T.jsonValue.isValid([1, , 3])).toBe(false)
+		expect(T.jsonValue.isValid(new Array(3))).toBe(false)
+	})
+
+	it('[J3] accepts null-prototype and structured-clone objects as plain objects', () => {
+		expect(T.jsonValue.isValid(Object.create(null))).toBe(true)
+		expect(T.jsonValue.isValid(structuredClone({ a: 1 }))).toBe(true)
+	})
+
+	it('[J4] the full-validation failure message reports the typeof of the root value', () => {
+		expect(() => T.jsonValue.validate({ a: undefined })).toThrow(
+			'Expected json serializable value, got object'
+		)
+		expect(() => T.jsonValue.validate(() => {})).toThrow(
+			'Expected json serializable value, got function'
+		)
+	})
+
+	it('[J5] known-good validation is incremental and identity-preserving for arrays', () => {
+		const knownGood = T.jsonValue.validate([1, [2], 'x'])
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, [1, [2], 'x'])).toBe(knownGood)
+
+		const changed = [1, [2], 'y']
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, changed)).toBe(changed)
+
+		const longer = [1, [2], 'x', 4]
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, longer)).toBe(longer)
+
+		const shorter = [1, [2]]
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, shorter)).toBe(shorter)
+	})
+
+	it('[J5] known-good validation is incremental and identity-preserving for objects', () => {
+		const knownGood = T.jsonValue.validate({ a: [1, 2], b: 'x' })
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, { a: [1, 2], b: 'x' })).toBe(
+			knownGood
+		)
+
+		const changed = { a: [1, 2], b: 'y' }
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, changed)).toBe(changed)
+
+		const removed = { a: [1, 2] }
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, removed)).toBe(removed)
+
+		const added = { a: [1, 2], b: 'x', c: 1 }
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGood, added)).toBe(added)
+	})
+
+	it('[J5] added and changed entries are validated', () => {
+		const knownGoodArr = T.jsonValue.validate([1, 2])
+		expect(() => T.jsonValue.validateUsingKnownGoodVersion(knownGoodArr, [1, () => {}])).toThrow()
+		expect(() =>
+			T.jsonValue.validateUsingKnownGoodVersion(knownGoodArr, [1, 2, () => {}])
+		).toThrow()
+
+		const knownGoodObj = T.jsonValue.validate({ a: 1 })
+		expect(() => T.jsonValue.validateUsingKnownGoodVersion(knownGoodObj, { a: () => {} })).toThrow()
+		expect(() =>
+			T.jsonValue.validateUsingKnownGoodVersion(knownGoodObj, { a: 1, b: () => {} })
+		).toThrow()
+	})
+
+	it('[J6] a shape mismatch falls back to a full validation of the new value', () => {
+		const knownGoodArr = T.jsonValue.validate([1])
+		const obj = { a: 1 }
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGoodArr, obj)).toBe(obj)
+
+		const knownGoodObj = T.jsonValue.validate({ a: 1 })
+		const arr = [1]
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGoodObj, arr)).toBe(arr)
+
+		expect(T.jsonValue.validateUsingKnownGoodVersion(knownGoodObj, 'x')).toBe('x')
+		expect(() => T.jsonValue.validateUsingKnownGoodVersion(knownGoodObj, () => {})).toThrow(
+			'Expected json serializable value, got function'
+		)
+	})
+})

package/src/test/model.test.ts

@@ -0,0 +1,34 @@
+import * as T from '../lib/validation'
+
+describe('§14 Models', () => {
+	it('[M1] model prefixes the model name onto validation failures', () => {
+		const shape = T.model('shape', T.object({ id: T.string, x: T.number, y: T.number }))
+
+		const value = { id: 'abc123', x: 132, y: 0 }
+		expect(shape.validate(value)).toBe(value)
+
+		expect(() => shape.validate({ id: 'abc123', x: 132, y: NaN })).toThrow(
+			'At shape.y: Expected a number, got NaN'
+		)
+		expect(() =>
+			T.model(
+				'shape',
+				T.object({ id: T.string, color: T.setEnum(new Set(['red', 'green', 'blue'])) })
+			).validate({ id: 'abc13', color: 'rubbish' })
+		).toThrow('At shape.color: Expected "red" or "green" or "blue", got rubbish')
+	})
+
+	it('[M2] known-good validation delegates to the inner validator with the same prefixing', () => {
+		const user = T.model('user', T.object({ id: T.string, n: T.number }))
+		const knownGood = user.validate({ id: 'x', n: 1 })
+
+		expect(user.validateUsingKnownGoodVersion(knownGood, { id: 'x', n: 1 })).toBe(knownGood)
+
+		const next = { id: 'x', n: 2 }
+		expect(user.validateUsingKnownGoodVersion(knownGood, next)).toBe(next)
+
+		expect(() => user.validateUsingKnownGoodVersion(knownGood, { id: 'x', n: 'bad' })).toThrow(
+			'At user.n: Expected number, got a string'
+		)
+	})
+})

package/src/test/nullable-optional.test.ts

@@ -0,0 +1,75 @@
+import * as T from '../lib/validation'
+
+describe('§5 optional and nullable', () => {
+	it('[NO1] nullable accepts null and passes everything else to the inner validator', () => {
+		const validator = T.nullable(T.string)
+		expect(validator.validate(null)).toBe(null)
+		expect(validator.validate('hello')).toBe('hello')
+		expect(() => validator.validate(undefined)).toThrow('Expected string, got undefined')
+		expect(() => validator.validate(5)).toThrow('Expected string, got a number')
+	})
+
+	it('[NO1] the .nullable() method behaves like T.nullable', () => {
+		expect(T.string.nullable().validate(null)).toBe(null)
+		expect(T.string.nullable().validate('hello')).toBe('hello')
+	})
+
+	it('[NO2] optional accepts undefined and passes everything else to the inner validator', () => {
+		const validator = T.optional(T.string)
+		expect(validator.validate(undefined)).toBe(undefined)
+		expect(validator.validate('hello')).toBe('hello')
+		expect(() => validator.validate(null)).toThrow('Expected string, got null')
+	})
+
+	it('[NO2] the .optional() method behaves like T.optional', () => {
+		expect(T.string.optional().validate(undefined)).toBe(undefined)
+		expect(T.string.optional().validate('hello')).toBe('hello')
+	})
+
+	it('[NO3] known-good validation short-circuits null/undefined new values', () => {
+		let calls = 0
+		const counting = new T.Validator<string>((value) => {
+			calls++
+			return T.string.validate(value)
+		})
+
+		expect(T.optional(counting).validateUsingKnownGoodVersion('a', undefined)).toBe(undefined)
+		expect(T.nullable(counting).validateUsingKnownGoodVersion('a', null)).toBe(null)
+		expect(calls).toBe(0)
+	})
+
+	it('[NO3] a null/undefined known-good value forces a full inner validate', () => {
+		expect(T.string.optional().validateUsingKnownGoodVersion(undefined, 'a')).toBe('a')
+		expect(() => T.string.optional().validateUsingKnownGoodVersion(undefined, 5)).toThrow(
+			'Expected string, got a number'
+		)
+		expect(T.string.nullable().validateUsingKnownGoodVersion(null, 'a')).toBe('a')
+		expect(() => T.string.nullable().validateUsingKnownGoodVersion(null, 5)).toThrow(
+			'Expected string, got a number'
+		)
+	})
+
+	it('[NO3] otherwise the inner known-good path is used, preserving identity', () => {
+		const validator = T.object({ a: T.number }).optional()
+		const knownGood = validator.validate({ a: 1 })
+		expect(validator.validateUsingKnownGoodVersion(knownGood, { a: 1 })).toBe(knownGood)
+
+		const next = { a: 2 }
+		expect(validator.validateUsingKnownGoodVersion(knownGood, next)).toBe(next)
+	})
+
+	it('[NO4] optional/nullable wrappers keep transforming validators exempt from the dev same-value check', () => {
+		expect(
+			T.string
+				.refine((s) => s.toUpperCase())
+				.optional()
+				.validate('a')
+		).toBe('A')
+		expect(
+			T.string
+				.refine((s) => s.toUpperCase())
+				.nullable()
+				.validate('a')
+		).toBe('A')
+	})
+})

package/src/test/numbers.test.ts

@@ -0,0 +1,114 @@
+import * as T from '../lib/validation'
+
+describe('§7 Numbers', () => {
+	it('[N1] number accepts finite numbers and rejects everything else with specific messages', () => {
+		expect(T.number.validate(42)).toBe(42)
+		expect(T.number.validate(-3.14)).toBe(-3.14)
+		expect(T.number.validate(0)).toBe(0)
+
+		expect(() => T.number.validate('42')).toThrow('Expected number, got a string')
+		expect(() => T.number.validate(NaN)).toThrow('Expected a number, got NaN')
+		expect(() => T.number.validate(Infinity)).toThrow('Expected a finite number, got Infinity')
+		expect(() => T.number.validate(-Infinity)).toThrow('Expected a finite number, got -Infinity')
+	})
+
+	it('[N2] positiveNumber accepts zero and positive finite numbers', () => {
+		expect(T.positiveNumber.validate(29.99)).toBe(29.99)
+		expect(T.positiveNumber.validate(0)).toBe(0)
+
+		expect(() => T.positiveNumber.validate(-1)).toThrow('Expected a positive number, got -1')
+		expect(() => T.positiveNumber.validate(-Infinity)).toThrow(
+			'Expected a positive number, got -Infinity'
+		)
+		expect(() => T.positiveNumber.validate(Infinity)).toThrow(
+			'Expected a finite number, got Infinity'
+		)
+		expect(() => T.positiveNumber.validate(NaN)).toThrow('Expected a number, got NaN')
+		expect(() => T.positiveNumber.validate('1')).toThrow('Expected number, got a string')
+	})
+
+	it('[N3] nonZeroNumber accepts only positive finite numbers', () => {
+		expect(T.nonZeroNumber.validate(0.01)).toBe(0.01)
+
+		expect(() => T.nonZeroNumber.validate(0)).toThrow('Expected a non-zero positive number, got 0')
+		expect(() => T.nonZeroNumber.validate(-5)).toThrow(
+			'Expected a non-zero positive number, got -5'
+		)
+		expect(() => T.nonZeroNumber.validate(-Infinity)).toThrow(
+			'Expected a non-zero positive number, got -Infinity'
+		)
+	})
+
+	it('[N4] nonZeroFiniteNumber accepts non-zero finite numbers including negatives', () => {
+		expect(T.nonZeroFiniteNumber.validate(-1.5)).toBe(-1.5)
+		expect(T.nonZeroFiniteNumber.validate(2)).toBe(2)
+
+		expect(() => T.nonZeroFiniteNumber.validate(0)).toThrow('Expected a non-zero number, got 0')
+		expect(() => T.nonZeroFiniteNumber.validate(Infinity)).toThrow(
+			'Expected a finite number, got Infinity'
+		)
+	})
+
+	it('[N5] unitInterval accepts finite numbers in [0, 1]', () => {
+		expect(T.unitInterval.validate(0)).toBe(0)
+		expect(T.unitInterval.validate(0.5)).toBe(0.5)
+		expect(T.unitInterval.validate(1)).toBe(1)
+
+		expect(() => T.unitInterval.validate(1.5)).toThrow('Expected a number between 0 and 1, got 1.5')
+		expect(() => T.unitInterval.validate(-0.1)).toThrow(
+			'Expected a number between 0 and 1, got -0.1'
+		)
+		expect(() => T.unitInterval.validate(Infinity)).toThrow(
+			'Expected a number between 0 and 1, got Infinity'
+		)
+		expect(() => T.unitInterval.validate(NaN)).toThrow('Expected a number, got NaN')
+	})
+
+	it('[N6] integer accepts whole finite numbers including negatives', () => {
+		expect(T.integer.validate(42)).toBe(42)
+		expect(T.integer.validate(-5)).toBe(-5)
+		expect(T.integer.validate(0)).toBe(0)
+
+		expect(() => T.integer.validate(3.14)).toThrow('Expected an integer, got 3.14')
+		expect(() => T.integer.validate(NaN)).toThrow('Expected a number, got NaN')
+		expect(() => T.integer.validate(Infinity)).toThrow('Expected a finite number, got Infinity')
+		expect(() => T.integer.validate('1')).toThrow('Expected number, got a string')
+	})
+
+	it('[N7] positiveInteger accepts zero and positive integers', () => {
+		expect(T.positiveInteger.validate(5)).toBe(5)
+		expect(T.positiveInteger.validate(0)).toBe(0)
+
+		expect(() => T.positiveInteger.validate(-1)).toThrow('Expected a positive integer, got -1')
+		expect(() => T.positiveInteger.validate(3.14)).toThrow('Expected an integer, got 3.14')
+	})
+
+	it('[N7] positiveInteger reports any negative number as not a positive integer, even fractions', () => {
+		expect(() => T.positiveInteger.validate(-1.5)).toThrow('Expected a positive integer, got -1.5')
+	})
+
+	it('[N8] nonZeroInteger accepts only positive integers', () => {
+		expect(T.nonZeroInteger.validate(1)).toBe(1)
+
+		expect(() => T.nonZeroInteger.validate(0)).toThrow(
+			'Expected a non-zero positive integer, got 0'
+		)
+		expect(() => T.nonZeroInteger.validate(-5)).toThrow(
+			'Expected a non-zero positive integer, got -5'
+		)
+		expect(() => T.nonZeroInteger.validate(0.5)).toThrow('Expected an integer, got 0.5')
+		expect(() => T.nonZeroInteger.validate(-0.5)).toThrow(
+			'Expected a non-zero positive integer, got -0.5'
+		)
+	})
+
+	it('[N9] negative zero counts as zero and as a non-negative integer', () => {
+		expect(T.number.validate(-0)).toBe(-0)
+		expect(T.integer.validate(-0)).toBe(-0)
+		expect(T.positiveNumber.validate(-0)).toBe(-0)
+		expect(T.positiveInteger.validate(-0)).toBe(-0)
+
+		expect(() => T.nonZeroNumber.validate(-0)).toThrow('Expected a non-zero positive number, got 0')
+		expect(() => T.nonZeroFiniteNumber.validate(-0)).toThrow('Expected a non-zero number, got 0')
+	})
+})