@oscarpalmer/jhunal 0.12.0 → 0.14.0

package/dist/constants.js

@@ -1,10 +1,8 @@
 const ERROR_NAME = "SchematicError";
-const EXPRESSION_INDEX = /\.\d+$/;
-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_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
 const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$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";
@@ -16,6 +14,8 @@ const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
 const TEMPLATE_PATTERN = "<>";
+const TEMPLATE_PATTERN_KEY = "<key>";
+const TEMPLATE_PATTERN_PROPERTY = "<property>";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
 const VALIDATABLE_TYPES = new Set([
@@ -34,4 +34,4 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
-export { ERROR_NAME, EXPRESSION_INDEX, EXPRESSION_KEY_PREFIX, EXPRESSION_KEY_VALUE, 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_PROPERTY, MESSAGE_CONSTRUCTOR, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, 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, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { instanceOf } from "./is.js";
+import { instanceOf } from "./helpers.js";
 import { SchematicError } from "./models.js";
 import { schematic } from "./schematic.js";
 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,10 @@ function join(value, delimiter) {
 	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
 }
 const ERROR_NAME = "SchematicError";
-const EXPRESSION_INDEX = /\.\d+$/;
-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_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
 const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$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";
@@ -76,6 +66,8 @@ const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
 const TEMPLATE_PATTERN = "<>";
+const TEMPLATE_PATTERN_KEY = "<key>";
+const TEMPLATE_PATTERN_PROPERTY = "<property>";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
 const VALIDATABLE_TYPES = new Set([
@@ -109,87 +101,49 @@ 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;
+function getDisallowedProperty(obj) {
+	if (PROPERTY_REQUIRED in obj) return PROPERTY_REQUIRED;
+	if (PROPERTY_TYPE in obj) return PROPERTY_TYPE;
+	if (PROPERTY_VALIDATORS in obj) return PROPERTY_VALIDATORS;
 }
-/**
-* 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 getKeyPrefix(key) {
-	const prefix = key.replace(EXPRESSION_KEY_PREFIX, "");
-	return prefix === key ? void 0 : prefix;
-}
-function getKeyValue(key) {
-	return key.replace(EXPRESSION_KEY_VALUE, "$1");
-}
-function getProperties(original) {
+function getProperties(original, prefix, fromType) {
 	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
-	const smushed = smush(original);
-	const keys = Object.keys(smushed);
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		if (property != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix).replace(TEMPLATE_PATTERN_PROPERTY, property));
+	}
+	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 keyPrefix = getKeyPrefix(key);
-		const keyValue = getKeyValue(key);
-		const value = smushed[key];
+		if (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(...getTypes(key, value[PROPERTY_TYPE]));
-			else types.push(TYPE_OBJECT);
-		} else types.push(...getTypes(key, value));
+			if (PROPERTY_TYPE in value) types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
+			else types.push(TYPE_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,
-			key: {
-				full: key,
-				prefix: keyPrefix,
-				value: keyValue
-			},
 			required: required && !types.includes(TYPE_UNDEFINED)
 		});
 	}
 	return properties;
 }
-function getRequired(key, value) {
-	if (!(PROPERTY_REQUIRED in value)) return;
-	if (typeof value[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
-	return value[PROPERTY_REQUIRED];
+function getRequired(key, obj) {
+	if (!(PROPERTY_REQUIRED in obj)) return;
+	if (typeof obj[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
+	return obj[PROPERTY_REQUIRED];
 }
-function getTypes(key, original) {
+function getTypes(key, original, prefix, fromType) {
 	const array = Array.isArray(original) ? original : [original];
 	const { length } = array;
 	const types = [];
@@ -200,7 +154,7 @@ function getTypes(key, original) {
 				types.push(isConstructor(value) ? instanceOf(value) : value);
 				break;
 			case isPlainObject(value):
-				types.push(schematic(value));
+				types.push(...getProperties(value, join([prefix, key], "."), fromType));
 				break;
 			case isSchematic(value):
 				types.push(value);
@@ -208,10 +162,10 @@ function getTypes(key, original) {
 			case TYPE_ALL.has(value):
 				types.push(value);
 				break;
-			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
+			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
 		}
 	}
-	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
+	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
 	return types;
 }
 function getValidators(original) {
@@ -233,27 +187,16 @@ function getValidators(original) {
 }
 function validateObject(obj, properties) {
 	if (!isPlainObject(obj)) return false;
-	const ignoredKeys = /* @__PURE__ */ new Set();
 	const propertiesLength = properties.length;
-	let key;
-	let value;
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
 		const property = properties[propertyIndex];
-		if (ignoredKeys.has(property.key.prefix)) {
-			key = void 0;
-			ignoredKeys.add(property.key.full);
-			continue;
-		}
-		key = property.key.full;
-		value = obj[key];
-		if (value === void 0 && property.required) return false;
-		const typesLength = property.types.length;
+		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 (validateValue(type, property, value)) {
-				ignoredKeys.add(property.key.full);
-				continue outer;
-			}
+			const type = types[typeIndex];
+			if (validateValue(type, property, value)) continue outer;
 		}
 		return false;
 	}
@@ -261,8 +204,9 @@ function validateObject(obj, properties) {
 }
 function validateValue(type, property, value) {
 	switch (true) {
-		case typeof type === "function": return type(value);
 		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);
 	}
 }

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,5 +1,5 @@
 import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.js";
-import { isSchematic } from "./is.js";
+import { isSchematic } from "./helpers.js";
 import { SchematicError } from "./models.js";
 import { getProperties } from "./validation/property.validation.js";
 import { validateObject } from "./validation/value.validation.js";

package/dist/validation/property.validation.js

@@ -1,57 +1,51 @@
-import { EXPRESSION_INDEX, EXPRESSION_KEY_PREFIX, EXPRESSION_KEY_VALUE, EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, 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_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
-import { instanceOf, isSchematic } from "../is.js";
+import { EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
+import { instanceOf, isSchematic } from "../helpers.js";
 import { SchematicError } from "../models.js";
-import { schematic } from "../schematic.js";
+import { join } from "../node_modules/@oscarpalmer/atoms/dist/internal/string.js";
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-import { smush } from "@oscarpalmer/atoms/value/misc";
-function getKeyPrefix(key) {
-	const prefix = key.replace(EXPRESSION_KEY_PREFIX, "");
-	return prefix === key ? void 0 : prefix;
+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 getKeyValue(key) {
-	return key.replace(EXPRESSION_KEY_VALUE, "$1");
-}
-function getProperties(original) {
+function getProperties(original, prefix, fromType) {
 	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
-	const smushed = smush(original);
-	const keys = Object.keys(smushed);
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		if (property != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix).replace(TEMPLATE_PATTERN_PROPERTY, property));
+	}
+	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 keyPrefix = getKeyPrefix(key);
-		const keyValue = getKeyValue(key);
-		const value = smushed[key];
+		if (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(...getTypes(key, value[PROPERTY_TYPE]));
-			else types.push(TYPE_OBJECT);
-		} else types.push(...getTypes(key, value));
+			if ("$type" in value) types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
+			else types.push(TYPE_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,
-			key: {
-				full: key,
-				prefix: keyPrefix,
-				value: keyValue
-			},
 			required: required && !types.includes("undefined")
 		});
 	}
 	return properties;
 }
-function getRequired(key, value) {
-	if (!("$required" in value)) return;
-	if (typeof value["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
-	return value[PROPERTY_REQUIRED];
+function getRequired(key, obj) {
+	if (!("$required" in obj)) return;
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+	return obj[PROPERTY_REQUIRED];
 }
-function getTypes(key, original) {
+function getTypes(key, original, prefix, fromType) {
 	const array = Array.isArray(original) ? original : [original];
 	const { length } = array;
 	const types = [];
@@ -62,7 +56,7 @@ function getTypes(key, original) {
 				types.push(isConstructor(value) ? instanceOf(value) : value);
 				break;
 			case isPlainObject(value):
-				types.push(schematic(value));
+				types.push(...getProperties(value, join([prefix, key], "."), fromType));
 				break;
 			case isSchematic(value):
 				types.push(value);
@@ -70,10 +64,10 @@ function getTypes(key, original) {
 			case TYPE_ALL.has(value):
 				types.push(value);
 				break;
-			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", key));
+			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("<>", key));
+	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 	return types;
 }
 function getValidators(original) {

package/dist/validation/value.validation.js

@@ -1,28 +1,17 @@
-import { isSchematic } from "../is.js";
+import { isSchematic } from "../helpers.js";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 function validateObject(obj, properties) {
 	if (!isPlainObject(obj)) return false;
-	const ignoredKeys = /* @__PURE__ */ new Set();
 	const propertiesLength = properties.length;
-	let key;
-	let value;
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
 		const property = properties[propertyIndex];
-		if (ignoredKeys.has(property.key.prefix)) {
-			key = void 0;
-			ignoredKeys.add(property.key.full);
-			continue;
-		}
-		key = property.key.full;
-		value = obj[key];
-		if (value === void 0 && property.required) return false;
-		const typesLength = property.types.length;
+		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 (validateValue(type, property, value)) {
-				ignoredKeys.add(property.key.full);
-				continue outer;
-			}
+			const type = types[typeIndex];
+			if (validateValue(type, property, value)) continue outer;
 		}
 		return false;
 	}
@@ -30,8 +19,9 @@ function validateObject(obj, properties) {
 }
 function validateValue(type, property, value) {
 	switch (true) {
-		case typeof type === "function": return type(value);
 		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);
 	}
 }

package/package.json

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

package/src/constants.ts

@@ -2,19 +2,17 @@ import type {ValueName} from './models';
 
 export const ERROR_NAME = 'SchematicError';
 
-export const EXPRESSION_INDEX = /\.\d+$/;
-
-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_DISALLOWED =
+	"'<key>.<property>' property is not allowed for schemas in $type";
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED =
+	"'<>.$required' property must be a boolean";
 
 export const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 
@@ -37,6 +35,10 @@ export const SCHEMATIC_NAME = '$schematic';
 
 export const TEMPLATE_PATTERN = '<>';
 
+export const TEMPLATE_PATTERN_KEY = '<key>';
+
+export const TEMPLATE_PATTERN_PROPERTY = '<property>';
+
 export const TYPE_OBJECT = 'object';
 
 export const TYPE_UNDEFINED = 'undefined';

package/src/index.ts

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

package/src/models.ts

@@ -109,6 +109,10 @@ type OptionalKeys<Value> = {
 	[Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
 
+type PlainSchema = {
+	[key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
+};
+
 type PropertyValidators<Value> = {
 	[Key in ExtractValueNames<Value>]?:
 		| ((value: Values[Key]) => boolean)
@@ -135,7 +139,7 @@ interface SchemaIndex {
 }
 
 /**
- * A property definition with explicit type(s) and optional requirement flag
+ * A property definition with explicit type(s), optional requirement flag, and optional validators
  */
 export type SchemaProperty = {
 	$required?: boolean;
@@ -145,7 +149,7 @@ export type SchemaProperty = {
 
 type SchemaPropertyType =
 	| Constructor
-	| Schema
+	| PlainSchema
 	| Schematic<unknown>
 	| ValueName
 	| ((value: unknown) => boolean);
@@ -290,19 +294,17 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
 		: Value;
 
 export type ValidatedProperty = {
-	key: ValidatedPropertyKey;
+	key: string;
 	required: boolean;
 	types: ValidatedPropertyType[];
 	validators: ValidatedPropertyValidators;
 };
 
-export type ValidatedPropertyKey = {
-	full: string;
-	prefix: string | undefined;
-	value: string;
-};
-
-export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValueName;
+export type ValidatedPropertyType =
+	| GenericCallback
+	| Schematic<unknown>
+	| ValidatedProperty
+	| ValueName;
 
 export type ValidatedPropertyValidators = {
 	[Key in ValueName]?: Array<(value: unknown) => boolean>;

package/src/schematic.ts

@@ -1,7 +1,7 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME} from './constants';
-import {isSchematic} from './is';
+import {isSchematic} from './helpers';
 import {
 	SchematicError,
 	type Infer,

package/src/validation/property.validation.ts

@@ -1,12 +1,10 @@
 import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value/misc';
+import {join} from '@oscarpalmer/atoms/string/misc';
 import {
-	EXPRESSION_INDEX,
-	EXPRESSION_KEY_PREFIX,
-	EXPRESSION_KEY_VALUE,
 	EXPRESSION_PROPERTY,
 	MESSAGE_SCHEMA_INVALID_EMPTY,
+	MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
 	MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
 	MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
 	MESSAGE_VALIDATOR_INVALID_KEY,
@@ -16,12 +14,14 @@ import {
 	PROPERTY_TYPE,
 	PROPERTY_VALIDATORS,
 	TEMPLATE_PATTERN,
+	TEMPLATE_PATTERN_KEY,
+	TEMPLATE_PATTERN_PROPERTY,
 	TYPE_ALL,
 	TYPE_OBJECT,
 	TYPE_UNDEFINED,
 	VALIDATABLE_TYPES,
 } from '../constants';
-import {instanceOf, isSchematic} from '../is';
+import {instanceOf, isSchematic} from '../helpers';
 import {
 	SchematicError,
 	type ValidatedProperty,
@@ -29,25 +29,44 @@ import {
 	type ValidatedPropertyValidators,
 	type ValueName,
 } from '../models';
-import {schematic} from '../schematic';
 
-function getKeyPrefix(key: string): string | undefined {
-	const prefix = key.replace(EXPRESSION_KEY_PREFIX, '');
+function getDisallowedProperty(obj: PlainObject): string | undefined {
+	if (PROPERTY_REQUIRED in obj) {
+		return PROPERTY_REQUIRED;
+	}
 
-	return prefix === key ? undefined : prefix;
-}
+	if (PROPERTY_TYPE in obj) {
+		return PROPERTY_TYPE;
+	}
 
-function getKeyValue(key: string): string {
-	return key.replace(EXPRESSION_KEY_VALUE, '$1');
+	if (PROPERTY_VALIDATORS in obj) {
+		return PROPERTY_VALIDATORS;
+	}
 }
 
-export function getProperties(original: PlainObject): ValidatedProperty[] {
+export function getProperties(
+	original: PlainObject,
+	prefix?: string,
+	fromType?: boolean,
+): ValidatedProperty[] {
 	if (Object.keys(original).length === 0) {
 		throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
 	}
 
-	const smushed = smush(original);
-	const keys = Object.keys(smushed);
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+
+		if (property != null) {
+			throw new SchematicError(
+				MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix!).replace(
+					TEMPLATE_PATTERN_PROPERTY,
+					property,
+				),
+			);
+		}
+	}
+
+	const keys = Object.keys(original);
 	const keysLength = keys.length;
 
 	const properties: ValidatedProperty[] = [];
@@ -55,13 +74,11 @@ export function getProperties(original: PlainObject): ValidatedProperty[] {
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 
-		if (EXPRESSION_INDEX.test(key) || EXPRESSION_PROPERTY.test(key)) {
+		if (EXPRESSION_PROPERTY.test(key)) {
 			continue;
 		}
 
-		const keyPrefix = getKeyPrefix(key);
-		const keyValue = getKeyValue(key);
-		const value = smushed[key];
+		const value = original[key];
 
 		const types: ValidatedPropertyType[] = [];
 
@@ -73,12 +90,12 @@ export function getProperties(original: PlainObject): ValidatedProperty[] {
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
 
 			if (PROPERTY_TYPE in value) {
-				types.push(...getTypes(key, value[PROPERTY_TYPE]));
+				types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
 			} else {
-				types.push(TYPE_OBJECT);
+				types.push(TYPE_OBJECT, ...getTypes(key, value, prefix));
 			}
 		} else {
-			types.push(...getTypes(key, value));
+			types.push(...getTypes(key, value, prefix));
 		}
 
 		if (!required && !types.includes(TYPE_UNDEFINED)) {
@@ -86,13 +103,9 @@ export function getProperties(original: PlainObject): ValidatedProperty[] {
 		}
 
 		properties.push({
+			key,
 			types,
 			validators,
-			key: {
-				full: key,
-				prefix: keyPrefix,
-				value: keyValue,
-			},
 			required: required && !types.includes(TYPE_UNDEFINED),
 		});
 	}
@@ -100,21 +113,26 @@ export function getProperties(original: PlainObject): ValidatedProperty[] {
 	return properties;
 }
 
-function getRequired(key: string, value: PlainObject): boolean | undefined {
-	if (!(PROPERTY_REQUIRED in value)) {
+function getRequired(key: string, obj: PlainObject): boolean | undefined {
+	if (!(PROPERTY_REQUIRED in obj)) {
 		return;
 	}
 
-	if (typeof value[PROPERTY_REQUIRED] !== 'boolean') {
+	if (typeof obj[PROPERTY_REQUIRED] !== 'boolean') {
 		throw new SchematicError(
 			MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
 		);
 	}
 
-	return value[PROPERTY_REQUIRED];
+	return obj[PROPERTY_REQUIRED];
 }
 
-function getTypes(key: string, original: unknown): ValidatedPropertyType[] {
+function getTypes(
+	key: string,
+	original: unknown,
+	prefix?: string,
+	fromType?: boolean,
+): ValidatedPropertyType[] {
 	const array = Array.isArray(original) ? original : [original];
 	const {length} = array;
 
@@ -129,7 +147,7 @@ function getTypes(key: string, original: unknown): ValidatedPropertyType[] {
 				break;
 
 			case isPlainObject(value):
-				types.push(schematic(value as never));
+				types.push(...getProperties(value, join([prefix, key], '.'), fromType));
 				break;
 
 			case isSchematic(value):
@@ -142,13 +160,15 @@ function getTypes(key: string, original: unknown): ValidatedPropertyType[] {
 
 			default:
 				throw new SchematicError(
-					MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key),
+					MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], '.')),
 				);
 		}
 	}
 
 	if (types.length === 0) {
-		throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
+		throw new SchematicError(
+			MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], '.')),
+		);
 	}
 
 	return types;

package/src/validation/value.validation.ts

@@ -1,5 +1,5 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
-import {isSchematic} from '../is';
+import {isSchematic} from '../helpers';
 import type {ValidatedProperty, ValidatedPropertyType, ValueName} from '../models';
 
 export function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean {
@@ -7,44 +7,25 @@ export function validateObject(obj: unknown, properties: ValidatedProperty[]): b
 		return false;
 	}
 
-	const ignoredKeys = new Set<string>();
 	const propertiesLength = properties.length;
 
-	let key!: string;
-	let value!: unknown;
-
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
 		const property = properties[propertyIndex];
 
-		if (ignoredKeys.has(property.key.prefix!)) {
-			key = undefined as never;
-
-			ignoredKeys.add(property.key.full);
-
-			continue;
-		}
-
-		/* if (key == null || !property.key.full.startsWith(key)) {
-			value = obj[property.key.full];
-		} else {
-			value = (value as PlainObject)?.[property.key.value];
-		} */
+		const {key, required, types} = property;
 
-		key = property.key.full;
-		value = obj[key];
+		const value = obj[key];
 
-		if (value === undefined && property.required) {
+		if (value === undefined && required) {
 			return false;
 		}
 
-		const typesLength = property.types.length;
+		const typesLength = types.length;
 
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			const type = property.types[typeIndex];
+			const type = types[typeIndex];
 
 			if (validateValue(type, property, value)) {
-				ignoredKeys.add(property.key.full);
-
 				continue outer;
 			}
 		}
@@ -61,11 +42,14 @@ function validateValue(
 	value: unknown,
 ): boolean {
 	switch (true) {
+		case isSchematic(type):
+			return type.is(value);
+
 		case typeof type === 'function':
 			return (type as (value: unknown) => boolean)(value);
 
-		case isSchematic(type):
-			return type.is(value);
+		case typeof type === 'object':
+			return validateObject(value, [type] as ValidatedProperty[]);
 
 		default:
 			return (

package/types/constants.d.ts

@@ -1,10 +1,8 @@
 export declare const ERROR_NAME = "SchematicError";
-export declare const EXPRESSION_INDEX: RegExp;
-export declare const EXPRESSION_KEY_PREFIX: RegExp;
-export declare const EXPRESSION_KEY_VALUE: RegExp;
 export declare const EXPRESSION_PROPERTY: RegExp;
 export declare const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 export declare const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
+export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
 export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 export declare const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
@@ -16,6 +14,8 @@ export declare const PROPERTY_TYPE = "$type";
 export declare const PROPERTY_VALIDATORS = "$validators";
 export declare const SCHEMATIC_NAME = "$schematic";
 export declare const TEMPLATE_PATTERN = "<>";
+export declare const TEMPLATE_PATTERN_KEY = "<key>";
+export declare const TEMPLATE_PATTERN_PROPERTY = "<property>";
 export declare const TYPE_OBJECT = "object";
 export declare const TYPE_UNDEFINED = "undefined";
 export declare const VALIDATABLE_TYPES: Set<keyof import("./models").Values>;

package/types/index.d.ts

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

package/types/models.d.ts

@@ -42,6 +42,9 @@ export type NestedSchema = {
 type OptionalKeys<Value> = {
     [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
+type PlainSchema = {
+    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
+};
 type PropertyValidators<Value> = {
     [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean>;
 };
@@ -55,14 +58,14 @@ interface SchemaIndex {
     [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 }
 /**
- * A property definition with explicit type(s) and optional requirement flag
+ * A property definition with explicit type(s), optional requirement flag, and optional validators
  */
 export type SchemaProperty = {
     $required?: boolean;
     $type: SchemaPropertyType | SchemaPropertyType[];
     $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
-type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
 export declare class SchematicError extends Error {
     constructor(message: string);
 }
@@ -123,17 +126,12 @@ type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => voi
 type UnionToTuple<Value, Items extends unknown[] = []> = [Value] extends [never] ? Items : UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Items]>;
 type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
 export type ValidatedProperty = {
-    key: ValidatedPropertyKey;
+    key: string;
     required: boolean;
     types: ValidatedPropertyType[];
     validators: ValidatedPropertyValidators;
 };
-export type ValidatedPropertyKey = {
-    full: string;
-    prefix: string | undefined;
-    value: string;
-};
-export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValueName;
+export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValidatedProperty | ValueName;
 export type ValidatedPropertyValidators = {
     [Key in ValueName]?: Array<(value: unknown) => boolean>;
 };

package/types/validation/property.validation.d.ts

@@ -1,3 +1,3 @@
 import type { PlainObject } from '@oscarpalmer/atoms/models';
 import { type ValidatedProperty } from '../models';
-export declare function getProperties(original: PlainObject): ValidatedProperty[];
+export declare function getProperties(original: PlainObject, prefix?: string, fromType?: boolean): ValidatedProperty[];