feature(#285): Add Type.BOOLEAN

packages/vue-props-validators/source/modules/boolean.test.ts

@@ -0,0 +1,70 @@
+/* eslint-disable no-magic-numbers */
+import { vuePropsValidators } from '..'
+import { REQUIRED } from '../constants'
+
+import { TypeBoolean } from './boolean'
+
+import { Type } from '.'
+
+const BASE_BOOLEAN: TypeBoolean = {
+	default: () => null,
+	nullable: true,
+	type: Type.BOOLEAN,
+}
+
+test('boolean has correct type', () =>
+	expect(vuePropsValidators.create({ example: BASE_BOOLEAN })).toMatchObject({
+		example: { type: Boolean },
+	}))
+
+test('boolean validator works', () => {
+	const { example } = vuePropsValidators.create({
+		example: BASE_BOOLEAN,
+	})
+
+	expect(example.validator('test')).toBeFalsy()
+	expect(example.validator(false)).toBeTruthy()
+	expect(example.validator(true)).toBeTruthy()
+	expect(example.validator(undefined)).toBeFalsy()
+	expect(example.validator(NaN)).toBeFalsy()
+	expect(example.validator(42)).toBeFalsy()
+	expect(example.validator(2.3)).toBeFalsy()
+})
+
+test('boolean (nullable: false)', () =>
+	expect(
+		vuePropsValidators
+			.create({
+				example: { ...BASE_BOOLEAN, nullable: false },
+			})
+			.example.validator(null),
+	).toBeFalsy())
+
+test('boolean (nullable: true)', () =>
+	expect(
+		vuePropsValidators
+			.create({
+				example: { ...BASE_BOOLEAN, nullable: true },
+			})
+			.example.validator(null),
+	).toBeTruthy())
+
+test('boolean (default)', () =>
+	expect(
+		vuePropsValidators
+			.create({
+				example: { ...BASE_BOOLEAN, default: () => null },
+			})
+			.example.default(),
+	).toBe(null))
+
+test('boolean (required)', () =>
+	expect(
+		vuePropsValidators.create({
+			example: { ...BASE_BOOLEAN, default: REQUIRED },
+		}),
+	).toMatchObject({
+		example: {
+			required: true,
+		},
+	}))

packages/vue-props-validators/source/modules/boolean.ts

@@ -0,0 +1,20 @@
+import { baseValidator } from '../common/base-validator'
+import { resolveDefault } from '../common/resolve-default'
+import { Result } from '../types'
+
+import { TypeBase, Type } from '.'
+
+export type TypeBoolean = TypeBase & {
+	type: Type.BOOLEAN
+}
+
+export const createBoolean = <OPTION extends TypeBoolean>(
+	option: OPTION,
+): Result<OPTION, BooleanConstructor> => ({
+	...resolveDefault(option),
+	type: Boolean,
+	validator: baseValidator(
+		option,
+		(value: unknown) => typeof value === 'boolean',
+	),
+})

packages/vue-props-validators/source/modules/index.ts

@@ -1,5 +1,6 @@
 import { REQUIRED } from '../constants'
 
+import { TypeBoolean } from './boolean'
 import { TypeEnum } from './enum'
 import { TypeFloat } from './float'
 import { TypeInteger } from './integer'
@@ -11,10 +12,16 @@ export type TypeBase = {
 }
 
 export enum Type {
+	BOOLEAN = 'boolean',
 	ENUM = 'enum',
 	FLOAT = 'float',
 	INTEGER = 'integer',
 	STRING = 'string',
 }
 
-export type Option = TypeEnum | TypeFloat | TypeInteger | TypeString
+export type Option =
+	| TypeBoolean
+	| TypeEnum
+	| TypeFloat
+	| TypeInteger
+	| TypeString

packages/vue-props-validators/source/namespace.ts

@@ -1,11 +1,13 @@
 import { Type, Option } from './modules'
+import { createBoolean } from './modules/boolean'
 import { createEnum } from './modules/enum'
 import { createFloat } from './modules/float'
 import { createInteger } from './modules/integer'
 import { createString } from './modules/string'
 import { Options, Result } from './types'
 
 type ResultMap<OPTION extends Option> = {
+	[Type.BOOLEAN]: Result<OPTION, BooleanConstructor>
 	[Type.ENUM]: Result<OPTION, StringConstructor>
 	[Type.FLOAT]: Result<OPTION, NumberConstructor>
 	[Type.INTEGER]: Result<OPTION, NumberConstructor>
@@ -20,6 +22,9 @@ export const create = <PROPS extends Options>(
 	Object.fromEntries(
 		Object.entries(props).map(([prop, option]) => {
 			switch (option.type) {
+				case Type.BOOLEAN:
+					return [prop, createBoolean(option)]
+
 				case Type.ENUM:
 					return [prop, createEnum(option)]