@oscarpalmer/jhunal 0.22.0 → 0.23.0

package/dist/validator/base.validator.d.mts

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

package/dist/validator/base.validator.mjs

@@ -0,0 +1,19 @@
+//#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
+export { getBaseValidator };

package/dist/validator/function.validator.d.mts

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

package/dist/validator/function.validator.mjs

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

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

@@ -0,0 +1,6 @@
+import { NamedValidatorHandlers } from "../models/validation.model.mjs";
+
+//#region src/validator/named.handler.d.ts
+declare function getNamedHandlers(original: unknown, prefix: string): NamedValidatorHandlers;
+//#endregion
+export { getNamedHandlers };

package/dist/validator/named.handler.mjs

@@ -0,0 +1,22 @@
+import { SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "../constants.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/validator/named.handler.ts
+function getNamedHandlers(original, prefix) {
+	const handlers = {};
+	if (original == null) return handlers;
+	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
+export { getNamedHandlers };

package/dist/validator/named.validator.d.mts

@@ -0,0 +1,7 @@
+import { NamedValidatorHandlers, ValidationInformationKey, Validator } from "../models/validation.model.mjs";
+import { ValueName } from "../models/misc.model.mjs";
+
+//#region src/validator/named.validator.d.ts
+declare function getNamedValidator(key: ValidationInformationKey, name: ValueName, handlers: NamedValidatorHandlers): Validator;
+//#endregion
+export { getNamedValidator };

package/dist/validator/named.validator.mjs

@@ -0,0 +1,39 @@
+import "../constants.mjs";
+import { getInvalidValidatorMessage } from "../helpers/message.helper.mjs";
+//#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: getInvalidValidatorMessage(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
+export { getNamedValidator };

package/dist/validator/object.validator.d.mts

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

package/dist/{validation.mjs → validator/object.validator.mjs}

@@ -1,58 +1,21 @@
-import { PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, 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_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "./constants.mjs";
-import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage, instanceOf, isSchematic } from "./helpers.mjs";
-import { SchematicError, ValidationError } from "./models/validation.model.mjs";
-import { schematicValidator } from "./schematic.mjs";
-import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-import { join } from "@oscarpalmer/atoms";
+import { PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, 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, TYPE_ALL } from "../constants.mjs";
+import { isSchematic } from "../helpers/misc.helper.mjs";
+import { SchematicError, ValidationError } from "../models/validation.model.mjs";
+import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getUnknownKeysMessage } from "../helpers/message.helper.mjs";
+import { getBaseValidator } from "./base.validator.mjs";
+import { getFunctionValidator } from "./function.validator.mjs";
+import { getNamedHandlers } from "./named.handler.mjs";
+import { getNamedValidator } from "./named.validator.mjs";
+import { getSchematicValidator } from "./schematic.validator.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms/string";
 import { clone } from "@oscarpalmer/atoms/value/clone";
-//#region src/validation.ts
+//#region src/validator/object.validator.ts
 function getDisallowedProperty(obj) {
 	if ("$required" in obj) return PROPERTY_REQUIRED;
 	if ("$type" in obj) return PROPERTY_TYPE;
 	if ("$validators" in obj) return PROPERTY_VALIDATORS;
 }
-function getFunctionValidator(fn) {
-	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
-	return (input) => validator(input) === true;
-}
-function getNamedValidator(key, name, handlers) {
-	const validator = namedValidators[name];
-	const named = handlers[name] ?? [];
-	const { length } = named;
-	return (input, parameters) => {
-		if (!validator(input)) return false;
-		for (let index = 0; index < length; index += 1) {
-			const handler = named[index];
-			if (handler(input) === true) continue;
-			const information = {
-				key,
-				validator,
-				message: getInvalidValidatorMessage(key.full, name, index, length),
-				value: input
-			};
-			parameters.information?.push(information);
-			return parameters.reporting.none ? false : [information];
-		}
-		return true;
-	};
-}
-function getNamedHandlers(original, prefix) {
-	const handlers = {};
-	if (original == null) return handlers;
-	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;
-}
 function getObjectValidator(original, origin, fromType) {
 	const keys = Object.keys(original);
 	const keysLength = keys.length;
@@ -111,13 +74,13 @@ function getObjectValidator(original, origin, fromType) {
 			types,
 			key: fullKey,
 			required: required && !types.includes("undefined"),
-			validator: getValidator(validators)
+			validator: getBaseValidator(validators)
 		});
 	}
 	const validatorsLength = items.length;
 	return (input, parameters, get) => {
 		if (!isPlainObject(input)) {
-			if (origin != null) return false;
+			if (origin != null) return [];
 			const information = {
 				key: {
 					full: "",
@@ -128,7 +91,7 @@ function getObjectValidator(original, origin, fromType) {
 			};
 			if (parameters.reporting.throw) throw new ValidationError([information]);
 			parameters.information?.push(information);
-			return parameters.reporting.none ? false : [information];
+			return [information];
 		}
 		if (parameters.strict) {
 			const unknownKeys = Object.keys(input).filter((key) => !set.has(key));
@@ -143,7 +106,7 @@ function getObjectValidator(original, origin, fromType) {
 				};
 				if (parameters.reporting.throw) throw new ValidationError([information]);
 				parameters.information?.push(information);
-				return parameters.reporting.none ? false : [information];
+				return [information];
 			}
 		}
 		const allInformation = [];
@@ -153,7 +116,7 @@ function getObjectValidator(original, origin, fromType) {
 			const value = input[key.short];
 			if (value === void 0) {
 				if (required) {
-					if (parameters.reporting.none) return false;
+					if (parameters.reporting.none) return [];
 					const information = {
 						key,
 						value,
@@ -173,12 +136,11 @@ function getObjectValidator(original, origin, fromType) {
 			parameters.output = output;
 			const result = validator(value, parameters, get);
 			parameters.output = previousOutput;
-			if (result === false) continue;
 			if (result === true) {
-				if (get) output[key.short] = clone(value);
+				if (get && !isPlainObject(value)) output[key.short] = parameters.clone ? clone(value) : value;
 				continue;
 			}
-			if (parameters.reporting.none) return false;
+			if (parameters.reporting.none) return [];
 			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
 				key,
 				value,
@@ -193,7 +155,7 @@ function getObjectValidator(original, origin, fromType) {
 		}
 		if (get) if (origin == null) parameters.output = output;
 		else parameters.output[origin.short] = output;
-		return parameters.reporting.none || allInformation.length === 0 ? true : allInformation;
+		return allInformation.length === 0 ? true : allInformation;
 	};
 }
 function getRequired(key, obj) {
@@ -201,45 +163,5 @@ function getRequired(key, obj) {
 	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
 	return obj[PROPERTY_REQUIRED];
 }
-function getSchematicValidator(schematic) {
-	const validator = schematicValidator.get(schematic);
-	return (input, parameters, get) => {
-		let result = false;
-		if (isPlainObject(input)) result = validator(input, parameters, get);
-		if (typeof result === "boolean") return result;
-		parameters.information?.push(...result);
-		return result.length === 0 ? true : result;
-	};
-}
-function getValidator(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 === false) continue;
-			if (result === true) return true;
-			parameters.information?.push(...result);
-			allInformation.push(...result);
-		}
-		return allInformation;
-	};
-}
-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
 export { getObjectValidator };

package/dist/validator/schematic.validator.d.mts

@@ -0,0 +1,7 @@
+import { Validator } from "../models/validation.model.mjs";
+import { Schematic } from "../schematic.mjs";
+
+//#region src/validator/schematic.validator.d.ts
+declare function getSchematicValidator(schematic: Schematic<unknown>): Validator;
+//#endregion
+export { getSchematicValidator };

package/dist/validator/schematic.validator.mjs

@@ -0,0 +1,16 @@
+import { schematicValidator } from "../schematic.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/validator/schematic.validator.ts
+function getSchematicValidator(schematic) {
+	const validator = schematicValidator.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
+export { getSchematicValidator };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/jhunal",
-	"version": "0.22.0",
+	"version": "0.23.0",
 	"description": "Flies free beneath the glistening moons…",
 	"keywords": [
 		"schema",

package/src/constants.ts

@@ -25,6 +25,8 @@ export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
 
 export const NAME_SCHEMATIC = 'Schematic';
 
+export const NAME_SCHEMATIC_PREFIXED = 'a Schematic';
+
 export const NAME_ERROR_SCHEMATIC = 'SchematicError';
 
 export const NAME_ERROR_VALIDATION = 'ValidationError';
@@ -45,7 +47,7 @@ export const PROPERTY_VALIDATORS = '$validators';
 
 // #region Property validation
 
-export const VALIDATION_MESSAGE_INVALID_INPUT = "Expected 'object' as input but received <>";
+export const VALIDATION_MESSAGE_INVALID_INPUT = 'Expected an object as input but received <>';
 
 export const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
 
@@ -116,24 +118,54 @@ export const TEMPLATE_PATTERN = '<>';
 
 export const TYPE_ARRAY = 'array';
 
+const TYPE_BIGINT = 'bigint';
+
+const TYPE_BOOLEAN = 'boolean';
+
+const TYPE_DATE = 'date';
+
+export const TYPE_FUNCTION = 'function';
+
+export const TYPE_FUNCTION_RESULT = 'a validated value';
+
 export const TYPE_NULL = 'null';
 
+const TYPE_NUMBER = 'number';
+
 export const TYPE_OBJECT = 'object';
 
+const TYPE_STRING = 'string';
+
+const TYPE_SYMBOL = 'symbol';
+
 export const TYPE_UNDEFINED = 'undefined';
 
 export const VALIDATABLE_TYPES = new Set<ValueName>([
-	'array',
-	'bigint',
-	'boolean',
-	'date',
-	'function',
-	'number',
-	'string',
-	'symbol',
+	TYPE_ARRAY,
+	TYPE_BIGINT,
+	TYPE_BOOLEAN,
+	TYPE_DATE,
+	TYPE_FUNCTION,
+	TYPE_NUMBER,
 	TYPE_OBJECT,
+	TYPE_STRING,
+	TYPE_SYMBOL,
 ]);
 
-export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, 'null', TYPE_UNDEFINED]);
+export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, TYPE_NULL, TYPE_UNDEFINED]);
+
+export const PREFIXED_TYPES: Record<ValueName, string> = {
+	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
+	[TYPE_BIGINT]: `a ${TYPE_BIGINT}`,
+	[TYPE_BOOLEAN]: `a ${TYPE_BOOLEAN}`,
+	[TYPE_DATE]: `a ${TYPE_DATE}`,
+	[TYPE_FUNCTION]: `a ${TYPE_FUNCTION}`,
+	[TYPE_NULL]: TYPE_NULL,
+	[TYPE_NUMBER]: `a ${TYPE_NUMBER}`,
+	[TYPE_STRING]: `a ${TYPE_STRING}`,
+	[TYPE_SYMBOL]: `a ${TYPE_SYMBOL}`,
+	[TYPE_OBJECT]: `an ${TYPE_OBJECT}`,
+	[TYPE_UNDEFINED]: TYPE_UNDEFINED,
+};
 
 // #endregion

package/src/helpers/message.helper.ts

@@ -0,0 +1,152 @@
+import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
+import {
+	COMMA,
+	CONJUNCTION_AND,
+	CONJUNCTION_AND_COMMA,
+	CONJUNCTION_OR,
+	CONJUNCTION_OR_COMMA,
+	PREFIXED_TYPES,
+	TEMPLATE_PATTERN,
+	TYPE_ALL,
+	TYPE_ARRAY,
+	TYPE_FUNCTION,
+	TYPE_FUNCTION_RESULT,
+	TYPE_NULL,
+	TYPE_OBJECT,
+	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,
+} from '../constants';
+import type {ValueName} from '../models/misc.model';
+import type {ValidatorType} from '../models/validation.model';
+
+export function getInvalidInputMessage(actual: unknown): string {
+	return VALIDATION_MESSAGE_INVALID_INPUT.replace(TEMPLATE_PATTERN, getValueType(actual));
+}
+
+export function getInvalidMissingMessage(key: string, types: ValidatorType[]): string {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace(TEMPLATE_PATTERN, renderTypes(types));
+
+	message = message.replace(TEMPLATE_PATTERN, key);
+
+	return message;
+}
+
+export function getInvalidTypeMessage(
+	key: string,
+	types: ValidatorType[],
+	actual: unknown,
+): string {
+	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace(TEMPLATE_PATTERN, renderTypes(types));
+
+	message = message.replace(TEMPLATE_PATTERN, key);
+	message = message.replace(TEMPLATE_PATTERN, getValueType(actual));
+
+	return message;
+}
+
+export function getInvalidValidatorMessage(
+	key: string,
+	type: ValueName,
+	index: number,
+	length: number,
+): string {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace(TEMPLATE_PATTERN, key);
+
+	message = message.replace(TEMPLATE_PATTERN, type);
+
+	if (length > 1) {
+		message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace(TEMPLATE_PATTERN, String(index));
+	}
+
+	return message;
+}
+
+function getPropertyType(type: ValidatorType): string {
+	switch (true) {
+		case typeof type === 'function':
+			return isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT;
+
+		case TYPE_ALL.has(type as ValueName):
+			return PREFIXED_TYPES[type as ValueName];
+
+		default:
+			return PREFIXED_TYPES[TYPE_OBJECT];
+	}
+}
+
+export function getUnknownKeysMessage(keys: string[]): string {
+	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace(TEMPLATE_PATTERN, renderKeys(keys));
+}
+
+function getValueType(value: unknown): string {
+	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 as ValueName];
+
+		default:
+			return (value as object).constructor.name;
+	}
+}
+
+function renderKeys(keys: string[]): string {
+	return renderParts(
+		keys.map(key => `'${key}'`),
+		CONJUNCTION_AND,
+		CONJUNCTION_AND_COMMA,
+	);
+}
+
+function renderParts(parts: string[], delimiterShort: string, delimiterLong: string): string {
+	const {length} = parts;
+
+	if (length === 1) {
+		return parts[0];
+	}
+
+	let rendered = '';
+
+	for (let index = 0; index < length; index += 1) {
+		rendered += parts[index];
+
+		if (index < length - 2) {
+			rendered += COMMA;
+		} else if (index === length - 2) {
+			rendered += parts.length > 2 ? delimiterLong : delimiterShort;
+		}
+	}
+
+	return rendered;
+}
+
+function renderTypes(types: ValidatorType[]): string {
+	const unique = new Set<string>();
+	const parts: string[] = [];
+
+	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);
+	}
+
+	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
+}

package/src/helpers/misc.helper.ts

@@ -0,0 +1,93 @@
+import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
+import type {Constructor, PlainObject} from '@oscarpalmer/atoms/models';
+import {
+	MESSAGE_CONSTRUCTOR,
+	PROPERTY_SCHEMATIC,
+	REPORTING_ALL,
+	REPORTING_FIRST,
+	REPORTING_NONE,
+	REPORTING_THROW,
+	REPORTING_TYPES,
+	TYPE_OBJECT,
+} from '../constants';
+import type {
+	ReportingInformation,
+	ReportingType,
+	ValidatorParameters,
+} from '../models/validation.model';
+import type {Schematic} from '../schematic';
+
+export function getParameters(input?: unknown): ValidatorParameters {
+	if (typeof input === 'boolean') {
+		return {
+			clone: true,
+			output: {},
+			reporting: getReporting(REPORTING_NONE),
+			strict: input,
+		};
+	}
+
+	if (REPORTING_TYPES.has(input as ReportingType)) {
+		return {
+			clone: true,
+			output: {},
+			reporting: getReporting(input as ReportingType),
+			strict: false,
+		};
+	}
+
+	const options = isPlainObject(input) ? input : {};
+
+	return {
+		clone: typeof options.clone === 'boolean' ? options.clone : true,
+		output: {},
+		reporting: getReporting(options.errors),
+		strict: typeof options.strict === 'boolean' ? options.strict : false,
+	};
+}
+
+export function getReporting(value: unknown): ReportingInformation {
+	const type = REPORTING_TYPES.has(value as ReportingType)
+		? (value as ReportingType)
+		: REPORTING_NONE;
+
+	return {
+		type,
+		[REPORTING_ALL]: type === REPORTING_ALL,
+		[REPORTING_FIRST]: type === REPORTING_FIRST,
+		[REPORTING_NONE]: type === REPORTING_NONE,
+		[REPORTING_THROW]: type === REPORTING_THROW,
+	} as ReportingInformation;
+}
+
+/**
+ * Creates a validator function for a given constructor
+ * @param constructor - Constructor to check against
+ * @throws Will throw a `TypeError` if the provided argument is not a valid constructor
+ * @returns Validator function that checks if a value is an instance of the constructor
+ */
+export function instanceOf<Instance>(
+	constructor: Constructor<Instance>,
+): (value: unknown) => value is Instance {
+	if (!isConstructor(constructor)) {
+		throw new TypeError(MESSAGE_CONSTRUCTOR);
+	}
+
+	return (value: unknown): value is Instance => {
+		return value instanceof constructor;
+	};
+}
+
+/**
+ * Is the value a schematic?
+ * @param value Value to check
+ * @returns `true` if the value is a schematic, `false` otherwise
+ */
+export function isSchematic(value: unknown): value is Schematic<never> {
+	return (
+		typeof value === TYPE_OBJECT &&
+		value !== null &&
+		PROPERTY_SCHEMATIC in (value as PlainObject) &&
+		(value as PlainObject)[PROPERTY_SCHEMATIC] === true
+	);
+}