@oscarpalmer/jhunal 0.11.0 → 0.13.0

package/dist/constants.js

@@ -1,10 +1,12 @@
 const ERROR_NAME = "SchematicError";
-const EXPRESSION_HAS_NUMBER = /\d+/;
 const EXPRESSION_INDEX = /\.\d+$/;
-const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+const EXPRESSION_KEY_PREFIX = /\.\w+$/;
+const EXPRESSION_KEY_VALUE = /^.*\.(\w+)$/;
+const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED = "'<>.$required' property is not allowed for schemas in $type";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE = "'<>.$required' property must be a boolean";
 const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
 const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
@@ -33,4 +35,4 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
-export { ERROR_NAME, EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, MESSAGE_CONSTRUCTOR, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_SCHEMA_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_NAME, TEMPLATE_PATTERN, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES };
+export { ERROR_NAME, EXPRESSION_INDEX, EXPRESSION_KEY_PREFIX, EXPRESSION_KEY_VALUE, EXPRESSION_PROPERTY, MESSAGE_CONSTRUCTOR, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_SCHEMA_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_NAME, TEMPLATE_PATTERN, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES };

package/dist/{is.js → helpers.js}

@@ -1,6 +1,6 @@
 import { MESSAGE_CONSTRUCTOR } from "./constants.js";
 import { isConstructor } from "@oscarpalmer/atoms/is";
-function isInstance(constructor) {
+function instanceOf(constructor) {
 	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
@@ -9,4 +9,4 @@ function isInstance(constructor) {
 function isSchematic(value) {
 	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
 }
-export { isInstance, isSchematic };
+export { instanceOf, isSchematic };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { isInstance } from "./is.js";
+import { instanceOf } from "./helpers.js";
 import { SchematicError } from "./models.js";
 import { schematic } from "./schematic.js";
-export { SchematicError, isInstance, schematic };
+export { SchematicError, instanceOf, schematic };

package/dist/jhunal.full.js

@@ -1,12 +1,4 @@
 /**
-* Is the value an array or a record?
-* @param value Value to check
-* @returns `true` if the value is an array or a record, otherwise `false`
-*/
-function isArrayOrPlainObject(value) {
-	return Array.isArray(value) || isPlainObject(value);
-}
-/**
 * Is the value a constructor function?
 * @param value Value to check
 * @returns `true` if the value is a constructor function, otherwise `false`
@@ -59,12 +51,12 @@ function join(value, delimiter) {
 	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
 }
 const ERROR_NAME = "SchematicError";
-const EXPRESSION_HAS_NUMBER = /\d+/;
 const EXPRESSION_INDEX = /\.\d+$/;
-const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED = "'<>.$required' property is not allowed for schemas in $type";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE = "'<>.$required' property must be a boolean";
 const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
 const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
@@ -93,7 +85,7 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
-function isInstance(constructor) {
+function instanceOf(constructor) {
 	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
@@ -108,120 +100,64 @@ var SchematicError = class extends Error {
 		this.name = ERROR_NAME;
 	}
 };
-function flattenObject(value, depth, smushed, prefix) {
-	if (depth >= MAX_DEPTH) return {};
-	if (smushed.has(value)) return smushed.get(value);
-	const keys = Object.keys(value);
-	const { length } = keys;
-	const flattened = {};
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const val = value[key];
-		if (isArrayOrPlainObject(val)) {
-			const prefixedKey = join([prefix, key], ".");
-			flattened[prefixedKey] = Array.isArray(val) ? [...val] : { ...val };
-			const nested = flattenObject(val, depth + 1, smushed, prefixedKey);
-			const nestedKeys = Object.keys(nested);
-			const nestedLength = nestedKeys.length;
-			for (let nestedIndex = 0; nestedIndex < nestedLength; nestedIndex += 1) {
-				const nestedKey = nestedKeys[nestedIndex];
-				flattened[nestedKey] = nested[nestedKey];
-			}
-		} else flattened[join([prefix, key], ".")] = val;
-	}
-	smushed.set(value, flattened);
-	return flattened;
-}
-/**
-* Smush an object into a flat object that uses dot notation keys
-* @param value Object to smush
-* @returns Smushed object with dot notation keys
-*/
-function smush(value) {
-	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
-}
-var MAX_DEPTH = 100;
-function addPropertyType(to, key, values, validators, required) {
-	if (to.keys.set.has(key)) {
-		const property = to.properties[key];
-		for (const type of values) property.types.push(type);
-	} else {
-		to.keys.array.push(key);
-		to.keys.set.add(key);
-		to.properties[key] = {
-			required,
-			types: values,
-			validators: {}
-		};
+function getProperties(original, prefix, fromTypes) {
+	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
+	if (PROPERTY_REQUIRED in original && (fromTypes ?? false) && prefix != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED.replace(TEMPLATE_PATTERN, prefix));
+	const keys = Object.keys(original);
+	const keysLength = keys.length;
+	const properties = [];
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+		if (EXPRESSION_INDEX.test(key) || EXPRESSION_PROPERTY.test(key)) continue;
+		const value = original[key];
+		const types = [];
+		let required = true;
+		let validators = {};
+		if (isPlainObject(value)) {
+			required = getRequired(key, value) ?? required;
+			validators = getValidators(value[PROPERTY_VALIDATORS]);
+			if (PROPERTY_TYPE in value) types.push("object", ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
+			else types.push("object", ...getTypes(key, value, prefix));
+		} else types.push(...getTypes(key, value, prefix));
+		if (!required && !types.includes(TYPE_UNDEFINED)) types.push(TYPE_UNDEFINED);
+		properties.push({
+			key,
+			types,
+			validators,
+			required: required && !types.includes(TYPE_UNDEFINED)
+		});
 	}
-	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) to.properties[key].types.push(TYPE_UNDEFINED);
-	to.properties[key].validators = validators;
+	return properties;
 }
-function getSchema(schema) {
-	return getValidatedSchema(schema, {
-		keys: {
-			array: [],
-			set: /* @__PURE__ */ new Set()
-		},
-		properties: {}
-	});
+function getRequired(key, obj) {
+	if (!(PROPERTY_REQUIRED in obj)) return;
+	if (typeof obj[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE.replace(TEMPLATE_PATTERN, key));
+	return obj[PROPERTY_REQUIRED];
 }
-function getTypes(value, validated, prefix) {
-	const propertyTypes = [];
-	const values = Array.isArray(value) ? value : [value];
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) {
-		const type = values[index];
-		if (isSchematic(type) || TYPE_ALL.has(type)) {
-			propertyTypes.push(type);
-			continue;
-		}
-		if (typeof type === "function") {
-			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
-			continue;
-		}
-		if (!isPlainObject(type)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, prefix));
-		if (PROPERTY_TYPE in type) {
-			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
-			continue;
-		}
-		const { [PROPERTY_REQUIRED]: required, ...nested } = type;
-		if (PROPERTY_REQUIRED in type && typeof required !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, prefix));
-		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, required !== false);
-		propertyTypes.push(TYPE_OBJECT);
-		getValidatedSchema(nested, validated, prefix);
-	}
-	return propertyTypes;
-}
-function getValidatedSchema(schema, validated, prefix) {
-	const smushed = smush(schema);
-	const keys = Object.keys(smushed);
-	const { length } = keys;
-	const arrayKeys = /* @__PURE__ */ new Set();
-	const noPrefix = prefix == null;
-	prefix = noPrefix ? "" : `${prefix}.`;
+function getTypes(key, original, prefix, fromTypes) {
+	const array = Array.isArray(original) ? original : [original];
+	const { length } = array;
+	const types = [];
 	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const value = smushed[key];
-		if (Array.isArray(value)) arrayKeys.add(key);
-		if (EXPRESSION_PROPERTY.test(key)) continue;
-		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
-		let required = true;
-		let validators = {};
-		const isObject = isPlainObject(value);
-		if (isObject && PROPERTY_REQUIRED in value) {
-			if (typeof value[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
-			required = value[PROPERTY_REQUIRED] === true;
+		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], "."), fromTypes));
+				break;
+			case isSchematic(value):
+				types.push(value);
+				break;
+			case TYPE_ALL.has(value):
+				types.push(value);
+				break;
+			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
 		}
-		if (isObject && PROPERTY_VALIDATORS in value) validators = getValidators(value[PROPERTY_VALIDATORS]);
-		const prefixedKey = `${prefix}${key}`;
-		const types = getTypes(value, validated, prefixedKey);
-		if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
-		addPropertyType(validated, prefixedKey, types, validators, required);
 	}
-	if (noPrefix) validated.keys.array.sort();
-	if (noPrefix && validated.keys.array.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
-	return validated;
+	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
+	return types;
 }
 function getValidators(original) {
 	const validators = {};
@@ -240,43 +176,31 @@ function getValidators(original) {
 	}
 	return validators;
 }
-function validateType(type, property, value) {
-	switch (true) {
-		case typeof type === "function": return type(value);
-		case typeof type === "string": return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
-		default: return type.is(value);
-	}
-}
-function validateValue(validated, obj) {
-	if (typeof obj !== "object" || obj === null) return false;
-	const { keys, properties } = validated;
-	const keysLength = keys.array.length;
-	const ignore = /* @__PURE__ */ new Set();
-	const smushed = smush(obj);
-	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
-		const key = keys.array[keyIndex];
-		const prefix = key.replace(EXPRESSION_SUFFIX, "");
-		if (ignore.has(prefix)) continue;
-		const property = properties[key];
-		const value = smushed[key];
-		if (value === void 0 && property.required && !property.types.includes(TYPE_UNDEFINED)) return false;
-		const typesLength = property.types.length;
-		if (typesLength === 1) {
-			if (!validateType(property.types[0], property, value)) return false;
-			continue;
-		}
+function validateObject(obj, properties) {
+	if (!isPlainObject(obj)) return false;
+	const propertiesLength = properties.length;
+	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
+		const property = properties[propertyIndex];
+		const { key, required, types } = property;
+		const value = obj[key];
+		if (value === void 0 && required) return false;
+		const typesLength = types.length;
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			const type = property.types[typeIndex];
-			if (validateType(type, property, value)) {
-				if (type !== "object") ignore.add(key);
-				continue outer;
-			}
+			const type = types[typeIndex];
+			if (validateValue(type, property, value)) continue outer;
 		}
 		return false;
 	}
 	return true;
 }
-const EXPRESSION_SUFFIX = /\.\w+$/;
+function validateValue(type, property, value) {
+	switch (true) {
+		case isSchematic(type): return type.is(value);
+		case typeof type === "function": return type(value);
+		case typeof type === "object": return validateObject(value, [type]);
+		default: return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
+	}
+}
 const validators = {
 	array: Array.isArray,
 	bigint: (value) => typeof value === "bigint",
@@ -284,7 +208,7 @@ const validators = {
 	date: (value) => value instanceof Date,
 	function: (value) => typeof value === "function",
 	null: (value) => value === null,
-	number: (value) => typeof value === "number" && !Number.isNaN(value),
+	number: (value) => typeof value === "number",
 	object: (value) => typeof value === "object" && value !== null,
 	string: (value) => typeof value === "string",
 	symbol: (value) => typeof value === "symbol",
@@ -294,20 +218,21 @@ const validators = {
 * A schematic for validating objects
 */
 var Schematic = class {
-	#schema;
-	constructor(schema) {
+	#properties;
+	constructor(properties) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = schema;
+		this.#properties = properties;
 	}
 	/**
 	* Does the value match the schema?
 	*/
 	is(value) {
-		return validateValue(this.#schema, value);
+		return validateObject(value, this.#properties);
 	}
 };
 function schematic(schema) {
+	if (isSchematic(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schematic(getSchema(schema));
+	return new Schematic(getProperties(schema));
 }
-export { SchematicError, isInstance, schematic };
+export { SchematicError, instanceOf, schematic };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/array/compact.js

@@ -0,0 +1,12 @@
+function compact(array, strict) {
+	if (!Array.isArray(array)) return [];
+	if (strict === true) return array.filter(Boolean);
+	const { length } = array;
+	const compacted = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		if (item != null) compacted.push(item);
+	}
+	return compacted;
+}
+export { compact };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/string.js

@@ -0,0 +1,24 @@
+import { compact } from "./array/compact.js";
+/**
+* Get the string value from any value
+* @param value Original value
+* @returns String representation of the value
+*/
+function getString(value) {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value === "function") return getString(value());
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+}
+/**
+* Join an array of values into a string
+* @param value Array of values
+* @param delimiter Delimiter to use between values
+* @returns Joined string
+*/
+function join(value, delimiter) {
+	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
+}
+export { join };

package/dist/schematic.js

@@ -1,26 +1,28 @@
 import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.js";
+import { isSchematic } from "./helpers.js";
 import { SchematicError } from "./models.js";
-import { getSchema } from "./validation/schema.validation.js";
-import { validateValue } from "./validation/value.validation.js";
+import { getProperties } from "./validation/property.validation.js";
+import { validateObject } from "./validation/value.validation.js";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 /**
 * A schematic for validating objects
 */
 var Schematic = class {
-	#schema;
-	constructor(schema) {
+	#properties;
+	constructor(properties) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = schema;
+		this.#properties = properties;
 	}
 	/**
 	* Does the value match the schema?
 	*/
 	is(value) {
-		return validateValue(this.#schema, value);
+		return validateObject(value, this.#properties);
 	}
 };
 function schematic(schema) {
+	if (isSchematic(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schematic(getSchema(schema));
+	return new Schematic(getProperties(schema));
 }
 export { Schematic, schematic };

package/dist/validation/property.validation.js

@@ -0,0 +1,82 @@
+import { EXPRESSION_INDEX, EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPE_ALL, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
+import { instanceOf, isSchematic } from "../helpers.js";
+import { SchematicError } from "../models.js";
+import { join } from "../node_modules/@oscarpalmer/atoms/dist/internal/string.js";
+import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+function getProperties(original, prefix, fromTypes) {
+	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
+	if ("$required" in original && (fromTypes ?? false) && prefix != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED.replace("<>", prefix));
+	const keys = Object.keys(original);
+	const keysLength = keys.length;
+	const properties = [];
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+		if (EXPRESSION_INDEX.test(key) || EXPRESSION_PROPERTY.test(key)) continue;
+		const value = original[key];
+		const types = [];
+		let required = true;
+		let validators = {};
+		if (isPlainObject(value)) {
+			required = getRequired(key, value) ?? required;
+			validators = getValidators(value[PROPERTY_VALIDATORS]);
+			if ("$type" in value) types.push("object", ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
+			else types.push("object", ...getTypes(key, value, prefix));
+		} else types.push(...getTypes(key, value, prefix));
+		if (!required && !types.includes("undefined")) types.push(TYPE_UNDEFINED);
+		properties.push({
+			key,
+			types,
+			validators,
+			required: required && !types.includes("undefined")
+		});
+	}
+	return properties;
+}
+function getRequired(key, obj) {
+	if (!("$required" in obj)) return;
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE.replace("<>", key));
+	return obj[PROPERTY_REQUIRED];
+}
+function getTypes(key, original, prefix, fromTypes) {
+	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], "."), fromTypes));
+				break;
+			case isSchematic(value):
+				types.push(value);
+				break;
+			case TYPE_ALL.has(value):
+				types.push(value);
+				break;
+			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
+		}
+	}
+	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
+	return types;
+}
+function getValidators(original) {
+	const validators = {};
+	if (original == null) return validators;
+	if (!isPlainObject(original)) throw new TypeError(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(MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		const value = original[key];
+		validators[key] = (Array.isArray(value) ? value : [value]).filter((item) => {
+			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key));
+			return true;
+		});
+	}
+	return validators;
+}
+export { getProperties };

package/dist/validation/value.validation.js

@@ -1,42 +1,30 @@
-import "../constants.js";
-import { smush } from "@oscarpalmer/atoms/value/misc";
-function validateType(type, property, value) {
-	switch (true) {
-		case typeof type === "function": return type(value);
-		case typeof type === "string": return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
-		default: return type.is(value);
-	}
-}
-function validateValue(validated, obj) {
-	if (typeof obj !== "object" || obj === null) return false;
-	const { keys, properties } = validated;
-	const keysLength = keys.array.length;
-	const ignore = /* @__PURE__ */ new Set();
-	const smushed = smush(obj);
-	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
-		const key = keys.array[keyIndex];
-		const prefix = key.replace(EXPRESSION_SUFFIX, "");
-		if (ignore.has(prefix)) continue;
-		const property = properties[key];
-		const value = smushed[key];
-		if (value === void 0 && property.required && !property.types.includes("undefined")) return false;
-		const typesLength = property.types.length;
-		if (typesLength === 1) {
-			if (!validateType(property.types[0], property, value)) return false;
-			continue;
-		}
+import { isSchematic } from "../helpers.js";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+function validateObject(obj, properties) {
+	if (!isPlainObject(obj)) return false;
+	const propertiesLength = properties.length;
+	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
+		const property = properties[propertyIndex];
+		const { key, required, types } = property;
+		const value = obj[key];
+		if (value === void 0 && required) return false;
+		const typesLength = types.length;
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			const type = property.types[typeIndex];
-			if (validateType(type, property, value)) {
-				if (type !== "object") ignore.add(key);
-				continue outer;
-			}
+			const type = types[typeIndex];
+			if (validateValue(type, property, value)) continue outer;
 		}
 		return false;
 	}
 	return true;
 }
-var EXPRESSION_SUFFIX = /\.\w+$/;
+function validateValue(type, property, value) {
+	switch (true) {
+		case isSchematic(type): return type.is(value);
+		case typeof type === "function": return type(value);
+		case typeof type === "object": return validateObject(value, [type]);
+		default: return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
+	}
+}
 var validators = {
 	array: Array.isArray,
 	bigint: (value) => typeof value === "bigint",
@@ -44,10 +32,10 @@ var validators = {
 	date: (value) => value instanceof Date,
 	function: (value) => typeof value === "function",
 	null: (value) => value === null,
-	number: (value) => typeof value === "number" && !Number.isNaN(value),
+	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
 };
-export { validateType, validateValue };
+export { validateObject };

package/package.json

@@ -45,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.11.0"
+	"version": "0.13.0"
 }

package/src/constants.ts

@@ -2,17 +2,23 @@ import type {ValueName} from './models';
 
 export const ERROR_NAME = 'SchematicError';
 
-export const EXPRESSION_HAS_NUMBER = /\d+/;
-
 export const EXPRESSION_INDEX = /\.\d+$/;
 
-export const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+export const EXPRESSION_KEY_PREFIX = /\.\w+$/;
+
+export const EXPRESSION_KEY_VALUE = /^.*\.(\w+)$/;
+
+export const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 
 export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
 
 export const MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
 
-export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED =
+	"'<>.$required' property is not allowed for schemas in $type";
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE =
+	"'<>.$required' property must be a boolean";
 
 export const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 

package/src/{is.ts → helpers.ts}

@@ -3,7 +3,7 @@ import {MESSAGE_CONSTRUCTOR, SCHEMATIC_NAME} from './constants';
 import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
-export function isInstance<Instance>(
+export function instanceOf<Instance>(
 	constructor: Constructor<Instance>,
 ): (value: unknown) => value is Instance {
 	if (!isConstructor(constructor)) {

package/src/index.ts

@@ -1,3 +1,3 @@
-export {isInstance} from './is';
+export {instanceOf} from './helpers';
 export {SchematicError, type Schema, type TypedSchema} from './models';
 export {schematic, type Schematic} from './schematic';