@oscarpalmer/jhunal 0.25.0 → 0.27.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
-import { error, ok } from "@oscarpalmer/atoms/result/misc";
 import { clone } from "@oscarpalmer/atoms/value/clone";
+import { error, ok } from "@oscarpalmer/atoms/result/misc";
 //#region src/constants.ts
 const CONJUNCTION_OR = " or ";
 const CONJUNCTION_OR_COMMA = ", or ";
@@ -10,24 +10,30 @@ const CONJUNCTION_AND_COMMA = ", and ";
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 const NAME_ERROR_SCHEMATIC = "SchematicError";
 const NAME_ERROR_VALIDATION = "ValidationError";
+const NAME_ERROR_VALIDATOR = "ValidatorError";
 const PROPERTY_DEFAULT = "$default";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_SCHEMA = "$schema";
 const PROPERTY_TYPE = "$type";
+const PROPERTY_VALIDATOR = "$validator";
 const PROPERTY_VALIDATORS = "$validators";
 const VALIDATION_MESSAGE_INVALID_INPUT = "Expected an object as input but received <>";
 const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
-const VALIDATION_MESSAGE_INVALID_TYPE = "Expected <> for '<>' but received <>";
-const VALIDATION_MESSAGE_INVALID_VALUE = "Value does not satisfy validator for '<>' and type '<>'";
-const VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX = " at index <>";
+const VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE = "Expected <> for '<>' but received <>";
+const VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR = "Value does not satisfy validator for '<>' and type '<>'";
+const VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX = " at index <>";
+const VALIDATION_MESSAGE_INVALID_VALUE_TYPE = "Expected <> but received <>";
+const VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR = "Value does not satisfy validator for type '<>'";
 const VALIDATION_MESSAGE_UNKNOWN_KEYS = "Found keys that are not defined in the schema: <>";
 const REPORTING_FIRST = "first";
 const REPORTING_NONE = "none";
+const REPORTING_RESULT = "result";
 const REPORTING_THROW = "throw";
 const REPORTING_TYPES = new Set([
 	"all",
 	REPORTING_FIRST,
 	REPORTING_NONE,
+	REPORTING_RESULT,
 	REPORTING_THROW
 ]);
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED = "'<>' has a default value but is not required";
@@ -47,7 +53,7 @@ const TYPE_FUNCTION_RESULT = "a validated value";
 const TYPE_NULL = "null";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
+const TYPES_ALL = new Set([
 	...new Set([
 		TYPE_ARRAY,
 		"bigint",
@@ -62,7 +68,7 @@ const TYPE_ALL = new Set([
 	TYPE_NULL,
 	TYPE_UNDEFINED
 ]);
-const PREFIXED_TYPES = {
+const TYPES_PREFIXED = {
 	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
 	bigint: `a bigint`,
 	boolean: `a boolean`,
@@ -75,6 +81,9 @@ const PREFIXED_TYPES = {
 	[TYPE_OBJECT]: `an ${TYPE_OBJECT}`,
 	[TYPE_UNDEFINED]: TYPE_UNDEFINED
 };
+const VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE = "Validator must not be 'null' or 'undefined'";
+const VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE = "Validator must be of a valid type";
+const VALIDATOR_MESSAGE_INVALID_VALIDATOR = "Validator must be a function or an array of functions";
 //#endregion
 //#region src/helpers/misc.helper.ts
 function getParameters(input) {
@@ -103,7 +112,7 @@ function getReporting(value) {
 	return {
 		type,
 		["all"]: type === "all",
-		[REPORTING_FIRST]: type === REPORTING_FIRST,
+		[REPORTING_FIRST]: type === "first" || type === "result",
 		[REPORTING_NONE]: type === REPORTING_NONE,
 		[REPORTING_THROW]: type === REPORTING_THROW
 	};
@@ -121,13 +130,21 @@ function instanceOf(constructor) {
 	};
 }
 /**
-* 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
 */
 function isSchema(value) {
 	return typeof value === "object" && value !== null && "$schema" in value && value["$schema"] === true;
 }
+/**
+* Is the value a validator?
+* @param value Value to check
+* @returns `true` if the value is a validator, `false` otherwise
+*/
+function isValidator(value) {
+	return typeof value === "object" && value !== null && "$validator" in value && value["$validator"] === true;
+}
 //#endregion
 //#region src/models/validation.model.ts
 /**
@@ -149,6 +166,285 @@ var ValidationError = class extends Error {
 		this.name = NAME_ERROR_VALIDATION;
 	}
 };
+/**
+* Thrown when a validator definition is invalid
+*/
+var ValidatorError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = NAME_ERROR_VALIDATOR;
+	}
+};
+//#endregion
+//#region src/helpers/report.helper.ts
+function report(parameters, getReports) {
+	const { information, message, original } = parameters;
+	let reported;
+	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;
+}
+//#endregion
+//#region src/handler/base.handler.ts
+function getBaseHandler(handlers) {
+	const { length } = handlers;
+	return (input, parameters, get) => {
+		const allInformation = [];
+		for (let index = 0; index < length; index += 1) {
+			const previousInformation = parameters.information;
+			parameters.information = [];
+			const result = handlers[index](input, parameters, get);
+			parameters.information = previousInformation;
+			if (result === true) return true;
+			parameters.information?.push(...result);
+			allInformation.push(...result);
+		}
+		return allInformation;
+	};
+}
+//#endregion
+//#region src/handler/function.handler.ts
+function getFunctionHandler(fn) {
+	const handler = isConstructor(fn) ? instanceOf(fn) : fn;
+	return (input) => handler(input) ? true : [];
+}
+//#endregion
+//#region src/handler/schema.handler.ts
+function getSchemaHandler(schematic) {
+	const handler = schemaHandlers.get(schematic);
+	return (input, parameters, get) => {
+		let result;
+		if (isPlainObject(input)) result = handler(input, parameters, get);
+		else result = [];
+		if (result === true) return result;
+		parameters.information?.push(...result);
+		return result;
+	};
+}
+//#endregion
+//#region src/handler/type.handler.ts
+function getTypeHandler(type, validators, key) {
+	const validator = typeValidators[type];
+	const typedValidators = validators[type] ?? [];
+	const { length } = typedValidators;
+	return (input, parameters) => {
+		if (!validator(input)) return [];
+		for (let index = 0; index < length; index += 1) {
+			const validator = typedValidators[index];
+			if (validator(input) === true) continue;
+			const information = {
+				validator,
+				message: key == null ? getInputValueValidatorMessage(type, index, length) : getInputPropertyValidatorMessage(key.full, type, index, length),
+				value: input
+			};
+			if (key != null) information.key = key;
+			parameters.information?.push(information);
+			return parameters.reporting.none ? [] : [information];
+		}
+		return true;
+	};
+}
+function getTypeValidators(types, original) {
+	const values = types.filter((type) => TYPES_ALL.has(type));
+	const { length } = values;
+	const validators = {};
+	if (original == null || length === 0) return validators;
+	if (typeof original === "function" || Array.isArray(original)) {
+		if (length > 1) throw new ValidatorError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
+		return getValidators({ [values[0]]: original }, true);
+	}
+	return getValidators(original, true);
+}
+function getValidators(original, allowed, prefix) {
+	const validators = {};
+	if (original == null) return validators;
+	if (!allowed) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", PROPERTY_VALIDATORS));
+	if (!isPlainObject(original)) throw new SchematicError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
+	const keys = Object.keys(original);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!TYPES_ALL.has(key)) throw new SchematicError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		const value = original[key];
+		validators[key] = (Array.isArray(value) ? value : [value]).map((item) => {
+			if (typeof item !== "function") if (prefix == null) throw new ValidatorError(VALIDATOR_MESSAGE_INVALID_VALIDATOR);
+			else throw new SchematicError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key).replace("<>", prefix));
+			return item;
+		});
+	}
+	return validators;
+}
+const typeValidators = {
+	array: Array.isArray,
+	bigint: (value) => typeof value === "bigint",
+	boolean: (value) => typeof value === "boolean",
+	date: (value) => value instanceof Date,
+	function: (value) => typeof value === "function",
+	null: (value) => value === null,
+	number: (value) => typeof value === "number",
+	object: (value) => typeof value === "object" && value !== null,
+	string: (value) => typeof value === "string",
+	symbol: (value) => typeof value === "symbol",
+	undefined: (value) => value === void 0
+};
+//#endregion
+//#region src/handler/value.handler.ts
+function getDefaults(obj, key, allowed) {
+	if (!("$default" in obj)) return;
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
+	return { value: obj[PROPERTY_DEFAULT] };
+}
+function getRequired(obj, key, allowed) {
+	if (!("$required" in obj)) return;
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
+	return obj[PROPERTY_REQUIRED];
+}
+function getValueHandler(input, property) {
+	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 = {
+		full: prefixedKey,
+		short: property?.key ?? ""
+	};
+	let required = true;
+	let typed = false;
+	let validators = {};
+	let defaults;
+	let types;
+	const handlers = [];
+	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;
+		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):
+				handler = getTypeHandler(type, validators, isProperty ? fullKey : void 0);
+				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("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
+	};
+}
+//#endregion
+//#region src/handler/validator.handler.ts
+function getValidatorHandler(value, validators) {
+	const { handler, types } = getValueHandler({
+		validators,
+		value
+	});
+	const validator = (input, parameters, get) => {
+		const result = handler(input, parameters, get);
+		if (result === true) return true;
+		if (parameters.key != null) return [];
+		return report({
+			value: input,
+			extract: false,
+			information: {
+				all: parameters.information ?? [],
+				existing: result.length > 0 ? result : void 0
+			},
+			message: {
+				arguments: [types, input],
+				callback: getInputValueTypeMessage
+			},
+			original: parameters
+		});
+	};
+	return {
+		types,
+		handler: validator
+	};
+}
+//#endregion
+//#region src/helpers/result.helper.ts
+function getResult(handler, value, options) {
+	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]);
+}
+function isResult(handler, value, options) {
+	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]);
+}
+//#endregion
+//#region src/validator.ts
+var Validator = class {
+	#handler;
+	constructor(handler, types) {
+		Object.defineProperty(this, PROPERTY_VALIDATOR, { value: true });
+		this.#handler = handler;
+		validatorHandlers.set(this, handler);
+		validatorTypes.set(this, types);
+	}
+	is(value, options) {
+		return isResult(this.#handler, value, options);
+	}
+};
+function validator(value, validators) {
+	if (value instanceof Validator) return value;
+	const { handler, types } = getValidatorHandler(value, validators);
+	return new Validator(handler, types);
+}
+const validatorHandlers = /* @__PURE__ */ new WeakMap();
+const validatorTypes = /* @__PURE__ */ new WeakMap();
 //#endregion
 //#region src/helpers/message.helper.ts
 function getDefaultRequiredMessage(key) {
@@ -173,15 +469,25 @@ function getInputPropertyMissingMessage(key, types) {
 	return message;
 }
 function getInputPropertyTypeMessage(key, types, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
+	let message = VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE.replace("<>", renderTypes(types));
 	message = message.replace("<>", key);
 	message = message.replace("<>", getValueType(actual));
 	return message;
 }
 function getInputPropertyValidatorMessage(key, type, index, length) {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
+	let message = VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR.replace("<>", key);
 	message = message.replace("<>", type);
-	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
+	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX.replace("<>", String(index));
+	return message;
+}
+function getInputValueTypeMessage(types, actual) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE_TYPE.replace("<>", renderTypes(types));
+	message = message.replace("<>", getValueType(actual));
+	return message;
+}
+function getInputValueValidatorMessage(type, index, length) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR.replace("<>", type);
+	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX.replace("<>", String(index));
 	return message;
 }
 function getSchematicPropertyNullableMessage(key) {
@@ -192,18 +498,19 @@ function getSchematicPropertyTypeMessage(key) {
 }
 function getPropertyType(type) {
 	switch (true) {
-		case typeof type === "function": return isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT;
-		case TYPE_ALL.has(type): return PREFIXED_TYPES[type];
-		default: return PREFIXED_TYPES[TYPE_OBJECT];
+		case typeof type === "function": return [isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT];
+		case isValidator(type): return validatorTypes.get(type).flatMap(getPropertyType);
+		case TYPES_ALL.has(type): return [TYPES_PREFIXED[type]];
+		default: return [TYPES_PREFIXED[TYPE_OBJECT]];
 	}
 }
 function getValueType(value) {
 	const valueType = typeof value;
 	switch (true) {
 		case value === null: return TYPE_NULL;
-		case Array.isArray(value): return PREFIXED_TYPES[TYPE_ARRAY];
-		case isPlainObject(value): return PREFIXED_TYPES[TYPE_OBJECT];
-		case valueType !== TYPE_OBJECT: return PREFIXED_TYPES[valueType];
+		case Array.isArray(value): return TYPES_PREFIXED[TYPE_ARRAY];
+		case isPlainObject(value): return TYPES_PREFIXED[TYPE_OBJECT];
+		case valueType !== TYPE_OBJECT: return TYPES_PREFIXED[valueType];
 		default: return value.constructor.name;
 	}
 }
@@ -224,11 +531,16 @@ function renderParts(parts, delimiterShort, delimiterLong) {
 function renderTypes(types) {
 	const unique = /* @__PURE__ */ new Set();
 	const parts = [];
-	for (let index = 0; index < types.length; index += 1) {
-		const rendered = getPropertyType(types[index]);
-		if (unique.has(rendered)) continue;
-		unique.add(rendered);
-		parts.push(rendered);
+	const typesLength = types.length;
+	for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+		const properties = getPropertyType(types[typeIndex]);
+		const propertiesLength = properties.length;
+		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);
 }
@@ -239,112 +551,14 @@ function getUnknownKeysMessage(keys) {
 	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
 }
 //#endregion
-//#region src/validator/base.validator.ts
-function getBaseValidator(validators) {
-	const { length } = validators;
-	return (input, parameters, get) => {
-		const allInformation = [];
-		for (let index = 0; index < length; index += 1) {
-			const previousInformation = parameters.information;
-			parameters.information = [];
-			const result = validators[index](input, parameters, get);
-			parameters.information = previousInformation;
-			if (result === true) return true;
-			parameters.information?.push(...result);
-			allInformation.push(...result);
-		}
-		return allInformation;
-	};
-}
-//#endregion
-//#region src/validator/function.validator.ts
-function getFunctionValidator(fn) {
-	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
-	return (input) => validator(input) ? true : [];
-}
-//#endregion
-//#region src/validator/named.handler.ts
-function getNamedHandlers(original, prefix, allowed) {
-	const handlers = {};
-	if (original == null) return handlers;
-	if (!allowed) throw new TypeError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", PROPERTY_VALIDATORS));
-	if (!isPlainObject(original)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
-	const keys = Object.keys(original);
-	const { length } = keys;
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		if (!TYPE_ALL.has(key)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
-		const value = original[key];
-		handlers[key] = (Array.isArray(value) ? value : [value]).map((item) => {
-			if (typeof item !== "function") throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key).replace("<>", prefix));
-			return item;
-		});
-	}
-	return handlers;
-}
-//#endregion
-//#region src/validator/named.validator.ts
-function getNamedValidator(key, name, handlers) {
-	const validator = namedValidators[name];
-	const named = handlers[name] ?? [];
-	const { length } = named;
-	return (input, parameters) => {
-		if (!validator(input)) return [];
-		for (let index = 0; index < length; index += 1) {
-			const handler = named[index];
-			if (handler(input) === true) continue;
-			const information = {
-				key,
-				validator,
-				message: getInputPropertyValidatorMessage(key.full, name, index, length),
-				value: input
-			};
-			parameters.information?.push(information);
-			return parameters.reporting.none ? [] : [information];
-		}
-		return true;
-	};
-}
-const namedValidators = {
-	array: Array.isArray,
-	bigint: (value) => typeof value === "bigint",
-	boolean: (value) => typeof value === "boolean",
-	date: (value) => value instanceof Date,
-	function: (value) => typeof value === "function",
-	null: (value) => value === null,
-	number: (value) => typeof value === "number",
-	object: (value) => typeof value === "object" && value !== null,
-	string: (value) => typeof value === "string",
-	symbol: (value) => typeof value === "symbol",
-	undefined: (value) => value === void 0
-};
-//#endregion
-//#region src/validator/schematic.validator.ts
-function getSchemaValidator(schematic) {
-	const validator = schemaValidators.get(schematic);
-	return (input, parameters, get) => {
-		let result;
-		if (isPlainObject(input)) result = validator(input, parameters, get);
-		else result = [];
-		if (result === true) return result;
-		parameters.information?.push(...result);
-		return result;
-	};
-}
-//#endregion
-//#region src/validator/object.validator.ts
-function getDefaults(obj, key, allowed) {
-	if (!("$default" in obj)) return;
-	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
-	return { value: obj[PROPERTY_DEFAULT] };
-}
+//#region src/handler/object.handler.ts
 function getDisallowedProperty(obj) {
 	if ("$default" in obj) return PROPERTY_DEFAULT;
 	if ("$required" in obj) return PROPERTY_REQUIRED;
 	if ("$type" in obj) return PROPERTY_TYPE;
 	if ("$validators" in obj) return PROPERTY_VALIDATORS;
 }
-function getObjectValidator(original, origin, fromType) {
+function getObjectHandler(original, origin, fromType) {
 	const keys = Object.keys(original);
 	const keysLength = keys.length;
 	if (keysLength === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
@@ -356,86 +570,34 @@ function getObjectValidator(original, origin, fromType) {
 	const items = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
-		const value = original[key];
-		if (value == null) throw new SchematicError(getSchematicPropertyNullableMessage(join([origin?.full, key], ".")));
-		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
-		const fullKey = {
-			full: prefixedKey,
-			short: key
-		};
-		let handlers = {};
-		let required = true;
-		let typed = false;
-		let defaults;
-		let types;
-		const validators = [];
-		if (isPlainObject(value)) {
-			typed = PROPERTY_TYPE in value;
-			const type = typed ? value[PROPERTY_TYPE] : value;
-			defaults = getDefaults(value, prefixedKey, typed);
-			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey, typed);
-			required = getRequired(value, prefixedKey, typed) ?? required;
-			types = Array.isArray(type) ? type : [type];
-		} else types = Array.isArray(value) ? value : [value];
-		if (types.length === 0) throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
-		const typesLength = types.length;
-		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			const type = types[typeIndex];
-			let validator;
-			switch (true) {
-				case typeof type === "function":
-					validator = getFunctionValidator(type);
-					break;
-				case isPlainObject(type):
-					validator = getObjectValidator(type, fullKey, typed);
-					break;
-				case isSchema(type):
-					validator = getSchemaValidator(type);
-					break;
-				case TYPE_ALL.has(type):
-					validator = getNamedValidator(fullKey, type, handlers);
-					break;
-				default: throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
-			}
-			validators.push(validator);
-		}
-		required = required && !types.includes("undefined");
-		if (defaults != null && !required) throw new SchematicError(getDefaultRequiredMessage(prefixedKey));
-		const validator = getBaseValidator(validators);
-		if (defaults != null && Array.isArray(validator(defaults.value, getParameters(), false))) throw new SchematicError(getDefaultTypeMessage(prefixedKey, types));
+		const { defaults, handler, key: fullKey, required, types } = getValueHandler({ value: original[key] }, {
+			key,
+			origin
+		});
 		items.push({
 			defaults,
+			handler,
 			required,
 			types,
-			validator,
 			key: fullKey
 		});
 		set.add(key);
 	}
 	const validatorsLength = items.length;
 	return (input, parameters, get) => {
-		if (!isPlainObject(input)) {
-			if (origin != null) return [];
-			const information = {
-				key: {
-					full: "",
-					short: ""
-				},
-				value: input,
-				message: getInputTypeMessage(input)
-			};
-			if (parameters.reporting.throw) throw new ValidationError([information]);
-			parameters.information?.push(information);
-			return [information];
-		}
+		if (!isPlainObject(input)) return origin == null ? report({
+			message: {
+				arguments: [input],
+				callback: getInputTypeMessage
+			},
+			original: parameters,
+			value: input
+		}, true) : [];
 		if (parameters.strict) {
 			const unknownKeys = Object.keys(input).filter((key) => !set.has(key));
 			if (unknownKeys.length > 0) {
 				const information = {
-					key: origin ?? {
-						full: "",
-						short: ""
-					},
+					key: origin,
 					message: getUnknownKeysMessage(unknownKeys),
 					value: input
 				};
@@ -444,97 +606,96 @@ function getObjectValidator(original, origin, fromType) {
 				return [information];
 			}
 		}
+		const getAndClone = get && parameters.clone;
 		const allInformation = [];
 		const output = {};
 		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
-			const { defaults, key, required, types, validator } = items[validatorIndex];
+			const { defaults, handler, key, required, types } = items[validatorIndex];
 			const value = input[key.short];
 			if (value === void 0) {
 				if (required) {
 					if (get && defaults != null) {
-						output[key.short] = clone(defaults.value);
+						const defaultValue = clone(defaults.value);
+						if (parameters.clone) output[key.short] = defaultValue;
+						else input[key.short] = defaultValue;
 						continue;
 					}
 					if (parameters.reporting.none) return [];
-					const information = {
+					const reported = report({
 						key,
 						value,
-						message: getInputPropertyMissingMessage(key.full, types)
-					};
-					if (parameters.reporting.throw) throw new ValidationError([information]);
-					parameters.information?.push(information);
-					if (parameters.reporting.all) {
-						allInformation.push(information);
-						continue;
-					}
-					return [information];
+						information: { all: allInformation },
+						message: {
+							arguments: [key.full, types],
+							callback: getInputPropertyMissingMessage
+						},
+						original: parameters
+					});
+					if (reported == null) continue;
+					return reported;
 				}
 				continue;
 			}
 			const previousOutput = parameters.output;
+			parameters.key = key.full;
 			parameters.output = output;
-			const result = validator(value, parameters, get);
+			const result = handler(value, parameters, get);
 			parameters.output = previousOutput;
 			if (result === true) {
-				if (get && !isPlainObject(value)) output[key.short] = parameters.clone ? clone(value) : value;
+				if (getAndClone && !isPlainObject(value)) output[key.short] = clone(value);
 				continue;
 			}
 			if (parameters.reporting.none) return [];
-			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
+			const reported = report({
 				key,
 				value,
-				message: getInputPropertyTypeMessage(key.full, types, value)
-			}];
-			if (parameters.reporting.throw) throw new ValidationError(information);
-			if (parameters.reporting.all) {
-				allInformation.push(...information);
-				continue;
-			}
-			return information;
+				extract: false,
+				information: {
+					all: allInformation,
+					existing: typeof result !== "boolean" && result.length > 0 ? result : void 0
+				},
+				message: {
+					arguments: [
+						key.full,
+						types,
+						value
+					],
+					callback: getInputPropertyTypeMessage
+				},
+				original: parameters
+			});
+			if (reported == null) continue;
+			return reported;
 		}
-		if (get) if (origin == null) parameters.output = output;
+		if (getAndClone) if (origin == null) parameters.output = output;
 		else parameters.output[origin.short] = output;
 		return allInformation.length === 0 ? true : allInformation;
 	};
 }
-function getRequired(obj, key, allowed) {
-	if (!("$required" in obj)) return;
-	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
-	return obj[PROPERTY_REQUIRED];
-}
 //#endregion
 //#region src/schema.ts
 /**
 * A schema for validating objects
 */
 var Schema = class {
-	#validator;
+	#handler;
 	constructor(validator) {
 		Object.defineProperty(this, PROPERTY_SCHEMA, { value: true });
-		this.#validator = validator;
-		schemaValidators.set(this, validator);
+		this.#handler = validator;
+		schemaHandlers.set(this, validator);
 	}
 	get(value, options) {
-		const parameters = getParameters(options);
-		const result = this.#validator(value, parameters, true);
-		if (result === true) return parameters.reporting.none || parameters.reporting.throw ? parameters.output : ok(parameters.output);
-		if (parameters.reporting.none) return;
-		return error(parameters.reporting.all ? result : result[0]);
+		return getResult(this.#handler, value, options);
 	}
 	is(value, options) {
-		const parameters = getParameters(options);
-		const result = this.#validator(value, parameters, false);
-		if (result === true) return parameters.reporting.none || parameters.reporting.throw ? result : ok(result);
-		if (parameters.reporting.none) return false;
-		return error(parameters.reporting.all ? result : result[0]);
+		return isResult(this.#handler, value, options);
 	}
 };
 function schema(schema) {
 	if (isSchema(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schema(getObjectValidator(schema));
+	return new Schema(getObjectHandler(schema));
 }
-const schemaValidators = /* @__PURE__ */ new WeakMap();
+const schemaHandlers = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { SchematicError, ValidationError, instanceOf, isSchema, schema };
+export { SchematicError, ValidationError, instanceOf, isSchema, schema, validator };