@oscarpalmer/jhunal 0.10.0 → 0.11.0

package/dist/constants.js

@@ -1,23 +1,36 @@
+const ERROR_NAME = "SchematicError";
 const EXPRESSION_HAS_NUMBER = /\d+/;
 const EXPRESSION_INDEX = /\.\d+$/;
 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_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";
+const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
+const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
+const TEMPLATE_PATTERN = "<>";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
+const VALIDATABLE_TYPES = new Set([
 	"array",
 	"bigint",
 	"boolean",
 	"date",
 	"function",
-	"null",
 	"number",
 	"string",
 	"symbol",
-	TYPE_OBJECT,
+	TYPE_OBJECT
+]);
+const TYPE_ALL = new Set([
+	...VALIDATABLE_TYPES,
+	"null",
 	TYPE_UNDEFINED
 ]);
-export { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_NAME, TYPE_ALL, TYPE_OBJECT, 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 };

package/dist/index.js

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

package/dist/is.js

@@ -1,7 +1,7 @@
-import "./constants.js";
+import { MESSAGE_CONSTRUCTOR } from "./constants.js";
 import { isConstructor } from "@oscarpalmer/atoms/is";
 function isInstance(constructor) {
-	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
 	};

package/dist/jhunal.full.js

@@ -58,30 +58,43 @@ function getString(value) {
 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 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_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";
+const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
+const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
+const TEMPLATE_PATTERN = "<>";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
+const VALIDATABLE_TYPES = new Set([
 	"array",
 	"bigint",
 	"boolean",
 	"date",
 	"function",
-	"null",
 	"number",
 	"string",
 	"symbol",
-	TYPE_OBJECT,
+	TYPE_OBJECT
+]);
+const TYPE_ALL = new Set([
+	...VALIDATABLE_TYPES,
+	"null",
 	TYPE_UNDEFINED
 ]);
 function isInstance(constructor) {
-	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
 	};
@@ -89,6 +102,12 @@ function isInstance(constructor) {
 function isSchematic(value) {
 	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
 }
+var SchematicError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = ERROR_NAME;
+	}
+};
 function flattenObject(value, depth, smushed, prefix) {
 	if (depth >= MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
@@ -125,7 +144,7 @@ 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) if (!property.types.includes(type)) property.types.push(type);
+		for (const type of values) property.types.push(type);
 	} else {
 		to.keys.array.push(key);
 		to.keys.set.add(key);
@@ -139,15 +158,13 @@ function addPropertyType(to, key, values, validators, required) {
 	to.properties[key].validators = validators;
 }
 function getSchema(schema) {
-	const validated = {
-		enabled: false,
+	return getValidatedSchema(schema, {
 		keys: {
 			array: [],
 			set: /* @__PURE__ */ new Set()
 		},
 		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+	});
 }
 function getTypes(value, validated, prefix) {
 	const propertyTypes = [];
@@ -155,23 +172,24 @@ function getTypes(value, validated, prefix) {
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		const typeOfType = typeof type;
-		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
+		if (isSchematic(type) || TYPE_ALL.has(type)) {
 			propertyTypes.push(type);
 			continue;
 		}
-		if (typeOfType === "function") {
+		if (typeof type === "function") {
 			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 			continue;
 		}
-		if (typeOfType !== "object" || type === null) 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;
 		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
+		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(type, validated, prefix);
+		getValidatedSchema(nested, validated, prefix);
 	}
 	return propertyTypes;
 }
@@ -190,22 +208,35 @@ function getValidatedSchema(schema, validated, prefix) {
 		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
 		let validators = {};
-		const isObject = typeof value === "object" && value !== null;
-		if (isObject && PROPERTY_REQUIRED in value) required = typeof value[PROPERTY_REQUIRED] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		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;
+		}
 		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) addPropertyType(validated, prefixedKey, types, validators, required);
+		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;
 }
 function getValidators(original) {
 	const validators = {};
-	if (typeof original !== "object" || original === null) return validators;
-	for (const type of TYPE_ALL) {
-		const value = original[type];
-		validators[type] = (Array.isArray(value) ? value : [value]).filter((validator) => typeof validator === "function");
+	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(TEMPLATE_PATTERN, 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(TEMPLATE_PATTERN, key));
+			return true;
+		});
 	}
 	return validators;
 }
@@ -264,22 +295,19 @@ const validators = {
 */
 var Schematic = class {
 	#schema;
-	get enabled() {
-		return this.#schema.enabled;
-	}
 	constructor(schema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = getSchema(schema);
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#schema = schema;
 	}
 	/**
 	* Does the value match the schema?
 	*/
 	is(value) {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateValue(this.#schema, value);
 	}
 };
 function schematic(schema) {
-	return new Schematic(schema);
+	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	return new Schematic(getSchema(schema));
 }
-export { isInstance, schematic };
+export { SchematicError, isInstance, schematic };

package/dist/models.js

@@ -0,0 +1,8 @@
+import { ERROR_NAME } from "./constants.js";
+var SchematicError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = ERROR_NAME;
+	}
+};
+export { SchematicError };

package/dist/schematic.js

@@ -1,27 +1,26 @@
-import { SCHEMATIC_NAME } from "./constants.js";
+import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.js";
+import { SchematicError } from "./models.js";
 import { getSchema } from "./validation/schema.validation.js";
 import { validateValue } from "./validation/value.validation.js";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
 /**
 * A schematic for validating objects
 */
 var Schematic = class {
 	#schema;
-	get enabled() {
-		return this.#schema.enabled;
-	}
 	constructor(schema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = getSchema(schema);
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#schema = schema;
 	}
 	/**
 	* Does the value match the schema?
 	*/
 	is(value) {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateValue(this.#schema, value);
 	}
 };
 function schematic(schema) {
-	return new Schematic(schema);
+	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	return new Schematic(getSchema(schema));
 }
 export { Schematic, schematic };

package/dist/validation/schema.validation.js

@@ -1,11 +1,12 @@
-import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
+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 { smush } from "../node_modules/@oscarpalmer/atoms/dist/value/smush.js";
-import { isConstructor } from "@oscarpalmer/atoms/is";
+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) if (!property.types.includes(type)) property.types.push(type);
+		for (const type of values) property.types.push(type);
 	} else {
 		to.keys.array.push(key);
 		to.keys.set.add(key);
@@ -19,15 +20,13 @@ function addPropertyType(to, key, values, validators, required) {
 	to.properties[key].validators = validators;
 }
 function getSchema(schema) {
-	const validated = {
-		enabled: false,
+	return getValidatedSchema(schema, {
 		keys: {
 			array: [],
 			set: /* @__PURE__ */ new Set()
 		},
 		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+	});
 }
 function getTypes(value, validated, prefix) {
 	const propertyTypes = [];
@@ -35,23 +34,24 @@ function getTypes(value, validated, prefix) {
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		const typeOfType = typeof type;
-		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
+		if (isSchematic(type) || TYPE_ALL.has(type)) {
 			propertyTypes.push(type);
 			continue;
 		}
-		if (typeOfType === "function") {
+		if (typeof type === "function") {
 			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 			continue;
 		}
-		if (typeOfType !== "object" || type === null) 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;
 		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
+		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(type, validated, prefix);
+		getValidatedSchema(nested, validated, prefix);
 	}
 	return propertyTypes;
 }
@@ -70,22 +70,35 @@ function getValidatedSchema(schema, validated, prefix) {
 		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
 		let validators = {};
-		const isObject = typeof value === "object" && value !== null;
-		if (isObject && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		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) addPropertyType(validated, prefixedKey, types, validators, required);
+		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 (typeof original !== "object" || original === null) return validators;
-	for (const type of TYPE_ALL) {
-		const value = original[type];
-		validators[type] = (Array.isArray(value) ? value : [value]).filter((validator) => typeof validator === "function");
+	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;
 }

package/dist/validation/value.validation.js

@@ -1,5 +1,5 @@
 import "../constants.js";
-import { smush } from "../node_modules/@oscarpalmer/atoms/dist/value/smush.js";
+import { smush } from "@oscarpalmer/atoms/value/misc";
 function validateType(type, property, value) {
 	switch (true) {
 		case typeof type === "function": return type(value);

package/package.json

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

package/src/constants.ts

@@ -1,4 +1,6 @@
-import type {Values} from './models';
+import type {ValueName} from './models';
+
+export const ERROR_NAME = 'SchematicError';
 
 export const EXPRESSION_HAS_NUMBER = /\d+/;
 
@@ -6,6 +8,23 @@ export const EXPRESSION_INDEX = /\.\d+$/;
 
 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_TYPE = "'<>' property must be of a valid type";
+
+export const MESSAGE_SCHEMA_INVALID_TYPE = 'Schema must be an object';
+
+export const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
+
+export const MESSAGE_VALIDATOR_INVALID_TYPE = 'Validators must be an object';
+
+export const MESSAGE_VALIDATOR_INVALID_VALUE =
+	"Validator '<>' must be a function or an array of functions";
+
 export const PROPERTY_REQUIRED = '$required';
 
 export const PROPERTY_TYPE = '$type';
@@ -14,20 +33,22 @@ export const PROPERTY_VALIDATORS = '$validators';
 
 export const SCHEMATIC_NAME = '$schematic';
 
+export const TEMPLATE_PATTERN = '<>';
+
 export const TYPE_OBJECT = 'object';
 
 export const TYPE_UNDEFINED = 'undefined';
 
-export const TYPE_ALL = new Set<keyof Values>([
+export const VALIDATABLE_TYPES = new Set<ValueName>([
 	'array',
 	'bigint',
 	'boolean',
 	'date',
 	'function',
-	'null',
 	'number',
 	'string',
 	'symbol',
 	TYPE_OBJECT,
-	TYPE_UNDEFINED,
 ]);
+
+export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, 'null', TYPE_UNDEFINED]);

package/src/index.ts

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

package/src/is.ts

@@ -1,5 +1,5 @@
 import {isConstructor} from '@oscarpalmer/atoms/is';
-import {SCHEMATIC_NAME} from './constants';
+import {MESSAGE_CONSTRUCTOR, SCHEMATIC_NAME} from './constants';
 import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
@@ -7,7 +7,7 @@ export function isInstance<Instance>(
 	constructor: Constructor<Instance>,
 ): (value: unknown) => value is Instance {
 	if (!isConstructor(constructor)) {
-		throw new TypeError('Expected a constructor function');
+		throw new TypeError(MESSAGE_CONSTRUCTOR);
 	}
 
 	return (value: unknown): value is Instance => {

package/src/models.ts

@@ -1,4 +1,5 @@
 import type {PlainObject, Simplify} from '@oscarpalmer/atoms/models';
+import {ERROR_NAME} from './constants';
 import type {Schematic} from './schematic';
 
 export type Constructor<Instance = any> = new (...args: any[]) => Instance;
@@ -65,17 +66,23 @@ type InferSchemaEntryValue<Value> =
 			? Model
 			: Value extends SchemaProperty
 				? InferPropertyType<Value['$type']>
-				: Value extends ValueName
-					? Values[Value & ValueName]
-					: Value extends Schema
-						? Infer<Value>
-						: never;
+				: Value extends NestedSchema
+					? Infer<Omit<Value, '$required'>>
+					: Value extends ValueName
+						? Values[Value & ValueName]
+						: Value extends Schema
+							? Infer<Value>
+							: never;
 
 type IsOptionalProperty<Value> = Value extends SchemaProperty
 	? Value['$required'] extends false
 		? true
 		: false
-	: false;
+	: Value extends {$required?: boolean}
+		? Value extends {$required: false}
+			? true
+			: false
+		: false;
 
 type LastOfUnion<Value> =
 	UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item
@@ -95,7 +102,8 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  */
 export type NestedSchema = {
 	$required?: boolean;
-} & Schema;
+	[key: string]: any;
+};
 
 type OptionalKeys<Value> = {
 	[Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
@@ -114,7 +122,7 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  */
 export type Schema = SchemaIndex;
 
-type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
+type SchemaEntry = Constructor | SchemaProperty | Schematic<unknown> | ValueName | NestedSchema;
 
 interface SchemaIndex {
 	[key: string]: SchemaEntry | SchemaEntry[];
@@ -131,13 +139,23 @@ export type SchemaProperty = {
 
 type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
 
+export class SchematicError extends Error {
+	constructor(message: string) {
+		super(message);
+
+		this.name = ERROR_NAME;
+	}
+}
+
 type ToSchemaPropertyType<Value> = UnwrapSingle<
 	DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>
 >;
 
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject
-	? TypedSchema<Value>
-	: ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema
+	? Omit<Value, '$required'>
+	: Value extends PlainObject
+		? TypedSchema<Value>
+		: ToValueType<Value>;
 
 type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
 
@@ -149,21 +167,23 @@ type ToValueType<Value> = Value extends unknown[]
 			? 'boolean'
 			: Value extends Date
 				? 'date'
-				: Value extends Function
-					? 'function'
-					: Value extends null
-						? 'null'
-						: Value extends number
-							? 'number'
-							: Value extends object
-								? 'object' | ((value: unknown) => value is Value)
-								: Value extends string
-									? 'string'
-									: Value extends symbol
-										? 'symbol'
-										: Value extends undefined
-											? 'undefined'
-											: (value: unknown) => value is Value;
+				: Value extends Schematic<any>
+					? Value
+					: Value extends Function
+						? 'function'
+						: Value extends null
+							? 'null'
+							: Value extends number
+								? 'number'
+								: Value extends object
+									? 'object' | ((value: unknown) => value is Value)
+									: Value extends string
+										? 'string'
+										: Value extends symbol
+											? 'symbol'
+											: Value extends undefined
+												? 'undefined'
+												: (value: unknown) => value is Value;
 
 type TuplePermutations<
 	Tuple extends unknown[],
@@ -223,11 +243,13 @@ export type TypedPropertyRequired<Value> = {
 export type TypedSchema<Model extends PlainObject> = Simplify<
 	{
 		[Key in RequiredKeys<Model>]: Model[Key] extends PlainObject
-			? TypedSchemaRequired<Model[Key]>
+			? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]>
 			: ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
 	} & {
 		[Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject
-			? TypedSchemaOptional<Exclude<Model[Key], undefined>>
+			?
+					| TypedSchemaOptional<Exclude<Model[Key], undefined>>
+					| Schematic<Exclude<Model[Key], undefined>>
 			: TypedPropertyOptional<Model[Key]>;
 	}
 >;
@@ -269,7 +291,6 @@ export type ValidatedPropertyValidators = {
 };
 
 export type ValidatedSchema = {
-	enabled: boolean;
 	keys: {
 		array: string[];
 		set: Set<string>;

package/src/schematic.ts

@@ -1,6 +1,13 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {SCHEMATIC_NAME} from './constants';
-import type {Infer, Schema, TypedSchema, ValidatedSchema} from './models';
+import {MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME} from './constants';
+import {
+	SchematicError,
+	type Infer,
+	type Schema,
+	type TypedSchema,
+	type ValidatedSchema,
+} from './models';
 import {getSchema} from './validation/schema.validation';
 import {validateValue} from './validation/value.validation';
 
@@ -12,25 +19,19 @@ export class Schematic<Model> {
 
 	#schema: ValidatedSchema;
 
-	get enabled(): boolean {
-		return this.#schema.enabled;
-	}
-
-	constructor(schema: Model) {
+	constructor(schema: ValidatedSchema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, {
 			value: true,
 		});
 
-		this.#schema = getSchema(schema);
-
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#schema = schema;
 	}
 
 	/**
 	 * Does the value match the schema?
 	 */
 	is(value: unknown): value is Model {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateValue(this.#schema, value);
 	}
 }
 
@@ -45,5 +46,11 @@ 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> {
-	return new Schematic<Model>(schema);
+	if (!isPlainObject(schema)) {
+		throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	}
+
+	const validated = getSchema(schema);
+
+	return new Schematic<Model>(validated);
 }

package/src/validation/schema.validation.ts

@@ -1,23 +1,33 @@
-import {isConstructor} from '@oscarpalmer/atoms/is';
+import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {smush} from '@oscarpalmer/atoms/value/misc';
 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,
+	TEMPLATE_PATTERN,
 	TYPE_ALL,
 	TYPE_OBJECT,
 	TYPE_UNDEFINED,
+	VALIDATABLE_TYPES,
 } from '../constants';
 import {isInstance, isSchematic} from '../is';
-import type {
-	Schema,
-	ValidatedPropertyType,
-	ValidatedPropertyValidators,
-	ValidatedSchema,
+import {
+	SchematicError,
+	type Schema,
+	type ValidatedPropertyType,
+	type ValidatedPropertyValidators,
+	type ValidatedSchema,
+	type ValueName,
 } from '../models';
 
 function addPropertyType(
@@ -31,9 +41,7 @@ function addPropertyType(
 		const property = to.properties[key];
 
 		for (const type of values) {
-			if (!property.types.includes(type)) {
-				property.types.push(type);
-			}
+			property.types.push(type);
 		}
 	} else {
 		to.keys.array.push(key);
@@ -53,19 +61,14 @@ function addPropertyType(
 	to.properties[key].validators = validators;
 }
 
-export function getSchema(schema: unknown): ValidatedSchema {
-	const validated: ValidatedSchema = {
-		enabled: false,
+export function getSchema(schema: Schema): ValidatedSchema {
+	return getValidatedSchema(schema, {
 		keys: {
 			array: [],
 			set: new Set<string>(),
 		},
 		properties: {},
-	};
-
-	return typeof schema === 'object' && schema !== null
-		? getValidatedSchema(schema as Schema, validated)
-		: validated;
+	});
 }
 
 function getTypes(
@@ -80,22 +83,23 @@ function getTypes(
 
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		const typeOfType = typeof type;
 
-		if (isSchematic(type) || (typeOfType === 'string' && TYPE_ALL.has(type as never))) {
-			propertyTypes.push(type as never);
+		if (isSchematic(type) || TYPE_ALL.has(type as never)) {
+			propertyTypes.push(type);
 
 			continue;
 		}
 
-		if (typeOfType === 'function') {
+		if (typeof type === 'function') {
 			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 
 			continue;
 		}
 
-		if (typeOfType !== 'object' || type === null) {
-			continue;
+		if (!isPlainObject(type)) {
+			throw new SchematicError(
+				MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, prefix),
+			);
 		}
 
 		if (PROPERTY_TYPE in type) {
@@ -104,11 +108,19 @@ function getTypes(
 			continue;
 		}
 
-		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
+		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(type as Schema, validated, prefix);
+		getValidatedSchema(nested as Schema, validated, prefix);
 	}
 
 	return propertyTypes;
@@ -147,10 +159,16 @@ function getValidatedSchema(
 		let required = true;
 		let validators: ValidatedPropertyValidators = {};
 
-		const isObject = typeof value === 'object' && value !== null;
+		const isObject = isPlainObject(value);
 
 		if (isObject && PROPERTY_REQUIRED in value) {
-			required = typeof value[PROPERTY_REQUIRED] === 'boolean' ? value[PROPERTY_REQUIRED] : true;
+			if (typeof value[PROPERTY_REQUIRED] !== 'boolean') {
+				throw new SchematicError(
+					MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
+				);
+			}
+
+			required = value[PROPERTY_REQUIRED] === true;
 		}
 
 		if (isObject && PROPERTY_VALIDATORS in value) {
@@ -161,31 +179,54 @@ function getValidatedSchema(
 
 		const types = getTypes(value, validated, prefixedKey);
 
-		if (types.length > 0) {
-			addPropertyType(validated, prefixedKey, types, validators, required);
+		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;
 }
 
 function getValidators(original: unknown): ValidatedPropertyValidators {
 	const validators: ValidatedPropertyValidators = {};
 
-	if (typeof original !== 'object' || original === null) {
+	if (original == null) {
 		return validators;
 	}
 
-	for (const type of TYPE_ALL) {
-		const value = (original as PlainObject)[type];
+	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));
+			}
 
-		validators[type] = (Array.isArray(value) ? value : [value]).filter(
-			validator => typeof validator === 'function',
-		);
+			return true;
+		});
 	}
 
 	return validators;

package/types/constants.d.ts

@@ -1,11 +1,21 @@
-import type { Values } from './models';
+export declare const ERROR_NAME = "SchematicError";
 export declare const EXPRESSION_HAS_NUMBER: RegExp;
 export declare const EXPRESSION_INDEX: 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_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";
+export declare const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
+export declare const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 export declare const PROPERTY_REQUIRED = "$required";
 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 TYPE_OBJECT = "object";
 export declare const TYPE_UNDEFINED = "undefined";
-export declare const TYPE_ALL: Set<keyof Values>;
+export declare const VALIDATABLE_TYPES: Set<keyof import("./models").Values>;
+export declare const TYPE_ALL: Set<keyof import("./models").Values>;

package/types/index.d.ts

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

package/types/models.d.ts

@@ -23,8 +23,12 @@ type InferRequiredKeys<Model extends Schema> = keyof {
     [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
 };
 type InferSchemaEntry<Value> = Value extends (infer Item)[] ? InferSchemaEntryValue<Item> : InferSchemaEntryValue<Value>;
-type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : false;
+type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends NestedSchema ? Infer<Omit<Value, '$required'>> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
+type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : Value extends {
+    $required?: boolean;
+} ? Value extends {
+    $required: false;
+} ? true : false : false;
 type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item ? Item : never;
 type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
 type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
@@ -33,7 +37,8 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  */
 export type NestedSchema = {
     $required?: boolean;
-} & Schema;
+    [key: string]: any;
+};
 type OptionalKeys<Value> = {
     [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
@@ -45,7 +50,7 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  * A schema for validating objects
  */
 export type Schema = SchemaIndex;
-type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
+type SchemaEntry = Constructor | SchemaProperty | Schematic<unknown> | ValueName | NestedSchema;
 interface SchemaIndex {
     [key: string]: SchemaEntry | SchemaEntry[];
 }
@@ -58,10 +63,13 @@ export type SchemaProperty = {
     $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+export declare class SchematicError extends Error {
+    constructor(message: string);
+}
 type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema ? Omit<Value, '$required'> : Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
 type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
-type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
+type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Schematic<any> ? Value : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
 type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : {
     [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [
         ...Elput,
@@ -101,9 +109,9 @@ export type TypedPropertyRequired<Value> = {
  * Create a schema type constrained to match a TypeScript type
  */
 export type TypedSchema<Model extends PlainObject> = Simplify<{
-    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
+    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
 } & {
-    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
+    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
 }>;
 type TypedSchemaOptional<Model extends PlainObject> = {
     $required: false;
@@ -124,7 +132,6 @@ export type ValidatedPropertyValidators = {
     [Key in ValueName]?: Array<(value: unknown) => boolean>;
 };
 export type ValidatedSchema = {
-    enabled: boolean;
     keys: {
         array: string[];
         set: Set<string>;

package/types/schematic.d.ts

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

package/types/validation/schema.validation.d.ts

@@ -1,2 +1,2 @@
-import type { ValidatedSchema } from '../models';
-export declare function getSchema(schema: unknown): ValidatedSchema;
+import { type Schema, type ValidatedSchema } from '../models';
+export declare function getSchema(schema: Schema): ValidatedSchema;

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

@@ -1,12 +0,0 @@
-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/is.js

@@ -1,20 +0,0 @@
-/**
-* 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 plain object?
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
-export { isArrayOrPlainObject };

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

@@ -1,24 +0,0 @@
-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/node_modules/@oscarpalmer/atoms/dist/value/smush.js

@@ -1,36 +0,0 @@
-import { isArrayOrPlainObject } from "../internal/is.js";
-import { join } from "../internal/string.js";
-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;
-export { smush };