@oscarpalmer/jhunal 0.25.0 → 0.27.0

package/dist/constants.d.mts

@@ -1,5 +1,5 @@
 import { ReportingType } from "./models/validation.model.mjs";
-import { ValueName, Values } from "./models/misc.model.mjs";
+import { ValueType, Values } from "./models/misc.model.mjs";
 
 //#region src/constants.d.ts
 declare const COMMA = ", ";
@@ -12,20 +12,25 @@ declare const NAME_SCHEMA = "Schema";
 declare const NAME_SCHEMA_PREFIXED = "a Schema";
 declare const NAME_ERROR_SCHEMATIC = "SchematicError";
 declare const NAME_ERROR_VALIDATION = "ValidationError";
+declare const NAME_ERROR_VALIDATOR = "ValidatorError";
 declare const PROPERTY_DEFAULT = "$default";
 declare const PROPERTY_REQUIRED = "$required";
 declare const PROPERTY_SCHEMA = "$schema";
 declare const PROPERTY_TYPE = "$type";
+declare const PROPERTY_VALIDATOR = "$validator";
 declare const PROPERTY_VALIDATORS = "$validators";
 declare const VALIDATION_MESSAGE_INVALID_INPUT = "Expected an object as input but received <>";
 declare const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
-declare const VALIDATION_MESSAGE_INVALID_TYPE = "Expected <> for '<>' but received <>";
-declare const VALIDATION_MESSAGE_INVALID_VALUE = "Value does not satisfy validator for '<>' and type '<>'";
-declare const VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX = " at index <>";
+declare const VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE = "Expected <> for '<>' but received <>";
+declare const VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR = "Value does not satisfy validator for '<>' and type '<>'";
+declare const VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX = " at index <>";
+declare const VALIDATION_MESSAGE_INVALID_VALUE_TYPE = "Expected <> but received <>";
+declare const VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR = "Value does not satisfy validator for type '<>'";
 declare const VALIDATION_MESSAGE_UNKNOWN_KEYS = "Found keys that are not defined in the schema: <>";
 declare const REPORTING_ALL: ReportingType;
 declare const REPORTING_FIRST: ReportingType;
 declare const REPORTING_NONE: ReportingType;
+declare const REPORTING_RESULT: ReportingType;
 declare const REPORTING_THROW: ReportingType;
 declare const REPORTING_TYPES: Set<ReportingType>;
 declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED = "'<>' has a default value but is not required";
@@ -47,7 +52,10 @@ declare const TYPE_NULL = "null";
 declare const TYPE_OBJECT = "object";
 declare const TYPE_UNDEFINED = "undefined";
 declare const VALIDATABLE_TYPES: Set<keyof Values>;
-declare const TYPE_ALL: Set<keyof Values>;
-declare const PREFIXED_TYPES: Record<ValueName, string>;
+declare const TYPES_ALL: Set<keyof Values>;
+declare const TYPES_PREFIXED: Record<ValueType, string>;
+declare const VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE = "Validator must not be 'null' or 'undefined'";
+declare const VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE = "Validator must be of a valid type";
+declare const VALIDATOR_MESSAGE_INVALID_VALIDATOR = "Validator must be a function or an array of functions";
 //#endregion
-export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMA, NAME_SCHEMA_PREFIXED, PREFIXED_TYPES, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMA, PROPERTY_TYPE, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS };
+export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_ERROR_VALIDATOR, NAME_SCHEMA, NAME_SCHEMA_PREFIXED, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMA, PROPERTY_TYPE, PROPERTY_VALIDATOR, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_RESULT, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPES_ALL, TYPES_PREFIXED, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE, VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX, VALIDATION_MESSAGE_INVALID_VALUE_TYPE, VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR, VALIDATION_MESSAGE_UNKNOWN_KEYS, VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE, VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE, VALIDATOR_MESSAGE_INVALID_VALIDATOR };

package/dist/constants.mjs

@@ -9,25 +9,31 @@ const NAME_SCHEMA = "Schema";
 const NAME_SCHEMA_PREFIXED = "a Schema";
 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_ALL = "all";
 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";
@@ -59,12 +65,12 @@ const VALIDATABLE_TYPES = new Set([
 	"string",
 	"symbol"
 ]);
-const TYPE_ALL = new Set([
+const TYPES_ALL = new Set([
 	...VALIDATABLE_TYPES,
 	TYPE_NULL,
 	TYPE_UNDEFINED
 ]);
-const PREFIXED_TYPES = {
+const TYPES_PREFIXED = {
 	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
 	bigint: `a bigint`,
 	boolean: `a boolean`,
@@ -77,5 +83,8 @@ 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
-export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMA, NAME_SCHEMA_PREFIXED, PREFIXED_TYPES, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMA, PROPERTY_TYPE, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS };
+export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_ERROR_VALIDATOR, NAME_SCHEMA, NAME_SCHEMA_PREFIXED, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMA, PROPERTY_TYPE, PROPERTY_VALIDATOR, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_RESULT, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPES_ALL, TYPES_PREFIXED, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE, VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX, VALIDATION_MESSAGE_INVALID_VALUE_TYPE, VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR, VALIDATION_MESSAGE_UNKNOWN_KEYS, VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE, VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE, VALIDATOR_MESSAGE_INVALID_VALIDATOR };

package/dist/handler/base.handler.d.mts

@@ -0,0 +1,6 @@
+import { ValidationHandler } from "../models/validation.model.mjs";
+
+//#region src/handler/base.handler.d.ts
+declare function getBaseHandler(handlers: ValidationHandler[]): ValidationHandler;
+//#endregion
+export { getBaseHandler };

package/dist/{validator/base.validator.mjs → handler/base.handler.mjs}

@@ -1,12 +1,12 @@
-//#region src/validator/base.validator.ts
-function getBaseValidator(validators) {
-	const { length } = validators;
+//#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 = validators[index](input, parameters, get);
+			const result = handlers[index](input, parameters, get);
 			parameters.information = previousInformation;
 			if (result === true) return true;
 			parameters.information?.push(...result);
@@ -16,4 +16,4 @@ function getBaseValidator(validators) {
 	};
 }
 //#endregion
-export { getBaseValidator };
+export { getBaseHandler };

package/dist/handler/function.handler.d.mts

@@ -0,0 +1,6 @@
+import { ValidationHandler } from "../models/validation.model.mjs";
+
+//#region src/handler/function.handler.d.ts
+declare function getFunctionHandler(fn: Function): ValidationHandler;
+//#endregion
+export { getFunctionHandler };

package/dist/handler/function.handler.mjs

@@ -0,0 +1,9 @@
+import { instanceOf } from "../helpers/misc.helper.mjs";
+import { isConstructor } from "@oscarpalmer/atoms/is";
+//#region src/handler/function.handler.ts
+function getFunctionHandler(fn) {
+	const handler = isConstructor(fn) ? instanceOf(fn) : fn;
+	return (input) => handler(input) ? true : [];
+}
+//#endregion
+export { getFunctionHandler };

package/dist/handler/object.handler.d.mts

@@ -0,0 +1,7 @@
+import { PropertyValidationKey, ValidationHandler } from "../models/validation.model.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/handler/object.handler.d.ts
+declare function getObjectHandler(original: PlainObject, origin?: PropertyValidationKey, fromType?: boolean): ValidationHandler;
+//#endregion
+export { getObjectHandler };

package/dist/handler/object.handler.mjs

@@ -0,0 +1,130 @@
+import { PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY } from "../constants.mjs";
+import { SchematicError, ValidationError } from "../models/validation.model.mjs";
+import { report } from "../helpers/report.helper.mjs";
+import { getValueHandler } from "./value.handler.mjs";
+import { getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputTypeMessage, getUnknownKeysMessage } from "../helpers/message.helper.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { clone } from "@oscarpalmer/atoms/value/clone";
+//#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 getObjectHandler(original, origin, fromType) {
+	const keys = Object.keys(original);
+	const keysLength = keys.length;
+	if (keysLength === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		if (property != null) throw new SchematicError(getDisallowedMessage(origin.full, property));
+	}
+	const set = /* @__PURE__ */ new Set();
+	const items = [];
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+		const { defaults, handler, key: fullKey, required, types } = getValueHandler({ value: original[key] }, {
+			key,
+			origin
+		});
+		items.push({
+			defaults,
+			handler,
+			required,
+			types,
+			key: fullKey
+		});
+		set.add(key);
+	}
+	const validatorsLength = items.length;
+	return (input, parameters, get) => {
+		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,
+					message: getUnknownKeysMessage(unknownKeys),
+					value: input
+				};
+				if (parameters.reporting.throw) throw new ValidationError([information]);
+				parameters.information?.push(information);
+				return [information];
+			}
+		}
+		const getAndClone = get && parameters.clone;
+		const allInformation = [];
+		const output = {};
+		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
+			const { defaults, handler, key, required, types } = items[validatorIndex];
+			const value = input[key.short];
+			if (value === void 0) {
+				if (required) {
+					if (get && defaults != null) {
+						const defaultValue = clone(defaults.value);
+						if (parameters.clone) output[key.short] = defaultValue;
+						else input[key.short] = defaultValue;
+						continue;
+					}
+					if (parameters.reporting.none) return [];
+					const reported = report({
+						key,
+						value,
+						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 = handler(value, parameters, get);
+			parameters.output = previousOutput;
+			if (result === true) {
+				if (getAndClone && !isPlainObject(value)) output[key.short] = clone(value);
+				continue;
+			}
+			if (parameters.reporting.none) return [];
+			const reported = report({
+				key,
+				value,
+				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 (getAndClone) if (origin == null) parameters.output = output;
+		else parameters.output[origin.short] = output;
+		return allInformation.length === 0 ? true : allInformation;
+	};
+}
+//#endregion
+export { getObjectHandler };

package/dist/handler/schema.handler.d.mts

@@ -0,0 +1,7 @@
+import { ValidationHandler } from "../models/validation.model.mjs";
+import { Schema } from "../schema.mjs";
+
+//#region src/handler/schema.handler.d.ts
+declare function getSchemaHandler(schematic: Schema<unknown>): ValidationHandler;
+//#endregion
+export { getSchemaHandler };

package/dist/handler/schema.handler.mjs

@@ -0,0 +1,16 @@
+import { schemaHandlers } from "../schema.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#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
+export { getSchemaHandler };

package/dist/handler/type.handler.d.mts

@@ -0,0 +1,9 @@
+import { PropertyValidationKey, ValidationHandler, ValidationHandlerType, Validators } from "../models/validation.model.mjs";
+import { ValueType } from "../models/misc.model.mjs";
+
+//#region src/handler/type.handler.d.ts
+declare function getTypeHandler(type: ValueType, validators: Validators, key?: PropertyValidationKey): ValidationHandler;
+declare function getTypeValidators(types: ValidationHandlerType[], original: unknown): Validators;
+declare function getValidators(original: unknown, allowed: boolean, prefix?: string): Validators;
+//#endregion
+export { getTypeHandler, getTypeValidators, getValidators };

package/dist/handler/type.handler.mjs

@@ -0,0 +1,71 @@
+import { PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPES_ALL, VALIDATOR_MESSAGE_INVALID_VALIDATOR } from "../constants.mjs";
+import { SchematicError, ValidatorError } from "../models/validation.model.mjs";
+import { getInputPropertyValidatorMessage, getInputValueValidatorMessage } from "../helpers/message.helper.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#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
+export { getTypeHandler, getTypeValidators, getValidators };

package/dist/handler/validator.handler.d.mts

@@ -0,0 +1,10 @@
+import { ValidationHandler, ValidationHandlerType } from "../models/validation.model.mjs";
+
+//#region src/handler/validator.handler.d.ts
+type ValidatorHandler = {
+  handler: ValidationHandler;
+  types: ValidationHandlerType[];
+};
+declare function getValidatorHandler(value: unknown, validators?: unknown): ValidatorHandler;
+//#endregion
+export { getValidatorHandler };

package/dist/handler/validator.handler.mjs

@@ -0,0 +1,34 @@
+import { report } from "../helpers/report.helper.mjs";
+import { getValueHandler } from "./value.handler.mjs";
+import { getInputValueTypeMessage } from "../helpers/message.helper.mjs";
+//#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
+export { getValidatorHandler };

package/dist/handler/value.handler.d.mts

@@ -0,0 +1,14 @@
+import { PropertyValidationKey, ValidationHandlerItem } from "../models/validation.model.mjs";
+
+//#region src/handler/value.handler.d.ts
+type Input = {
+  validators?: unknown;
+  value: unknown;
+};
+type PropertyInformation = {
+  key: string;
+  origin?: PropertyValidationKey;
+};
+declare function getValueHandler(input: Input, property?: PropertyInformation): ValidationHandlerItem;
+//#endregion
+export { getValueHandler };

package/dist/handler/value.handler.mjs

@@ -0,0 +1,98 @@
+import { PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPES_ALL, VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE, VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE } from "../constants.mjs";
+import { getParameters, isSchema, isValidator } from "../helpers/misc.helper.mjs";
+import { SchematicError, ValidatorError } from "../models/validation.model.mjs";
+import { getBaseHandler } from "./base.handler.mjs";
+import { getFunctionHandler } from "./function.handler.mjs";
+import { getSchemaHandler } from "./schema.handler.mjs";
+import { getTypeHandler, getTypeValidators, getValidators } from "./type.handler.mjs";
+import { validatorHandlers } from "../validator.mjs";
+import { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage } from "../helpers/message.helper.mjs";
+import { getObjectHandler } from "./object.handler.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms/string";
+//#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
+export { getValueHandler };

package/dist/helpers/message.helper.d.mts

@@ -1,17 +1,19 @@
-import { ValidatorType } from "../models/validation.model.mjs";
-import { ValueName } from "../models/misc.model.mjs";
+import { ValidationHandlerType } from "../models/validation.model.mjs";
+import { ValueType } from "../models/misc.model.mjs";
 
 //#region src/helpers/message.helper.d.ts
 declare function getDefaultRequiredMessage(key: string): string;
-declare function getDefaultTypeMessage(key: string, types: ValidatorType[]): string;
+declare function getDefaultTypeMessage(key: string, types: ValidationHandlerType[]): string;
 declare function getDisallowedMessage(key: string, property: string): string;
 declare function getInputTypeMessage(actual: unknown): string;
-declare function getInputPropertyMissingMessage(key: string, types: ValidatorType[]): string;
-declare function getInputPropertyTypeMessage(key: string, types: ValidatorType[], actual: unknown): string;
-declare function getInputPropertyValidatorMessage(key: string, type: ValueName, index: number, length: number): string;
+declare function getInputPropertyMissingMessage(key: string, types: ValidationHandlerType[]): string;
+declare function getInputPropertyTypeMessage(key: string, types: ValidationHandlerType[], actual: unknown): string;
+declare function getInputPropertyValidatorMessage(key: string, type: ValueType, index: number, length: number): string;
+declare function getInputValueTypeMessage(types: ValidationHandlerType[], actual: unknown): string;
+declare function getInputValueValidatorMessage(type: ValueType, index: number, length: number): string;
 declare function getSchematicPropertyNullableMessage(key: string): string;
 declare function getSchematicPropertyTypeMessage(key: string): string;
 declare function getRequiredMessage(key: string): string;
 declare function getUnknownKeysMessage(keys: string[]): string;
 //#endregion
-export { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };
+export { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getInputValueTypeMessage, getInputValueValidatorMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };