@oscarpalmer/jhunal 0.11.0 → 0.13.0

package/src/models.ts

@@ -1,4 +1,4 @@
-import type {PlainObject, Simplify} from '@oscarpalmer/atoms/models';
+import type {GenericCallback, PlainObject, Simplify} from '@oscarpalmer/atoms/models';
 import {ERROR_NAME} from './constants';
 import type {Schematic} from './schematic';
 
@@ -122,10 +122,16 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  */
 export type Schema = SchemaIndex;
 
-type SchemaEntry = Constructor | SchemaProperty | Schematic<unknown> | ValueName | NestedSchema;
+type SchemaEntry =
+	| Constructor
+	| Schema
+	| SchemaProperty
+	| Schematic<unknown>
+	| ValueName
+	| ((value: unknown) => boolean);
 
 interface SchemaIndex {
-	[key: string]: SchemaEntry | SchemaEntry[];
+	[key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 }
 
 /**
@@ -137,7 +143,12 @@ export type SchemaProperty = {
 	$validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 
-type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+type SchemaPropertyType =
+	| Constructor
+	| Schema
+	| Schematic<unknown>
+	| ValueName
+	| ((value: unknown) => boolean);
 
 export class SchematicError extends Error {
 	constructor(message: string) {
@@ -279,25 +290,22 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
 		: Value;
 
 export type ValidatedProperty = {
+	key: string;
 	required: boolean;
 	types: ValidatedPropertyType[];
 	validators: ValidatedPropertyValidators;
 };
 
-export type ValidatedPropertyType = Schematic<unknown> | ValueName;
+export type ValidatedPropertyType =
+	| GenericCallback
+	| Schematic<unknown>
+	| ValidatedProperty
+	| ValueName;
 
 export type ValidatedPropertyValidators = {
 	[Key in ValueName]?: Array<(value: unknown) => boolean>;
 };
 
-export type ValidatedSchema = {
-	keys: {
-		array: string[];
-		set: Set<string>;
-	};
-	properties: Record<string, ValidatedProperty>;
-};
-
 /**
  * Valid type name strings
  */

package/src/schematic.ts

@@ -1,15 +1,16 @@
 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 './helpers';
 import {
 	SchematicError,
 	type Infer,
 	type Schema,
 	type TypedSchema,
-	type ValidatedSchema,
+	type ValidatedProperty,
 } from './models';
-import {getSchema} from './validation/schema.validation';
-import {validateValue} from './validation/value.validation';
+import {getProperties} from './validation/property.validation';
+import {validateObject} from './validation/value.validation';
 
 /**
  * A schematic for validating objects
@@ -17,21 +18,21 @@ import {validateValue} from './validation/value.validation';
 export class Schematic<Model> {
 	declare private readonly $schematic: true;
 
-	#schema: ValidatedSchema;
+	#properties: ValidatedProperty[];
 
-	constructor(schema: ValidatedSchema) {
+	constructor(properties: ValidatedProperty[]) {
 		Object.defineProperty(this, SCHEMATIC_NAME, {
 			value: true,
 		});
 
-		this.#schema = schema;
+		this.#properties = properties;
 	}
 
 	/**
 	 * Does the value match the schema?
 	 */
 	is(value: unknown): value is Model {
-		return validateValue(this.#schema, value);
+		return validateObject(value, this.#properties);
 	}
 }
 
@@ -46,11 +47,13 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Infer<
 export function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
 
 export function schematic<Model extends Schema>(schema: Model): Schematic<Model> {
+	if (isSchematic(schema)) {
+		return schema;
+	}
+
 	if (!isPlainObject(schema)) {
 		throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
 	}
 
-	const validated = getSchema(schema);
-
-	return new Schematic<Model>(validated);
+	return new Schematic<Model>(getProperties(schema));
 }

package/src/validation/property.validation.ts

@@ -0,0 +1,187 @@
+import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {join} from '@oscarpalmer/atoms/string/misc';
+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,
+	TEMPLATE_PATTERN,
+	TYPE_ALL,
+	TYPE_UNDEFINED,
+	VALIDATABLE_TYPES,
+} from '../constants';
+import {instanceOf, isSchematic} from '../helpers';
+import {
+	SchematicError,
+	type ValidatedProperty,
+	type ValidatedPropertyType,
+	type ValidatedPropertyValidators,
+	type ValueName,
+} from '../models';
+
+export function getProperties(
+	original: PlainObject,
+	prefix?: string,
+	fromTypes?: boolean,
+): ValidatedProperty[] {
+	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: ValidatedProperty[] = [];
+
+	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: ValidatedPropertyType[] = [];
+
+		let required = true;
+		let validators: ValidatedPropertyValidators = {};
+
+		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),
+		});
+	}
+
+	return properties;
+}
+
+function getRequired(key: string, obj: PlainObject): boolean | undefined {
+	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(
+	key: string,
+	original: unknown,
+	prefix?: string,
+	fromTypes?: boolean,
+): ValidatedPropertyType[] {
+	const array = Array.isArray(original) ? original : [original];
+	const {length} = array;
+
+	const types: ValidatedPropertyType[] = [];
+
+	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 as never):
+				types.push(value as never);
+				break;
+
+			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, join([prefix, key], '.')),
+		);
+	}
+
+	return types;
+}
+
+function getValidators(original: unknown): ValidatedPropertyValidators {
+	const validators: ValidatedPropertyValidators = {};
+
+	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 as never)) {
+			throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+		}
+
+		const value = (original as PlainObject)[key];
+
+		validators[key as ValueName] = (Array.isArray(value) ? value : [value]).filter(item => {
+			if (typeof item !== 'function') {
+				throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key));
+			}
+
+			return true;
+		});
+	}
+
+	return validators;
+}

package/src/validation/value.validation.ts

@@ -1,74 +1,31 @@
-import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value/misc';
-import {TYPE_UNDEFINED} from '../constants';
-import type {ValidatedProperty, ValidatedPropertyType, ValidatedSchema, Values} from '../models';
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {isSchematic} from '../helpers';
+import type {ValidatedProperty, ValidatedPropertyType, ValueName} from '../models';
 
-export function validateType(
-	type: ValidatedPropertyType,
-	property: ValidatedProperty,
-	value: unknown,
-): boolean {
-	switch (true) {
-		case typeof type === 'function':
-			return (type as any)(value);
-
-		case typeof type === 'string':
-			return (
-				validators[type](value) &&
-				(property.validators[type]?.every(validator => validator(value)) ?? true)
-			);
-
-		default:
-			return type.is(value);
-	}
-}
-
-export function validateValue(validated: ValidatedSchema, obj: unknown): boolean {
-	if (typeof obj !== 'object' || obj === null) {
+export function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean {
+	if (!isPlainObject(obj)) {
 		return false;
 	}
 
-	const {keys, properties} = validated;
-	const keysLength = keys.array.length;
+	const propertiesLength = properties.length;
 
-	const ignore = new Set<string>();
+	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
+		const property = properties[propertyIndex];
 
-	const smushed = smush(obj as PlainObject);
+		const {key, required, types} = property;
 
-	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
-		const key = keys.array[keyIndex];
+		const value = obj[key];
 
-		const prefix = key.replace(EXPRESSION_SUFFIX, '');
-
-		if (ignore.has(prefix)) {
-			continue;
-		}
-
-		const property = properties[key];
-		const value = smushed[key];
-
-		if (value === undefined && property.required && !property.types.includes(TYPE_UNDEFINED)) {
+		if (value === undefined && required) {
 			return false;
 		}
 
-		const typesLength = property.types.length;
-
-		if (typesLength === 1) {
-			if (!validateType(property.types[0], property, value)) {
-				return false;
-			}
-
-			continue;
-		}
+		const typesLength = types.length;
 
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			const type = property.types[typeIndex];
-
-			if (validateType(type, property, value)) {
-				if ((type as never) !== 'object') {
-					ignore.add(key);
-				}
+			const type = types[typeIndex];
 
+			if (validateValue(type, property, value)) {
 				continue outer;
 			}
 		}
@@ -79,20 +36,39 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 	return true;
 }
 
-//
+function validateValue(
+	type: ValidatedPropertyType,
+	property: ValidatedProperty,
+	value: unknown,
+): boolean {
+	switch (true) {
+		case isSchematic(type):
+			return type.is(value);
+
+		case typeof type === 'function':
+			return (type as (value: unknown) => boolean)(value);
 
-const EXPRESSION_SUFFIX = /\.\w+$/;
+		case typeof type === 'object':
+			return validateObject(value, [type] as ValidatedProperty[]);
+
+		default:
+			return (
+				validators[type as ValueName](value) &&
+				(property.validators[type as ValueName]?.every(validator => validator(value)) ?? true)
+			);
+	}
+}
 
 //
 
-const validators: Record<keyof Values, (value: unknown) => boolean> = {
+const validators: Record<ValueName, (value: unknown) => boolean> = {
 	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' && !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',

package/types/constants.d.ts

@@ -1,10 +1,12 @@
 export declare const ERROR_NAME = "SchematicError";
-export declare const EXPRESSION_HAS_NUMBER: RegExp;
 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_REQUIRED = "'<>.$required' property must be a boolean";
+export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED = "'<>.$required' property is not allowed for schemas in $type";
+export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE = "'<>.$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";
 export declare const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";

package/types/{is.d.ts → helpers.d.ts}

@@ -1,4 +1,4 @@
 import type { Constructor } from './models';
 import type { Schematic } from './schematic';
-export declare function isInstance<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
+export declare function instanceOf<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
 export declare function isSchematic(value: unknown): value is Schematic<never>;

package/types/index.d.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';

package/types/models.d.ts

@@ -1,4 +1,4 @@
-import type { PlainObject, Simplify } from '@oscarpalmer/atoms/models';
+import type { GenericCallback, PlainObject, Simplify } from '@oscarpalmer/atoms/models';
 import type { Schematic } from './schematic';
 export type Constructor<Instance = any> = new (...args: any[]) => Instance;
 type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Value extends [
@@ -50,9 +50,9 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  * A schema for validating objects
  */
 export type Schema = SchemaIndex;
-type SchemaEntry = Constructor | SchemaProperty | Schematic<unknown> | ValueName | NestedSchema;
+type SchemaEntry = Constructor | Schema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
 interface SchemaIndex {
-    [key: string]: SchemaEntry | SchemaEntry[];
+    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 }
 /**
  * A property definition with explicit type(s) and optional requirement flag
@@ -62,7 +62,7 @@ export type SchemaProperty = {
     $type: SchemaPropertyType | SchemaPropertyType[];
     $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
-type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
 export declare class SchematicError extends Error {
     constructor(message: string);
 }
@@ -123,21 +123,15 @@ 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: string;
     required: boolean;
     types: ValidatedPropertyType[];
     validators: ValidatedPropertyValidators;
 };
-export type ValidatedPropertyType = Schematic<unknown> | ValueName;
+export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValidatedProperty | ValueName;
 export type ValidatedPropertyValidators = {
     [Key in ValueName]?: Array<(value: unknown) => boolean>;
 };
-export type ValidatedSchema = {
-    keys: {
-        array: string[];
-        set: Set<string>;
-    };
-    properties: Record<string, ValidatedProperty>;
-};
 /**
  * Valid type name strings
  */

package/types/schematic.d.ts

@@ -1,12 +1,12 @@
 import type { PlainObject } from '@oscarpalmer/atoms/models';
-import { type Infer, type Schema, type TypedSchema, type ValidatedSchema } from './models';
+import { type Infer, type Schema, type TypedSchema, type ValidatedProperty } from './models';
 /**
  * A schematic for validating objects
  */
 export declare class Schematic<Model> {
     #private;
     private readonly $schematic;
-    constructor(schema: ValidatedSchema);
+    constructor(properties: ValidatedProperty[]);
     /**
      * Does the value match the schema?
      */

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

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

package/types/validation/value.validation.d.ts

@@ -1,3 +1,2 @@
-import type { ValidatedProperty, ValidatedPropertyType, ValidatedSchema } from '../models';
-export declare function validateType(type: ValidatedPropertyType, property: ValidatedProperty, value: unknown): boolean;
-export declare function validateValue(validated: ValidatedSchema, obj: unknown): boolean;
+import type { ValidatedProperty } from '../models';
+export declare function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean;

package/dist/validation/schema.validation.js

@@ -1,105 +0,0 @@
-import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, 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 { isInstance, isSchematic } from "../is.js";
-import { SchematicError } from "../models.js";
-import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-import { smush } from "@oscarpalmer/atoms/value/misc";
-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: {}
-		};
-	}
-	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
-	to.properties[key].validators = validators;
-}
-function getSchema(schema) {
-	return getValidatedSchema(schema, {
-		keys: {
-			array: [],
-			set: /* @__PURE__ */ new Set()
-		},
-		properties: {}
-	});
-}
-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("<>", prefix));
-		if ("$type" in type) {
-			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
-			continue;
-		}
-		const { [PROPERTY_REQUIRED]: required, ...nested } = type;
-		if ("$required" in type && typeof required !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", 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}.`;
-	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 && "$required" in value) {
-			if (typeof value["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
-			required = value[PROPERTY_REQUIRED] === true;
-		}
-		if (isObject && "$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("<>", 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;
-}
-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 { getSchema };