@oscarpalmer/jhunal 0.22.0 → 0.23.0

package/dist/index.mjs

@@ -1,7 +1,6 @@
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
 import { error, ok } from "@oscarpalmer/atoms/result/misc";
-import { join as join$1 } from "@oscarpalmer/atoms";
 import { clone } from "@oscarpalmer/atoms/value/clone";
 //#region src/constants.ts
 const CONJUNCTION_OR = " or ";
@@ -9,14 +8,13 @@ const CONJUNCTION_OR_COMMA = ", or ";
 const CONJUNCTION_AND = " and ";
 const CONJUNCTION_AND_COMMA = ", and ";
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
-const NAME_SCHEMATIC = "Schematic";
 const NAME_ERROR_SCHEMATIC = "SchematicError";
 const NAME_ERROR_VALIDATION = "ValidationError";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_SCHEMATIC = "$schematic";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
-const VALIDATION_MESSAGE_INVALID_INPUT = "Expected 'object' as input but received <>";
+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 '<>'";
@@ -41,71 +39,68 @@ const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
 const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
 const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 const TYPE_ARRAY = "array";
+const TYPE_BIGINT = "bigint";
+const TYPE_BOOLEAN = "boolean";
+const TYPE_DATE = "date";
+const TYPE_FUNCTION = "function";
+const TYPE_FUNCTION_RESULT = "a validated value";
 const TYPE_NULL = "null";
+const TYPE_NUMBER = "number";
 const TYPE_OBJECT = "object";
+const TYPE_STRING = "string";
+const TYPE_SYMBOL = "symbol";
 const TYPE_UNDEFINED = "undefined";
 const TYPE_ALL = new Set([
 	...new Set([
-		"array",
-		"bigint",
-		"boolean",
-		"date",
-		"function",
-		"number",
-		"string",
-		"symbol",
-		TYPE_OBJECT
+		TYPE_ARRAY,
+		TYPE_BIGINT,
+		TYPE_BOOLEAN,
+		TYPE_DATE,
+		TYPE_FUNCTION,
+		TYPE_NUMBER,
+		TYPE_OBJECT,
+		TYPE_STRING,
+		TYPE_SYMBOL
 	]),
-	"null",
+	TYPE_NULL,
 	TYPE_UNDEFINED
 ]);
+const PREFIXED_TYPES = {
+	[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
-//#region src/helpers.ts
-function getInvalidInputMessage(actual) {
-	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
-}
-function getInvalidMissingMessage(key, types) {
-	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
-	message = message.replace("<>", key);
-	return message;
-}
-function getInvalidTypeMessage(key, types, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
-	message = message.replace("<>", key);
-	message = message.replace("<>", getValueType(actual));
-	return message;
-}
-function getInvalidValidatorMessage(key, type, index, length) {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
-	message = message.replace("<>", type);
-	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
-	return message;
-}
+//#region src/helpers/misc.helper.ts
 function getParameters(input) {
 	if (typeof input === "boolean") return {
+		clone: true,
 		output: {},
 		reporting: getReporting(REPORTING_NONE),
 		strict: input
 	};
 	if (REPORTING_TYPES.has(input)) return {
+		clone: true,
 		output: {},
 		reporting: getReporting(input),
 		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
 	};
 }
-function getPropertyType(original) {
-	if (typeof original === "function") return "a validated value";
-	if (Array.isArray(original)) return `'array'`;
-	if (isPlainObject(original)) return `'${TYPE_OBJECT}'`;
-	if (isSchematic(original)) return `a ${NAME_SCHEMATIC}`;
-	return `'${String(original)}'`;
-}
 function getReporting(value) {
 	const type = REPORTING_TYPES.has(value) ? value : REPORTING_NONE;
 	return {
@@ -116,21 +111,6 @@ function getReporting(value) {
 		[REPORTING_THROW]: type === REPORTING_THROW
 	};
 }
-function getUnknownKeysMessage(keys) {
-	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
-}
-function getValueType(value) {
-	const valueType = typeof value;
-	switch (true) {
-		case value === null: return `'${TYPE_NULL}'`;
-		case value === void 0: return `'${TYPE_UNDEFINED}'`;
-		case valueType !== TYPE_OBJECT: return `'${valueType}'`;
-		case Array.isArray(value): return `'${TYPE_ARRAY}'`;
-		case isPlainObject(value): return `'${TYPE_OBJECT}'`;
-		case isSchematic(value): return `a ${NAME_SCHEMATIC}`;
-		default: return value.constructor.name;
-	}
-}
 /**
 * Creates a validator function for a given constructor
 * @param constructor - Constructor to check against
@@ -151,6 +131,69 @@ function instanceOf(constructor) {
 function isSchematic(value) {
 	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
 }
+//#endregion
+//#region src/models/validation.model.ts
+/**
+* Thrown when a schema definition is invalid
+*/
+var SchematicError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = NAME_ERROR_SCHEMATIC;
+	}
+};
+/**
+* Thrown in `'throw'` mode when one or more properties fail validation; `information` holds all failures
+*/
+var ValidationError = class extends Error {
+	constructor(information) {
+		super(join(information.map((item) => item.message), "; "));
+		this.information = information;
+		this.name = NAME_ERROR_VALIDATION;
+	}
+};
+//#endregion
+//#region src/helpers/message.helper.ts
+function getInvalidInputMessage(actual) {
+	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
+}
+function getInvalidMissingMessage(key, types) {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
+	return message;
+}
+function getInvalidTypeMessage(key, types, actual) {
+	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
+	message = message.replace("<>", getValueType(actual));
+	return message;
+}
+function getInvalidValidatorMessage(key, type, index, length) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
+	message = message.replace("<>", type);
+	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
+	return message;
+}
+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];
+	}
+}
+function getUnknownKeysMessage(keys) {
+	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
+}
+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];
+		default: return value.constructor.name;
+	}
+}
 function renderKeys(keys) {
 	return renderParts(keys.map((key) => `'${key}'`), CONJUNCTION_AND, CONJUNCTION_AND_COMMA);
 }
@@ -177,43 +220,56 @@ function renderTypes(types) {
 	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
 }
 //#endregion
-//#region src/models/validation.model.ts
-/**
-* Thrown when a schema definition is invalid
-*/
-var SchematicError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = NAME_ERROR_SCHEMATIC;
-	}
-};
-/**
-* Thrown in `'throw'` mode when one or more properties fail validation; `information` holds all failures
-*/
-var ValidationError = class extends Error {
-	constructor(information) {
-		super(join(information.map((item) => item.message), "; "));
-		this.information = information;
-		this.name = NAME_ERROR_VALIDATION;
-	}
-};
-//#endregion
-//#region src/validation.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;
+//#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;
+	return (input) => validator(input) ? true : [];
 }
+//#endregion
+//#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
+//#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 false;
+		if (!validator(input)) return [];
 		for (let index = 0; index < length; index += 1) {
 			const handler = named[index];
 			if (handler(input) === true) continue;
@@ -224,27 +280,43 @@ function getNamedValidator(key, name, handlers) {
 				value: input
 			};
 			parameters.information?.push(information);
-			return parameters.reporting.none ? false : [information];
+			return parameters.reporting.none ? [] : [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;
+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 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
+//#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 getObjectValidator(original, origin, fromType) {
 	const keys = Object.keys(original);
@@ -259,8 +331,8 @@ function getObjectValidator(original, origin, fromType) {
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 		const value = original[key];
-		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join$1([origin?.full, key], ".")));
-		const prefixedKey = origin == null ? key : join$1([origin.full, key], ".");
+		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join([origin?.full, key], ".")));
+		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
 		const fullKey = {
 			full: prefixedKey,
 			short: key
@@ -304,13 +376,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: "",
@@ -321,7 +393,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));
@@ -336,7 +408,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 = [];
@@ -346,7 +418,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,
@@ -366,12 +438,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,
@@ -386,7 +457,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) {
@@ -394,46 +465,6 @@ 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
 //#region src/schematic.ts
 /**
@@ -449,13 +480,15 @@ var Schematic = class {
 	get(value, options) {
 		const parameters = getParameters(options);
 		const result = this.#validator(value, parameters, true);
-		if (typeof result === "boolean") return parameters.reporting.none ? result ? parameters.output : void 0 : ok(parameters.output);
+		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]);
 	}
 	is(value, options) {
 		const parameters = getParameters(options);
 		const result = this.#validator(value, parameters, false);
-		if (typeof result === "boolean") return parameters.reporting.none ? result : ok(result);
+		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]);
 	}
 };

package/dist/models/validation.model.d.mts

@@ -46,21 +46,32 @@ type ValidationInformationKey = {
   full: string;
   short: string;
 };
-/**
- * Options for validation
- */
-type ValidationOptions<Errors extends ReportingType> = {
+type BaseOptions<Errors extends ReportingType> = {
   /**
    * How should validation failures be reported; see {@link ReportingType} _(defaults to `'none'`)_
    */
-  errors?: Errors;
+  errors: Errors;
   /**
    * Validate if unknown keys are present in the object? _(defaults to `false`)_
    */
   strict?: boolean;
 };
-type Validator = (input: unknown, parameters: ValidatorParameters, get: boolean) => boolean | ValidationInformation[];
+/**
+ * Options for validating and getting a value from an input
+ */
+type GetOptions<Errors extends ReportingType> = BaseOptions<Errors> & {
+  /**
+   * Get a deeply cloned version of the input? _(defaults to `true`)_
+   */
+  clone?: boolean;
+};
+/**
+ * Options for validation an input value
+ */
+type IsOptions<Errors extends ReportingType> = BaseOptions<Errors>;
+type Validator = (input: unknown, parameters: ValidatorParameters, get: boolean) => true | ValidationInformation[];
 type ValidatorParameters = {
+  clone: boolean;
   information?: ValidationInformation[];
   output: PlainObject;
   reporting: ReportingInformation;
@@ -68,4 +79,4 @@ type ValidatorParameters = {
 };
 type ValidatorType = Function | PlainObject | Schematic<unknown> | ValueName;
 //#endregion
-export { NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, Validator, ValidatorParameters, ValidatorType };
+export { GetOptions, IsOptions, NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, Validator, ValidatorParameters, ValidatorType };

package/dist/schematic.d.mts

@@ -1,6 +1,6 @@
 import { Infer } from "./models/infer.model.mjs";
 import { TypedSchema } from "./models/schema.typed.model.mjs";
-import { ValidationInformation, ValidationOptions, Validator } from "./models/validation.model.mjs";
+import { GetOptions, IsOptions, ValidationInformation, Validator } from "./models/validation.model.mjs";
 import { Schema } from "./models/schema.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 import { Result } from "@oscarpalmer/atoms/result/models";
@@ -21,7 +21,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
    */
-  get(value: unknown, options: ValidationOptions<'throw'>): Model;
+  get(value: unknown, options: GetOptions<'throw'>): Model;
   /**
    * Parse a value according to the schema
    *
@@ -39,7 +39,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Result holding deeply cloned value or all validation information
    */
-  get(value: unknown, options: ValidationOptions<'all'>): Result<Model, ValidationInformation[]>;
+  get(value: unknown, options: GetOptions<'all'>): Result<Model, ValidationInformation[]>;
   /**
    * Parse a value according to the schema
    *
@@ -57,7 +57,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Result holding deeply cloned value or all validation information
    */
-  get(value: unknown, options: ValidationOptions<'first'>): Result<Model, ValidationInformation>;
+  get(value: unknown, options: GetOptions<'first'>): Result<Model, ValidationInformation>;
   /**
    * Parse a value according to the schema
    *
@@ -67,6 +67,15 @@ declare class Schematic<Model> {
    * @returns Result holding deeply cloned value or all validation information
    */
   get(value: unknown, errors: 'first'): Result<Model, ValidationInformation>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or `undefined` if the value does not match the schema
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Deeply cloned value, or `undefined` if it's invalid
+   */
+  get(value: unknown, options: GetOptions<'none'>): Model | undefined;
   /**
    * Parse a value according to the schema
    *
@@ -84,7 +93,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise throws an error
    */
-  is(value: unknown, options: ValidationOptions<'throw'>): asserts value is Model;
+  is(value: unknown, options: IsOptions<'throw'>): asserts value is Model;
   /**
    * Does the value match the schema?
    *
@@ -102,7 +111,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Result holding `true` or all validation information
    */
-  is(value: unknown, options: ValidationOptions<'all'>): Result<true, ValidationInformation[]>;
+  is(value: unknown, options: IsOptions<'all'>): Result<true, ValidationInformation[]>;
   /**
    * Does the value match the schema?
    *
@@ -120,7 +129,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise `false`
    */
-  is(value: unknown, options: ValidationOptions<'first'>): Result<true, ValidationInformation>;
+  is(value: unknown, options: IsOptions<'first'>): Result<true, ValidationInformation>;
   /**
    * Does the value match the schema?
    *
@@ -130,6 +139,15 @@ declare class Schematic<Model> {
    * @returns `true` if the value matches the schema, otherwise `false`
    */
   is(value: unknown, errors: 'first'): Result<true, ValidationInformation>;
+  /**
+   * Does the value match the schema?
+   *
+   * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures
+   * @param value Value to validate
+   * @param options Validation options
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown, options: IsOptions<'none'>): value is Model;
   /**
    * Does the value match the schema?
    *

package/dist/schematic.mjs

@@ -1,7 +1,7 @@
 import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
-import { getParameters, isSchematic } from "./helpers.mjs";
+import { getParameters, isSchematic } from "./helpers/misc.helper.mjs";
 import { SchematicError } from "./models/validation.model.mjs";
-import { getObjectValidator } from "./validation.mjs";
+import { getObjectValidator } from "./validator/object.validator.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 import { error, ok } from "@oscarpalmer/atoms/result/misc";
 //#region src/schematic.ts
@@ -18,13 +18,15 @@ var Schematic = class {
 	get(value, options) {
 		const parameters = getParameters(options);
 		const result = this.#validator(value, parameters, true);
-		if (typeof result === "boolean") return parameters.reporting.none ? result ? parameters.output : void 0 : ok(parameters.output);
+		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]);
 	}
 	is(value, options) {
 		const parameters = getParameters(options);
 		const result = this.#validator(value, parameters, false);
-		if (typeof result === "boolean") return parameters.reporting.none ? result : ok(result);
+		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]);
 	}
 };