@oscarpalmer/jhunal 0.20.0 → 0.22.0

package/dist/index.mjs

@@ -1,6 +1,8 @@
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
-import { error } from "@oscarpalmer/atoms/result/misc";
+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 ";
 const CONJUNCTION_OR_COMMA = ", or ";
@@ -42,19 +44,18 @@ const TYPE_ARRAY = "array";
 const TYPE_NULL = "null";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
-const VALIDATABLE_TYPES = new Set([
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"function",
-	"number",
-	"string",
-	"symbol",
-	TYPE_OBJECT
-]);
 const TYPE_ALL = new Set([
-	...VALIDATABLE_TYPES,
+	...new Set([
+		"array",
+		"bigint",
+		"boolean",
+		"date",
+		"function",
+		"number",
+		"string",
+		"symbol",
+		TYPE_OBJECT
+	]),
 	"null",
 	TYPE_UNDEFINED
 ]);
@@ -63,41 +64,45 @@ const TYPE_ALL = new Set([
 function getInvalidInputMessage(actual) {
 	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
 }
-function getInvalidMissingMessage(property) {
-	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(property.types));
-	message = message.replace("<>", property.key.full);
+function getInvalidMissingMessage(key, types) {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
 	return message;
 }
-function getInvalidTypeMessage(property, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(property.types));
-	message = message.replace("<>", property.key.full);
+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(property, type, index, length) {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", property.key.full);
+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 getOptions(input) {
+function getParameters(input) {
 	if (typeof input === "boolean") return {
+		output: {},
 		reporting: getReporting(REPORTING_NONE),
 		strict: input
 	};
 	if (REPORTING_TYPES.has(input)) return {
+		output: {},
 		reporting: getReporting(input),
 		strict: false
 	};
 	const options = isPlainObject(input) ? input : {};
 	return {
+		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 `'${TYPE_OBJECT}'`;
+	if (Array.isArray(original)) return `'array'`;
+	if (isPlainObject(original)) return `'${TYPE_OBJECT}'`;
 	if (isSchematic(original)) return `a ${NAME_SCHEMATIC}`;
 	return `'${String(original)}'`;
 }
@@ -193,216 +198,230 @@ var ValidationError = class extends Error {
 	}
 };
 //#endregion
-//#region src/validation/property.validation.ts
+//#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;
 }
-function getProperties(original, prefix, fromType) {
-	if (Object.keys(original).length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
-	if (fromType ?? false) {
-		const property = getDisallowedProperty(original);
-		if (property != null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", property));
-	}
-	const keys = Object.keys(original);
-	const keysLength = keys.length;
-	const properties = [];
-	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
-		const key = keys[keyIndex];
-		const prefixed = join([prefix, key], ".");
-		const value = original[key];
-		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", prefixed));
-		const types = [];
-		let required = true;
-		let validators = {};
-		if (isPlainObject(value)) {
-			required = getRequired(key, value) ?? required;
-			validators = getValidators(value[PROPERTY_VALIDATORS]);
-			const hasType = PROPERTY_TYPE in value;
-			types.push(...getTypes(key, hasType ? value[PROPERTY_TYPE] : value, prefix, hasType));
-		} else types.push(...getTypes(key, value, prefix));
-		if (!required && !types.includes("undefined")) types.push(TYPE_UNDEFINED);
-		properties.push({
-			types,
-			validators,
-			key: {
-				full: prefixed,
-				short: key
-			},
-			required: required && !types.includes("undefined")
-		});
-	}
-	return properties;
-}
-function getRequired(key, obj) {
-	if (!("$required" in obj)) return;
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
-	return obj[PROPERTY_REQUIRED];
+function getFunctionValidator(fn) {
+	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
+	return (input) => validator(input) === true;
 }
-function getTypes(key, original, prefix, fromType) {
-	const array = Array.isArray(original) ? original : [original];
-	const { length } = array;
-	const types = [];
-	for (let index = 0; index < length; index += 1) {
-		const value = array[index];
-		switch (true) {
-			case typeof value === "function":
-				types.push(isConstructor(value) ? instanceOf(value) : value);
-				break;
-			case isPlainObject(value):
-				types.push(getProperties(value, join([prefix, key], "."), fromType));
-				break;
-			case isSchematic(value):
-				types.push(value);
-				break;
-			case TYPE_ALL.has(value):
-				types.push(value);
-				break;
-			default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
+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];
 		}
-	}
-	if (types.length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
-	return types;
+		return true;
+	};
 }
-function getValidators(original) {
-	const validators = {};
-	if (original == null) return validators;
+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 (!VALIDATABLE_TYPES.has(key)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		if (!TYPE_ALL.has(key)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
 		const value = original[key];
-		validators[key] = (Array.isArray(value) ? value : [value]).map((item) => {
-			if (typeof item !== "function") throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", 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 validators;
+	return handlers;
 }
-//#endregion
-//#region src/validation/value.validation.ts
-function validateNamed(property, name, value, validation) {
-	if (!validators[name](value)) return false;
-	const propertyValidators = property.validators[name];
-	if (propertyValidators == null || propertyValidators.length === 0) return true;
-	const { length } = propertyValidators;
-	for (let index = 0; index < length; index += 1) {
-		const validator = propertyValidators[index];
-		if (!validator(value)) {
-			validation.push({
-				value,
-				key: { ...property.key },
-				message: getInvalidValidatorMessage(property, name, index, length),
-				validator
-			});
-			return false;
-		}
+function getObjectValidator(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(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", origin.full).replace("<>", property));
 	}
-	return true;
-}
-function validateObject(obj, properties, options, origin, validation) {
-	if (!isPlainObject(obj)) {
-		const key = origin == null ? {
-			full: "",
-			short: ""
-		} : { ...origin.key };
-		const information = {
-			key,
-			message: origin == null ? getInvalidInputMessage(obj) : getInvalidTypeMessage({
-				...origin,
-				key
-			}, obj),
-			value: obj
+	const set = /* @__PURE__ */ new Set();
+	const items = [];
+	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], ".");
+		const fullKey = {
+			full: prefixedKey,
+			short: key
 		};
-		if (options.reporting.throw) throw new ValidationError([information]);
-		validation?.push(information);
-		return options.reporting.none ? false : [information];
+		let handlers = {};
+		let required = true;
+		let typed = false;
+		let types;
+		const validators = [];
+		if (isPlainObject(value)) {
+			typed = PROPERTY_TYPE in value;
+			const type = typed ? value[PROPERTY_TYPE] : value;
+			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey);
+			required = getRequired(key, value) ?? required;
+			types = Array.isArray(type) ? type : [type];
+		} else types = Array.isArray(value) ? value : [value];
+		if (types.length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(value)));
+		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 isSchematic(type):
+					validator = getSchematicValidator(type);
+					break;
+				case TYPE_ALL.has(type):
+					validator = getNamedValidator(fullKey, type, handlers);
+					break;
+				default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(type)));
+			}
+			validators.push(validator);
+		}
+		set.add(key);
+		items.push({
+			types,
+			key: fullKey,
+			required: required && !types.includes("undefined"),
+			validator: getValidator(validators)
+		});
 	}
-	if (options.strict) {
-		const objKeys = Object.keys(obj);
-		const propertiesKeys = new Set(properties.map((property) => property.key.short));
-		const unknownKeys = objKeys.filter((key) => !propertiesKeys.has(key));
-		if (unknownKeys.length > 0) {
+	const validatorsLength = items.length;
+	return (input, parameters, get) => {
+		if (!isPlainObject(input)) {
+			if (origin != null) return false;
 			const information = {
-				key: origin == null ? {
+				key: {
 					full: "",
 					short: ""
-				} : { ...origin.key },
-				message: getUnknownKeysMessage(unknownKeys.map((key) => join([origin?.key.full, key], "."))),
-				value: obj
+				},
+				value: input,
+				message: getInvalidInputMessage(input)
 			};
-			if (options.reporting.throw) throw new ValidationError([information]);
-			validation?.push(information);
-			return options.reporting.none ? false : [information];
+			if (parameters.reporting.throw) throw new ValidationError([information]);
+			parameters.information?.push(information);
+			return parameters.reporting.none ? false : [information];
 		}
-	}
-	const allInformation = [];
-	const propertiesLength = properties.length;
-	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
-		let property = properties[propertyIndex];
-		property = {
-			...property,
-			key: {
-				full: join([origin?.key.full, property.key.short], "."),
-				short: property.key.short
+		if (parameters.strict) {
+			const unknownKeys = Object.keys(input).filter((key) => !set.has(key));
+			if (unknownKeys.length > 0) {
+				const information = {
+					key: origin ?? {
+						full: "",
+						short: ""
+					},
+					message: getUnknownKeysMessage(unknownKeys),
+					value: input
+				};
+				if (parameters.reporting.throw) throw new ValidationError([information]);
+				parameters.information?.push(information);
+				return parameters.reporting.none ? false : [information];
 			}
-		};
-		const { key, required, types } = property;
-		const value = obj[key.short];
-		if (value === void 0 && required) {
-			const information = {
+		}
+		const allInformation = [];
+		const output = {};
+		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
+			const { key, required, types, validator } = items[validatorIndex];
+			const value = input[key.short];
+			if (value === void 0) {
+				if (required) {
+					if (parameters.reporting.none) return false;
+					const information = {
+						key,
+						value,
+						message: getInvalidMissingMessage(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];
+				}
+				continue;
+			}
+			const previousOutput = parameters.output;
+			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);
+				continue;
+			}
+			if (parameters.reporting.none) return false;
+			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
+				key,
 				value,
-				key: { ...key },
-				message: getInvalidMissingMessage(property)
-			};
-			if (options.reporting.throw && validation == null) throw new ValidationError([information]);
-			if (validation != null) validation.push(information);
-			if (options.reporting.all) {
-				allInformation.push(information);
+				message: getInvalidTypeMessage(key.full, types, value)
+			}];
+			if (parameters.reporting.throw) throw new ValidationError(information);
+			if (parameters.reporting.all) {
+				allInformation.push(...information);
 				continue;
 			}
-			return options.reporting.none ? false : [information];
-		}
-		const typesLength = types.length;
-		const information = [];
-		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			const type = types[typeIndex];
-			if (validateValue(type, property, value, options, information)) continue outer;
+			return information;
 		}
-		if (information.length === 0) information.push({
-			value,
-			key: { ...key },
-			message: getInvalidTypeMessage(property, value)
-		});
-		if (options.reporting.throw && validation == null) throw new ValidationError(information);
-		validation?.push(...information);
-		if (options.reporting.all) {
-			allInformation.push(...information);
-			continue;
-		}
-		return options.reporting.none ? false : information;
-	}
-	return options.reporting.none || allInformation.length === 0 ? true : allInformation;
+		if (get) if (origin == null) parameters.output = output;
+		else parameters.output[origin.short] = output;
+		return parameters.reporting.none || allInformation.length === 0 ? true : allInformation;
+	};
 }
-function validateSchematic(property, schematic, value, options, validation) {
-	const result = validateObject(value, schematicProperties.get(schematic), options, property, validation);
-	return typeof result === "boolean" ? result : result.length === 0;
+function getRequired(key, obj) {
+	if (!("$required" in obj)) return;
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+	return obj[PROPERTY_REQUIRED];
 }
-function validateValue(type, property, value, options, validation) {
-	switch (true) {
-		case typeof type === "function": return type(value);
-		case Array.isArray(type): {
-			const validated = validateObject(value, type, options, property, validation);
-			return typeof validated === "boolean" ? validated : false;
+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);
 		}
-		case isSchematic(type): return validateSchematic(property, type, value, options, validation);
-		default: return validateNamed(property, type, value, validation);
-	}
+		return allInformation;
+	};
 }
-const validators = {
+const namedValidators = {
 	array: Array.isArray,
 	bigint: (value) => typeof value === "bigint",
 	boolean: (value) => typeof value === "boolean",
@@ -421,27 +440,30 @@ const validators = {
 * A schematic for validating objects
 */
 var Schematic = class {
-	#properties;
-	constructor(properties) {
+	#validator;
+	constructor(validator) {
 		Object.defineProperty(this, PROPERTY_SCHEMATIC, { value: true });
-		this.#properties = properties;
-		schematicProperties.set(this, properties);
+		this.#validator = validator;
+		schematicValidator.set(this, validator);
+	}
+	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);
+		return error(parameters.reporting.all ? result : result[0]);
 	}
 	is(value, options) {
-		const { reporting, strict } = getOptions(options);
-		const result = validateObject(value, this.#properties, {
-			reporting,
-			strict
-		});
-		if (typeof result === "boolean") return result;
-		return error(reporting.all ? result : result[0]);
+		const parameters = getParameters(options);
+		const result = this.#validator(value, parameters, false);
+		if (typeof result === "boolean") return parameters.reporting.none ? result : ok(result);
+		return error(parameters.reporting.all ? result : result[0]);
 	}
 };
 function schematic(schema) {
 	if (isSchematic(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schematic(getProperties(schema));
+	return new Schematic(getObjectValidator(schema));
 }
-const schematicProperties = /* @__PURE__ */ new WeakMap();
+const schematicValidator = /* @__PURE__ */ new WeakMap();
 //#endregion
 export { SchematicError, ValidationError, instanceOf, isSchematic, schematic };

package/dist/models/schema.plain.model.d.mts

@@ -25,19 +25,13 @@ type PlainSchema = {
  * };
  * ```
  */
-type Schema = SchemaIndex;
+type Schema = PlainSchema;
 /**
  * A union of all valid types for a single schema entry
  *
  * Can be a {@link Constructor}, {@link PlainSchema}, {@link SchemaProperty}, {@link Schematic}, {@link ValueName} string, or a custom validator function
  */
 type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
-/**
- * Index signature interface backing {@link Schema}, allowing string-keyed entries of {@link PlainSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry}
- */
-interface SchemaIndex {
-  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[];
-}
 /**
  * A property definition with explicit type(s), an optional requirement flag, and optional validators
  *
@@ -89,4 +83,4 @@ type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | Value
  */
 type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
 //#endregion
-export { PlainSchema, PropertyValidators, Schema, SchemaEntry, SchemaIndex, SchemaProperty, SchemaPropertyType };
+export { PlainSchema, PropertyValidators, Schema, SchemaEntry, SchemaProperty, SchemaPropertyType };