@oscarpalmer/jhunal 0.25.0 → 0.27.0

package/src/handler/value.handler.ts

@@ -0,0 +1,202 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {join} from '@oscarpalmer/atoms/string';
+import {
+	PROPERTY_DEFAULT,
+	PROPERTY_REQUIRED,
+	PROPERTY_TYPE,
+	PROPERTY_VALIDATORS,
+	TYPE_UNDEFINED,
+	TYPES_ALL,
+	VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE,
+	VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE,
+} from '../constants';
+import {
+	getDefaultRequiredMessage,
+	getDefaultTypeMessage,
+	getDisallowedMessage,
+	getRequiredMessage,
+	getSchematicPropertyNullableMessage,
+	getSchematicPropertyTypeMessage,
+} from '../helpers/message.helper';
+import {getParameters, isSchema, isValidator} from '../helpers/misc.helper';
+import type {ValueType} from '../models/misc.model';
+import {
+	type PropertyValidationKey,
+	SchematicError,
+	type ValidationHandler,
+	type ValidationHandlerDefaults,
+	type ValidationHandlerItem,
+	type ValidationHandlerType,
+	ValidatorError,
+	type Validators,
+} from '../models/validation.model';
+import {getBaseHandler} from './base.handler';
+import {getFunctionHandler} from './function.handler';
+import {getObjectHandler} from './object.handler';
+import {getSchemaHandler} from './schema.handler';
+import {getTypeHandler, getTypeValidators, getValidators} from './type.handler';
+import {validatorHandlers} from '../validator';
+
+type Input = {
+	validators?: unknown;
+	value: unknown;
+};
+
+type PropertyInformation = {
+	key: string;
+	origin?: PropertyValidationKey;
+};
+
+function getDefaults(
+	obj: PlainObject,
+	key: string,
+	allowed: boolean,
+): ValidationHandlerDefaults | undefined {
+	if (!(PROPERTY_DEFAULT in obj)) {
+		return;
+	}
+
+	if (!allowed) {
+		throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
+	}
+
+	return {
+		value: obj[PROPERTY_DEFAULT],
+	};
+}
+
+function getRequired(obj: PlainObject, key: string, allowed: boolean): boolean | undefined {
+	if (!(PROPERTY_REQUIRED in obj)) {
+		return;
+	}
+
+	if (!allowed) {
+		throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
+	}
+
+	if (typeof obj[PROPERTY_REQUIRED] !== 'boolean') {
+		throw new SchematicError(getRequiredMessage(key));
+	}
+
+	return obj[PROPERTY_REQUIRED];
+}
+
+export function getValueHandler(
+	input: Input,
+	property?: PropertyInformation,
+): ValidationHandlerItem {
+	const isProperty = property != null;
+
+	const prefixedKey = isProperty
+		? property.origin == null
+			? property.key
+			: join([property.origin.full, property.key], '.')
+		: '';
+
+	const {value} = input;
+
+	if (value == null) {
+		if (isProperty) {
+			throw new SchematicError(getSchematicPropertyNullableMessage(prefixedKey));
+		}
+
+		throw new ValidatorError(VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE);
+	}
+
+	const fullKey: PropertyValidationKey = {
+		full: prefixedKey,
+		short: property?.key ?? '',
+	};
+
+	let required = true;
+	let typed = false;
+	let validators: Validators = {};
+
+	let defaults: ValidationHandlerDefaults | undefined;
+
+	let types: ValidationHandlerType[];
+
+	const handlers: ValidationHandler[] = [];
+
+	if (isProperty && isPlainObject(value)) {
+		typed = PROPERTY_TYPE in value;
+
+		const type = typed ? value[PROPERTY_TYPE] : value;
+
+		defaults = getDefaults(value, prefixedKey, typed);
+		required = getRequired(value, prefixedKey, typed) ?? required;
+		validators = getValidators(value[PROPERTY_VALIDATORS], typed, prefixedKey);
+
+		types = Array.isArray(type) ? type : [type];
+	} else {
+		types = Array.isArray(value) ? value : [value];
+
+		if (input.validators != null) {
+			validators = getTypeValidators(types, input.validators);
+		}
+	}
+
+	const typesLength = types.length;
+
+	let invalid = false;
+
+	typeLoop: for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+		const type = types[typeIndex];
+
+		let handler: ValidationHandler;
+
+		switch (true) {
+			case typeof type === 'function':
+				handler = getFunctionHandler(type);
+				break;
+
+			case isProperty && isPlainObject(type):
+				handler = getObjectHandler(type, fullKey, typed);
+				break;
+
+			case isProperty && isSchema(type):
+				handler = getSchemaHandler(type);
+				break;
+
+			case isProperty && isValidator(type):
+				handler = validatorHandlers.get(type)!;
+				break;
+
+			case TYPES_ALL.has(type as ValueType):
+				handler = getTypeHandler(type as ValueType, validators, isProperty ? fullKey : undefined);
+				break;
+
+			default:
+				invalid = true;
+				break typeLoop;
+		}
+
+		handlers.push(handler);
+	}
+
+	if (invalid || handlers.length === 0) {
+		if (isProperty) {
+			throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
+		}
+
+		throw new ValidatorError(VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE);
+	}
+
+	required = required && !types.includes(TYPE_UNDEFINED);
+
+	if (defaults != null && !required) {
+		throw new SchematicError(getDefaultRequiredMessage(prefixedKey));
+	}
+
+	const handler = getBaseHandler(handlers);
+
+	if (
+		defaults != null &&
+		Array.isArray(handler(defaults.value, getParameters(isProperty), false))
+	) {
+		throw new SchematicError(getDefaultTypeMessage(prefixedKey, types));
+	}
+
+	return {defaults, handler, required, types, key: fullKey};
+}

package/src/helpers/message.helper.ts

@@ -5,7 +5,6 @@ import {
 	CONJUNCTION_AND_COMMA,
 	CONJUNCTION_OR,
 	CONJUNCTION_OR_COMMA,
-	PREFIXED_TYPES,
 	SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED,
 	SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE,
 	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
@@ -13,20 +12,25 @@ import {
 	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
 	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
 	TEMPLATE_PATTERN,
-	TYPE_ALL,
+	TYPES_ALL,
+	TYPES_PREFIXED,
 	TYPE_ARRAY,
 	TYPE_FUNCTION_RESULT,
 	TYPE_NULL,
 	TYPE_OBJECT,
 	VALIDATION_MESSAGE_INVALID_INPUT,
+	VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE,
+	VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR,
 	VALIDATION_MESSAGE_INVALID_REQUIRED,
-	VALIDATION_MESSAGE_INVALID_TYPE,
-	VALIDATION_MESSAGE_INVALID_VALUE,
-	VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX,
+	VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX,
+	VALIDATION_MESSAGE_INVALID_VALUE_TYPE,
+	VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR,
 	VALIDATION_MESSAGE_UNKNOWN_KEYS,
 } from '../constants';
-import type {ValueName} from '../models/misc.model';
-import type {ValidatorType} from '../models/validation.model';
+import type {ValueType} from '../models/misc.model';
+import type {ValidationHandlerType} from '../models/validation.model';
+import {isValidator} from './misc.helper';
+import {validatorTypes} from '../validator';
 
 // #region Defaults
 
@@ -34,7 +38,7 @@ export function getDefaultRequiredMessage(key: string): string {
 	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED.replace(TEMPLATE_PATTERN, key);
 }
 
-export function getDefaultTypeMessage(key: string, types: ValidatorType[]): string {
+export function getDefaultTypeMessage(key: string, types: ValidationHandlerType[]): string {
 	let message = SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE.replace(TEMPLATE_PATTERN, key);
 
 	message = message.replace(TEMPLATE_PATTERN, renderTypes(types));
@@ -62,7 +66,10 @@ export function getInputTypeMessage(actual: unknown): string {
 	return VALIDATION_MESSAGE_INVALID_INPUT.replace(TEMPLATE_PATTERN, getValueType(actual));
 }
 
-export function getInputPropertyMissingMessage(key: string, types: ValidatorType[]): string {
+export function getInputPropertyMissingMessage(
+	key: string,
+	types: ValidationHandlerType[],
+): string {
 	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace(TEMPLATE_PATTERN, renderTypes(types));
 
 	message = message.replace(TEMPLATE_PATTERN, key);
@@ -72,10 +79,13 @@ export function getInputPropertyMissingMessage(key: string, types: ValidatorType
 
 export function getInputPropertyTypeMessage(
 	key: string,
-	types: ValidatorType[],
+	types: ValidationHandlerType[],
 	actual: unknown,
 ): string {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace(TEMPLATE_PATTERN, renderTypes(types));
+	let message = VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE.replace(
+		TEMPLATE_PATTERN,
+		renderTypes(types),
+	);
 
 	message = message.replace(TEMPLATE_PATTERN, key);
 	message = message.replace(TEMPLATE_PATTERN, getValueType(actual));
@@ -85,16 +95,38 @@ export function getInputPropertyTypeMessage(
 
 export function getInputPropertyValidatorMessage(
 	key: string,
-	type: ValueName,
+	type: ValueType,
 	index: number,
 	length: number,
 ): string {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace(TEMPLATE_PATTERN, key);
+	let message = VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR.replace(TEMPLATE_PATTERN, key);
 
 	message = message.replace(TEMPLATE_PATTERN, type);
 
 	if (length > 1) {
-		message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace(TEMPLATE_PATTERN, String(index));
+		message += VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX.replace(TEMPLATE_PATTERN, String(index));
+	}
+
+	return message;
+}
+
+export function getInputValueTypeMessage(types: ValidationHandlerType[], actual: unknown): string {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE_TYPE.replace(TEMPLATE_PATTERN, renderTypes(types));
+
+	message = message.replace(TEMPLATE_PATTERN, getValueType(actual));
+
+	return message;
+}
+
+export function getInputValueValidatorMessage(
+	type: ValueType,
+	index: number,
+	length: number,
+): string {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR.replace(TEMPLATE_PATTERN, type);
+
+	if (length > 1) {
+		message += VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX.replace(TEMPLATE_PATTERN, String(index));
 	}
 
 	return message;
@@ -116,16 +148,19 @@ export function getSchematicPropertyTypeMessage(key: string): string {
 
 // #region Misc.
 
-function getPropertyType(type: ValidatorType): string {
+function getPropertyType(type: ValidationHandlerType): string[] {
 	switch (true) {
 		case typeof type === 'function':
-			return isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT;
+			return [isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT];
+
+		case isValidator(type):
+			return validatorTypes.get(type)!.flatMap(getPropertyType);
 
-		case TYPE_ALL.has(type as ValueName):
-			return PREFIXED_TYPES[type as ValueName];
+		case TYPES_ALL.has(type as ValueType):
+			return [TYPES_PREFIXED[type as ValueType]];
 
 		default:
-			return PREFIXED_TYPES[TYPE_OBJECT];
+			return [TYPES_PREFIXED[TYPE_OBJECT]];
 	}
 }
 
@@ -137,13 +172,13 @@ function getValueType(value: unknown): string {
 			return TYPE_NULL;
 
 		case Array.isArray(value):
-			return PREFIXED_TYPES[TYPE_ARRAY];
+			return TYPES_PREFIXED[TYPE_ARRAY];
 
 		case isPlainObject(value):
-			return PREFIXED_TYPES[TYPE_OBJECT];
+			return TYPES_PREFIXED[TYPE_OBJECT];
 
 		case valueType !== TYPE_OBJECT:
-			return PREFIXED_TYPES[valueType as ValueName];
+			return TYPES_PREFIXED[valueType as ValueType];
 
 		default:
 			return (value as object).constructor.name;
@@ -180,19 +215,26 @@ function renderParts(parts: string[], delimiterShort: string, delimiterLong: str
 	return rendered;
 }
 
-function renderTypes(types: ValidatorType[]): string {
+function renderTypes(types: ValidationHandlerType[]): string {
 	const unique = new Set<string>();
 	const parts: string[] = [];
 
-	for (let index = 0; index < types.length; index += 1) {
-		const rendered = getPropertyType(types[index]);
+	const typesLength = types.length;
 
-		if (unique.has(rendered)) {
-			continue;
-		}
+	for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+		const properties = getPropertyType(types[typeIndex]);
+		const propertiesLength = properties.length;
 
-		unique.add(rendered);
-		parts.push(rendered);
+		for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
+			const property = properties[propertyIndex];
+
+			if (unique.has(property)) {
+				continue;
+			}
+
+			unique.add(property);
+			parts.push(property);
+		}
 	}
 
 	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);

package/src/helpers/misc.helper.ts

@@ -3,20 +3,23 @@ import type {Constructor} from '@oscarpalmer/atoms/models';
 import {
 	MESSAGE_CONSTRUCTOR,
 	PROPERTY_SCHEMA,
+	PROPERTY_VALIDATOR,
 	REPORTING_ALL,
 	REPORTING_FIRST,
 	REPORTING_NONE,
+	REPORTING_RESULT,
 	REPORTING_THROW,
 	REPORTING_TYPES,
 } from '../constants';
 import type {
 	ReportingInformation,
 	ReportingType,
-	ValidatorParameters,
+	ValidationHandlerParameters,
 } from '../models/validation.model';
 import type {Schema} from '../schema';
+import type {Validator} from '../validator';
 
-export function getParameters(input?: unknown): ValidatorParameters {
+export function getParameters(input?: unknown): ValidationHandlerParameters {
 	if (typeof input === 'boolean') {
 		return {
 			clone: true,
@@ -53,7 +56,7 @@ export function getReporting(value?: unknown): ReportingInformation {
 	return {
 		type,
 		[REPORTING_ALL]: type === REPORTING_ALL,
-		[REPORTING_FIRST]: type === REPORTING_FIRST,
+		[REPORTING_FIRST]: type === REPORTING_FIRST || type === REPORTING_RESULT,
 		[REPORTING_NONE]: type === REPORTING_NONE,
 		[REPORTING_THROW]: type === REPORTING_THROW,
 	} as ReportingInformation;
@@ -78,11 +81,11 @@ export function instanceOf<Instance>(
 }
 
 /**
- * Is the value a schematic?
+ * Is the value a schema?
  * @param value Value to check
- * @returns `true` if the value is a schematic, `false` otherwise
+ * @returns `true` if the value is a schema, `false` otherwise
  */
-export function isSchema(value: unknown): value is Schema<never> {
+export function isSchema(value: unknown): value is Schema<unknown> {
 	return (
 		typeof value === 'object' &&
 		value !== null &&
@@ -90,3 +93,17 @@ export function isSchema(value: unknown): value is Schema<never> {
 		value[PROPERTY_SCHEMA] === true
 	);
 }
+
+/**
+ * Is the value a validator?
+ * @param value Value to check
+ * @returns `true` if the value is a validator, `false` otherwise
+ */
+export function isValidator(value: unknown): value is Validator<unknown> {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		PROPERTY_VALIDATOR in value &&
+		value[PROPERTY_VALIDATOR] === true
+	);
+}

package/src/helpers/report.helper.ts

@@ -0,0 +1,72 @@
+import {
+	ValidationError,
+	type ValidationHandlerParameters,
+	type PropertyValidation,
+	type PropertyValidationKey,
+} from '../models/validation.model';
+
+type ReportParameters<Callback extends (...args: any[]) => string> = {
+	extract?: boolean;
+	information?: ReportParametersInformation;
+	key?: PropertyValidationKey;
+	message: ReportParametersMessage<Callback>;
+	original: ValidationHandlerParameters;
+	value: unknown;
+};
+
+type ReportParametersMessage<Callback extends (...args: any[]) => string> = {
+	arguments: Parameters<Callback>;
+	callback: Callback;
+};
+
+type ReportParametersInformation = {
+	all: PropertyValidation[];
+	existing?: PropertyValidation[];
+};
+
+export function report<Callback extends (...args: any[]) => string>(
+	parameters: ReportParameters<Callback>,
+	getReports: true,
+): PropertyValidation[];
+
+export function report<Callback extends (...args: any[]) => string>(
+	parameters: ReportParameters<Callback>,
+): PropertyValidation[] | undefined;
+
+export function report<Callback extends (...args: any[]) => string>(
+	parameters: ReportParameters<Callback>,
+	getReports?: boolean,
+): PropertyValidation[] | undefined {
+	const {information, message, original} = parameters;
+
+	let reported: PropertyValidation[];
+
+	if (information?.existing == null) {
+		reported = [
+			{
+				value: parameters.value,
+				message: message.callback(...message.arguments),
+			},
+		];
+
+		if (parameters.key != null) {
+			reported[0].key = parameters.key;
+		}
+	} else {
+		reported = information.existing;
+	}
+
+	if (original.reporting.throw) {
+		throw new ValidationError(reported);
+	}
+
+	information?.all.push(...reported);
+
+	if (parameters.extract ?? true) {
+		original.information?.push(...reported);
+	}
+
+	if ((getReports ?? false) || !original.reporting.all) {
+		return reported;
+	}
+}

package/src/helpers/result.helper.ts

@@ -0,0 +1,33 @@
+import {error, ok} from '@oscarpalmer/atoms/result/misc';
+import type {ValidationHandler} from '../models/validation.model';
+import {getParameters} from './misc.helper';
+
+export function getResult(handler: ValidationHandler, value: unknown, options?: unknown): unknown {
+	const parameters = getParameters(options);
+
+	const result = handler(value, parameters, true);
+
+	if (result === true) {
+		return parameters.reporting.none || parameters.reporting.throw
+			? parameters.clone
+				? parameters.output
+				: value
+			: ok(parameters.clone ? parameters.output : value);
+	}
+
+	if (!parameters.reporting.none) {
+		return error(parameters.reporting.all ? result : result[0]);
+	}
+}
+
+export function isResult(handler: ValidationHandler, value: unknown, options?: unknown): unknown {
+	const parameters = getParameters(options);
+
+	const result = handler(value, parameters, false);
+
+	if (result === true) {
+		return parameters.reporting.none || parameters.reporting.throw ? result : ok(result);
+	}
+
+	return parameters.reporting.none ? false : error(parameters.reporting.all ? result : result[0]);
+}

package/src/index.ts

@@ -8,3 +8,4 @@ export {
 	type IsOptions,
 } from './models/validation.model';
 export {schema, type Schema} from './schema';
+export {validator, type Validator} from './validator';

package/src/models/infer.model.ts

@@ -1,7 +1,8 @@
 import type {Constructor, Simplify} from '@oscarpalmer/atoms/models';
 import type {Schema} from '../schema';
-import type {IsOptionalProperty, ValueName, Values} from './misc.model';
+import type {IsOptionalProperty, ValueType, Values} from './misc.model';
 import type {PlainSchematic, Schematic, SchematicProperty} from './schematic.plain.model';
+import type {Validator} from '../validator';
 
 /**
  * Infers the TypeScript type from a {@link Schematic} definition
@@ -49,8 +50,6 @@ export type InferPropertyType<Value> = Value extends (infer Item)[]
 /**
  * Maps a single `$type` definition to its TypeScript equivalent
  *
- * Resolves, in order: {@link Constructor}s, {@link Schema} instances, {@link ValueName} values, and nested {@link PlainSchematic} objects
- *
  * @template Value single type definition
  */
 export type InferPropertyValue<Value> =
@@ -58,11 +57,13 @@ export type InferPropertyValue<Value> =
 		? Instance
 		: Value extends Schema<infer Model>
 			? Model
-			: Value extends ValueName
-				? Values[Value & ValueName]
-				: Value extends PlainSchematic
-					? Infer<Value>
-					: never;
+			: Value extends Validator<infer Type>
+				? Type
+				: Value extends ValueType
+					? Values[Value & ValueType]
+					: Value extends PlainSchematic
+						? Infer<Value>
+						: never;
 
 /**
  * Extracts keys from a {@link Schematic} whose entries are required _(i.e., `$required` is not `false`)_
@@ -85,8 +86,6 @@ export type InferSchemaEntry<Value> = Value extends (infer Item)[]
 /**
  * Maps a single top-level schema entry to its TypeScript type
  *
- * Resolves, in order: {@link Constructor}s, {@link Schema} instances, {@link SchemaProperty} objects, {@link PlainSchematic} objects, and {@link ValueName} values
- *
  * @template Value single schema entry
  */
 export type InferSchemaEntryValue<Value> =
@@ -98,6 +97,25 @@ export type InferSchemaEntryValue<Value> =
 				? InferPropertyType<Value['$type']>
 				: Value extends PlainSchematic
 					? Infer<Value & Schematic>
-					: Value extends ValueName
-						? Values[Value & ValueName]
-						: never;
+					: Value extends Validator<infer Type>
+						? Type
+						: Value extends ValueType
+							? Values[Value & ValueType]
+							: never;
+
+/**
+ * Infers the TypeScript type from a {@link Validator} definition
+ *
+ * @template Value Validator to infer type from
+ */
+export type InferValidatorValue<Value> = Value extends (infer Item)[]
+	? InferValidatorValue<Item>
+	: Value extends Constructor<infer Instance>
+		? Instance
+		: Value extends ((value: unknown) => value is infer Type)
+			? Type
+			: Value extends (value: unknown) => boolean
+				? 'xyz'
+				: Value extends ValueType
+					? Values[Value & ValueType]
+					: never;

package/src/models/misc.model.ts

@@ -22,22 +22,22 @@ export type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = [
 	: Seen;
 
 /**
- * Recursively extracts {@link ValueName} strings from a type, unwrapping arrays and readonly arrays
+ * Recursively extracts {@link ValueType} strings from a type, unwrapping arrays and readonly arrays
  *
- * @template Value Type to extract value names from
+ * @template Value Type to extract value types from
  *
  * @example
  * ```ts
- * // ExtractValueNames<'string'>         => 'string'
- * // ExtractValueNames<['string', 'number']> => 'string' | 'number'
+ * // ExtractValueTypes<'string'>         => 'string'
+ * // ExtractValueTypes<['string', 'number']> => 'string' | 'number'
  * ```
  */
-export type ExtractValueNames<Value> = Value extends ValueName
+export type ExtractValueTypes<Value> = Value extends ValueType
 	? Value
 	: Value extends (infer Item)[]
-		? ExtractValueNames<Item>
+		? ExtractValueTypes<Item>
 		: Value extends readonly (infer Item)[]
-			? ExtractValueNames<Item>
+			? ExtractValueTypes<Item>
 			: never;
 
 /**
@@ -183,10 +183,10 @@ export type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
 /**
  * A union of valid type name strings, e.g. `'string'`, `'number'`, `'date'`
  */
-export type ValueName = keyof Values;
+export type ValueType = keyof Values;
 
 /**
- * Maps {@link ValueName} strings to their TypeScript equivalents
+ * Maps {@link ValueType} strings to their TypeScript equivalents
  */
 export type Values = {
 	array: unknown[];