@oscarpalmer/jhunal 0.7.0 → 0.9.0

package/dist/constants.js

@@ -1,3 +1,6 @@
+const EXPRESSION_HAS_NUMBER = /\d+/;
+const EXPRESSION_INDEX = /\.\d+$/;
+const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
 const SCHEMATIC_NAME = "$schematic";
@@ -8,14 +11,12 @@ const TYPE_ALL = new Set([
 	"bigint",
 	"boolean",
 	"date",
-	"date-like",
 	"function",
 	"null",
 	"number",
-	"numerical",
 	"string",
 	"symbol",
 	TYPE_OBJECT,
 	TYPE_UNDEFINED
 ]);
-export { PROPERTY_REQUIRED, PROPERTY_TYPE, SCHEMATIC_NAME, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED };
+export { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, SCHEMATIC_NAME, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED };

package/dist/index.js

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

package/dist/is.js

@@ -1,10 +1,12 @@
-import { SCHEMATIC_NAME } from "./constants.js";
-function isDateLike(value) {
-	if (value instanceof Date) return true;
-	if (typeof value === "number") return value >= -864e13 && value <= 864e13;
-	return typeof value === "string" && !Number.isNaN(Date.parse(value));
+import "./constants.js";
+import { isConstructor } from "@oscarpalmer/atoms/is";
+function isInstance(constructor) {
+	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	return (value) => {
+		return value instanceof constructor;
+	};
 }
 function isSchematic(value) {
 	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
 }
-export { isDateLike, isSchematic };
+export { isInstance, isSchematic };

package/dist/jhunal.full.js

@@ -1,23 +1,30 @@
-const PROPERTY_REQUIRED = "$required";
-const PROPERTY_TYPE = "$type";
-const SCHEMATIC_NAME = "$schematic";
-const TYPE_OBJECT = "object";
-const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"date-like",
-	"function",
-	"null",
-	"number",
-	"numerical",
-	"string",
-	"symbol",
-	TYPE_OBJECT,
-	TYPE_UNDEFINED
-]);
+/**
+* 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`
+*/
+function isConstructor(value) {
+	return typeof value === "function" && value.prototype?.constructor === 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;
+}
 function compact(array, strict) {
 	if (!Array.isArray(array)) return [];
 	if (strict === true) return array.filter(Boolean);
@@ -29,6 +36,11 @@ function compact(array, strict) {
 	}
 	return compacted;
 }
+/**
+* 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 "";
@@ -37,31 +49,45 @@ function getString(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 : "");
 }
-function isArrayOrPlainObject(value) {
-	return Array.isArray(value) || isPlainObject(value);
+const EXPRESSION_HAS_NUMBER = /\d+/;
+const EXPRESSION_INDEX = /\.\d+$/;
+const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
+const PROPERTY_REQUIRED = "$required";
+const PROPERTY_TYPE = "$type";
+const SCHEMATIC_NAME = "$schematic";
+const TYPE_OBJECT = "object";
+const TYPE_UNDEFINED = "undefined";
+const TYPE_ALL = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"function",
+	"null",
+	"number",
+	"string",
+	"symbol",
+	TYPE_OBJECT,
+	TYPE_UNDEFINED
+]);
+function isInstance(constructor) {
+	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	return (value) => {
+		return value instanceof constructor;
+	};
 }
-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;
+function isSchematic(value) {
+	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
 }
-new Set([
-	Int8Array,
-	Uint8Array,
-	Uint8ClampedArray,
-	Int16Array,
-	Uint16Array,
-	Int32Array,
-	Uint32Array,
-	Float32Array,
-	Float64Array,
-	BigInt64Array,
-	BigUint64Array
-]);
 function flattenObject(value, depth, smushed, prefix) {
 	if (depth >= MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
@@ -86,18 +112,15 @@ function flattenObject(value, depth, smushed, prefix) {
 	smushed.set(value, flattened);
 	return flattened;
 }
+/**
+* Smush an object into a flat object that uses dot notation keys
+* @param value Object to smush
+* @returns Smushed object with dot notation keys
+*/
 function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
 var MAX_DEPTH = 100;
-function isDateLike(value) {
-	if (value instanceof Date) return true;
-	if (typeof value === "number") return value >= -864e13 && value <= 864e13;
-	return typeof value === "string" && !Number.isNaN(Date.parse(value));
-}
-function isSchematic(value) {
-	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
-}
 function addPropertyType(to, key, values, required) {
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
@@ -112,17 +135,33 @@ function addPropertyType(to, key, values, required) {
 	}
 	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) to.properties[key].types.push(TYPE_UNDEFINED);
 }
+function getSchema(schema) {
+	const validated = {
+		enabled: false,
+		keys: {
+			array: [],
+			set: /* @__PURE__ */ new Set()
+		},
+		properties: {}
+	};
+	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+}
 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) || typeof type === "string" && TYPE_ALL.has(type)) {
+		const typeOfType = typeof type;
+		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
 			propertyTypes.push(type);
 			continue;
 		}
-		if (typeof type !== "object" || type === null) continue;
+		if (typeOfType === "function") {
+			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
+			continue;
+		}
+		if (typeOfType !== "object" || type === null) continue;
 		if (PROPERTY_TYPE in type) {
 			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
@@ -144,8 +183,8 @@ function getValidatedSchema(schema, validated, prefix) {
 		const key = keys[index];
 		const value = smushed[key];
 		if (Array.isArray(value)) arrayKeys.add(key);
-		if (/\.\$(required|type)(\.|$)/.test(key)) continue;
-		if (/\d+/.test(key) && arrayKeys.has(key.replace(/\.\d+$/, ""))) continue;
+		if (EXPRESSION_PROPERTY.test(key)) continue;
+		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
 		if (typeof value === "object" && value !== null && PROPERTY_REQUIRED in value) required = typeof value[PROPERTY_REQUIRED] === "boolean" ? value[PROPERTY_REQUIRED] : true;
 		const prefixedKey = `${prefix}${key}`;
@@ -155,18 +194,12 @@ function getValidatedSchema(schema, validated, prefix) {
 	if (noPrefix) validated.keys.array.sort();
 	return validated;
 }
-function validateSchema(schema) {
-	const validated = {
-		keys: {
-			array: [],
-			set: /* @__PURE__ */ new Set()
-		},
-		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
-}
 function validateType(type, value) {
-	return typeof type === "string" ? validators[type](value) : type.is(value);
+	switch (true) {
+		case typeof type === "function": return type(value);
+		case typeof type === "string": return validators[type](value);
+		default: return type.is(value);
+	}
 }
 function validateValue(validated, obj) {
 	if (typeof obj !== "object" || obj === null) return false;
@@ -189,7 +222,7 @@ function validateValue(validated, obj) {
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
 			if (validateType(type, value)) {
-				if (type !== TYPE_OBJECT) ignore.add(key);
+				if (type !== "object") ignore.add(key);
 				continue outer;
 			}
 		}
@@ -203,32 +236,35 @@ const validators = {
 	bigint: (value) => typeof value === "bigint",
 	boolean: (value) => typeof value === "boolean",
 	date: (value) => value instanceof Date,
-	"date-like": isDateLike,
 	function: (value) => typeof value === "function",
 	null: (value) => value === null,
 	number: (value) => typeof value === "number" && !Number.isNaN(value),
-	numerical: (value) => validators.bigint(value) || validators.number(value),
 	object: (value) => typeof value === "object" && value !== null,
 	string: (value) => typeof value === "string",
 	symbol: (value) => typeof value === "symbol",
 	undefined: (value) => value === void 0
 };
+/**
+* A schematic for validating objects
+*/
 var Schematic = class {
 	#schema;
-	#validatable;
-	get validatable() {
-		return this.#validatable;
+	get enabled() {
+		return this.#schema.enabled;
 	}
 	constructor(schema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = validateSchema(schema);
-		this.#validatable = this.#schema.keys.array.length > 0;
+		this.#schema = getSchema(schema);
+		this.#schema.enabled = this.#schema.keys.array.length > 0;
 	}
+	/**
+	* Does the value match the schema?
+	*/
 	is(value) {
-		return this.#validatable && validateValue(this.#schema, value);
+		return this.#schema.enabled && validateValue(this.#schema, value);
 	}
 };
 function schematic(schema) {
 	return new Schematic(schema);
 }
-export { schematic };
+export { isInstance, schematic };

package/dist/schematic.js

@@ -1,19 +1,24 @@
 import { SCHEMATIC_NAME } from "./constants.js";
-import { validateSchema } from "./validation/schema.validation.js";
+import { getSchema } from "./validation/schema.validation.js";
 import { validateValue } from "./validation/value.validation.js";
+/**
+* A schematic for validating objects
+*/
 var Schematic = class {
 	#schema;
-	#validatable;
-	get validatable() {
-		return this.#validatable;
+	get enabled() {
+		return this.#schema.enabled;
 	}
 	constructor(schema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = validateSchema(schema);
-		this.#validatable = this.#schema.keys.array.length > 0;
+		this.#schema = getSchema(schema);
+		this.#schema.enabled = this.#schema.keys.array.length > 0;
 	}
+	/**
+	* Does the value match the schema?
+	*/
 	is(value) {
-		return this.#validatable && validateValue(this.#schema, value);
+		return this.#schema.enabled && validateValue(this.#schema, value);
 	}
 };
 function schematic(schema) {

package/dist/validation/schema.validation.js

@@ -1,5 +1,6 @@
-import { PROPERTY_REQUIRED, PROPERTY_TYPE, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
-import { isSchematic } from "../is.js";
+import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
+import { isInstance, isSchematic } from "../is.js";
+import { isConstructor } from "@oscarpalmer/atoms/is";
 import { smush } from "@oscarpalmer/atoms/value";
 function addPropertyType(to, key, values, required) {
 	if (to.keys.set.has(key)) {
@@ -15,17 +16,33 @@ function addPropertyType(to, key, values, required) {
 	}
 	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
 }
+function getSchema(schema) {
+	const validated = {
+		enabled: false,
+		keys: {
+			array: [],
+			set: /* @__PURE__ */ new Set()
+		},
+		properties: {}
+	};
+	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+}
 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) || typeof type === "string" && TYPE_ALL.has(type)) {
+		const typeOfType = typeof type;
+		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
 			propertyTypes.push(type);
 			continue;
 		}
-		if (typeof type !== "object" || type === null) continue;
+		if (typeOfType === "function") {
+			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
+			continue;
+		}
+		if (typeOfType !== "object" || type === null) continue;
 		if ("$type" in type) {
 			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
@@ -47,8 +64,8 @@ function getValidatedSchema(schema, validated, prefix) {
 		const key = keys[index];
 		const value = smushed[key];
 		if (Array.isArray(value)) arrayKeys.add(key);
-		if (/\.\$(required|type)(\.|$)/.test(key)) continue;
-		if (/\d+/.test(key) && arrayKeys.has(key.replace(/\.\d+$/, ""))) continue;
+		if (EXPRESSION_PROPERTY.test(key)) continue;
+		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
 		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
 		const prefixedKey = `${prefix}${key}`;
@@ -58,14 +75,4 @@ function getValidatedSchema(schema, validated, prefix) {
 	if (noPrefix) validated.keys.array.sort();
 	return validated;
 }
-function validateSchema(schema) {
-	const validated = {
-		keys: {
-			array: [],
-			set: /* @__PURE__ */ new Set()
-		},
-		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
-}
-export { validateSchema };
+export { getSchema };

package/dist/validation/value.validation.js

@@ -1,8 +1,11 @@
-import { TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
-import { isDateLike } from "../is.js";
+import "../constants.js";
 import { smush } from "@oscarpalmer/atoms/value";
 function validateType(type, value) {
-	return typeof type === "string" ? validators[type](value) : type.is(value);
+	switch (true) {
+		case typeof type === "function": return type(value);
+		case typeof type === "string": return validators[type](value);
+		default: return type.is(value);
+	}
 }
 function validateValue(validated, obj) {
 	if (typeof obj !== "object" || obj === null) return false;
@@ -39,11 +42,9 @@ var validators = {
 	bigint: (value) => typeof value === "bigint",
 	boolean: (value) => typeof value === "boolean",
 	date: (value) => value instanceof Date,
-	"date-like": isDateLike,
 	function: (value) => typeof value === "function",
 	null: (value) => value === null,
 	number: (value) => typeof value === "number" && !Number.isNaN(value),
-	numerical: (value) => validators.bigint(value) || validators.number(value),
 	object: (value) => typeof value === "object" && value !== null,
 	string: (value) => typeof value === "string",
 	symbol: (value) => typeof value === "symbol",

package/package.json

@@ -4,26 +4,26 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.123"
+		"@oscarpalmer/atoms": "^0.139"
 	},
 	"description": "Flies free beneath the glistening moons…",
 	"devDependencies": {
-		"@types/node": "^25",
+		"@types/node": "^25.3",
 		"@vitest/coverage-istanbul": "^4",
-		"jsdom": "^27.4",
-		"oxfmt": "^0.21",
-		"oxlint": "^1.36",
-		"rolldown": "1.0.0-beta.57",
+		"jsdom": "^28.1",
+		"oxfmt": "^0.34",
+		"oxlint": "^1.49",
+		"rolldown": "1.0.0-rc.5",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "8.0.0-beta.5",
+		"vite": "8.0.0-beta.15",
 		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
-				"types": "./types/index.d.ts",
-				"default": "./dist/index.js"
+			"types": "./types/index.d.ts",
+			"default": "./dist/index.js"
 		}
 	},
 	"files": ["dist", "src", "types"],
@@ -45,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.7.0"
+	"version": "0.9.0"
 }

package/src/constants.ts

@@ -1,5 +1,11 @@
 import type {Values} from './models';
 
+export const EXPRESSION_HAS_NUMBER = /\d+/;
+
+export const EXPRESSION_INDEX = /\.\d+$/;
+
+export const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
+
 export const PROPERTY_REQUIRED = '$required';
 
 export const PROPERTY_TYPE = '$type';
@@ -15,11 +21,9 @@ export const TYPE_ALL = new Set<keyof Values>([
 	'bigint',
 	'boolean',
 	'date',
-	'date-like',
 	'function',
 	'null',
 	'number',
-	'numerical',
 	'string',
 	'symbol',
 	TYPE_OBJECT,

package/src/index.ts

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

package/src/is.ts

@@ -1,16 +1,18 @@
+import {isConstructor} from '@oscarpalmer/atoms/is';
 import {SCHEMATIC_NAME} from './constants';
+import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
-export function isDateLike(value: unknown): value is Date {
-	if (value instanceof Date) {
-		return true;
+export function isInstance<Instance>(
+	constructor: Constructor<Instance>,
+): (value: unknown) => value is Instance {
+	if (!isConstructor(constructor)) {
+		throw new TypeError('Expected a constructor function');
 	}
 
-	if (typeof value === 'number') {
-		return value >= -8_640e12 && value <= 8_640e12;
-	}
-
-	return typeof value === 'string' && !Number.isNaN(Date.parse(value));
+	return (value: unknown): value is Instance => {
+		return value instanceof constructor;
+	};
 }
 
 export function isSchematic(value: unknown): value is Schematic<never> {

package/src/models.ts

@@ -1,58 +1,67 @@
 import type {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 [
+	infer Head,
+	...infer Tail,
+]
+	? Head extends Seen[number]
+		? DeduplicateTuple<Tail, Seen>
+		: DeduplicateTuple<Tail, [...Seen, Head]>
+	: Seen;
+
 /**
  * Infer the TypeScript type from a schema definition
  */
 export type Infer<Model extends Schema> = Simplify<
 	{
-		[Key in InferRequiredKeys<Model>]: Model[Key] extends Schematic<infer SchematicModel>
-			? SchematicModel
-			: Model[Key] extends SchemaProperty
-				? InferPropertyValue<Model[Key]>
-				: InferEntryValue<Model[Key]>;
+		[Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]>;
 	} & {
-		[Key in InferOptionalKeys<Model>]?: Model[Key] extends Schematic<infer SchematicModel>
-			? SchematicModel
-			: Model[Key] extends SchemaProperty
-				? InferPropertyValue<Model[Key]>
-				: never;
+		[Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]>;
 	}
 >;
 
-type InferEntryValue<Value> = Value extends ValueName
-	? Values[Value]
-	: Value extends ValueName[]
-		? Values[Value[number]]
-		: never;
-
 type InferOptionalKeys<Model extends Schema> = keyof {
 	[Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never;
 };
 
 type InferPropertyType<Value> = Value extends (infer Item)[]
-	? InferTypeValue<Item>[]
-	: InferTypeValue<Value>;
+	? InferPropertyValue<Item>
+	: InferPropertyValue<Value>;
 
-type InferPropertyValue<Prop> = Prop extends SchemaProperty
-	? InferPropertyType<Prop['$type']>
-	: never;
+type InferPropertyValue<Value> =
+	Value extends Constructor<infer Instance>
+		? Instance
+		: Value extends Schematic<infer Model>
+			? Model
+			: Value extends ValueName
+				? Values[Value & ValueName]
+				: Value extends Schema
+					? Infer<Value>
+					: never;
 
 type InferRequiredKeys<Model extends Schema> = keyof {
 	[Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
 };
 
-type InferTypeValue<Value> = Value extends SchemaPropertyType
-	? Value extends Schema
-		? Infer<Value>
+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 ValueName
-				? Values[Value]
-				: Value extends (infer Nested)[]
-					? InferTypeValue<Nested>[]
-					: Value
-	: never;
+			: 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
@@ -65,6 +74,14 @@ type LastOfUnion<Value> =
 		? 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>]
+	: [];
+
 /**
  * A nested schema with optional requirement flag
  */
@@ -83,10 +100,10 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  */
 export type Schema = SchemaIndex;
 
-type SchemaEntry = NestedSchema | SchemaProperty | Schematic<unknown> | ValueName | ValueName[];
+type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
 
 interface SchemaIndex {
-	[key: string]: SchemaEntry;
+	[key: string]: SchemaEntry | SchemaEntry[];
 }
 
 /**
@@ -97,27 +114,67 @@ export type SchemaProperty = {
 	$type: SchemaPropertyType | SchemaPropertyType[];
 };
 
-type SchemaPropertyType = Schema | Schematic<unknown> | ValueName;
+type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
 
-type ToSchemaPropertyType<Value> = UnwrapSingle<UnionToTuple<ToSchemaPropertyTypeEach<Value>>>;
+type ToSchemaPropertyType<Value> = UnwrapSingle<
+	DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>
+>;
 
 type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject
 	? TypedSchema<Value>
-	: ToValueName<Value>;
-
-type ToSchemaType<Value> = UnwrapSingle<UnionToTuple<ToValueName<Value>>>;
-
-type ToValueName<Value> = {
-	[Key in Exclude<ValueName, ValueNameFallbacks>]: Value extends Values[Key] ? Key : never;
-}[Exclude<ValueName, ValueNameFallbacks>] extends infer Specific
-	? Specific extends never
-		? {[Key in ValueNameFallbacks]: Value extends Values[Key] ? Key : never}[ValueNameFallbacks]
-		: Specific
-	: never;
+	: 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 TuplePermutations<
+	Tuple extends unknown[],
+	Elput extends unknown[] = [],
+> = Tuple['length'] extends 0
+	? Elput
+	: {
+			[Key in keyof Tuple]: TuplePermutations<
+				TupleRemoveAt<Tuple, Key & `${number}`>,
+				[...Elput, Tuple[Key]]
+			>;
+		}[keyof Tuple & `${number}`];
+
+type TupleRemoveAt<
+	Items extends unknown[],
+	Item extends string,
+	Prefix extends unknown[] = [],
+> = Items extends [infer Head, ...infer Tail]
+	? `${Prefix['length']}` extends Item
+		? [...Prefix, ...Tail]
+		: TupleRemoveAt<Tail, Item, [...Prefix, Head]>
+	: Prefix;
 
 export type TypedPropertyOptional<Value> = {
 	$required: false;
-	$type: ToSchemaPropertyType<Value>;
+	$type: ToSchemaPropertyType<Exclude<Value, undefined>>;
 };
 
 export type TypedPropertyRequired<Value> = {
@@ -145,11 +202,11 @@ type TypedSchemaOptional<Model extends PlainObject> = {
 } & TypedSchema<Model>;
 
 type TypedSchemaRequired<Model extends PlainObject> = {
-	$required?: boolean;
+	$required?: true;
 } & TypedSchema<Model>;
 
-type UnionToIntersection<Value> = (Value extends unknown ? (x: Value) => void : never) extends (
-	x: infer Item,
+type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => void : never) extends (
+	value: infer Item,
 ) => void
 	? Item
 	: never;
@@ -158,7 +215,11 @@ 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;
+type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
+	? Only
+	: Value['length'] extends 1 | 2 | 3 | 4 | 5
+		? TuplePermutations<Value>
+		: Value;
 
 export type ValidatedProperty = {
 	required: boolean;
@@ -168,6 +229,7 @@ export type ValidatedProperty = {
 export type ValidatedPropertyType = Schematic<unknown> | ValueName;
 
 export type ValidatedSchema = {
+	enabled: boolean;
 	keys: {
 		array: string[];
 		set: Set<string>;
@@ -180,8 +242,6 @@ export type ValidatedSchema = {
  */
 export type ValueName = keyof Values;
 
-type ValueNameFallbacks = 'date-like' | 'numerical';
-
 /**
  * Map of type names to their TypeScript/validatable equivalents
  */
@@ -190,11 +250,9 @@ export type Values = {
 	bigint: bigint;
 	boolean: boolean;
 	date: Date;
-	'date-like': number | string | Date;
 	function: Function;
 	null: null;
 	number: number;
-	numerical: bigint | number;
 	object: object;
 	string: string;
 	symbol: symbol;

package/src/schematic.ts

@@ -1,7 +1,7 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {SCHEMATIC_NAME} from './constants';
 import type {Infer, Schema, TypedSchema, ValidatedSchema} from './models';
-import {validateSchema} from './validation/schema.validation';
+import {getSchema} from './validation/schema.validation';
 import {validateValue} from './validation/value.validation';
 
 /**
@@ -11,10 +11,9 @@ export class Schematic<Model> {
 	declare private readonly $schematic: true;
 
 	#schema: ValidatedSchema;
-	#validatable: boolean;
 
-	get validatable(): boolean {
-		return this.#validatable;
+	get enabled(): boolean {
+		return this.#schema.enabled;
 	}
 
 	constructor(schema: Model) {
@@ -22,16 +21,16 @@ export class Schematic<Model> {
 			value: true,
 		});
 
-		this.#schema = validateSchema(schema);
+		this.#schema = getSchema(schema);
 
-		this.#validatable = this.#schema.keys.array.length > 0;
+		this.#schema.enabled = this.#schema.keys.array.length > 0;
 	}
 
 	/**
 	 * Does the value match the schema?
 	 */
 	is(value: unknown): value is Model {
-		return this.#validatable && validateValue(this.#schema, value);
+		return this.#schema.enabled && validateValue(this.#schema, value);
 	}
 }
 

package/src/validation/schema.validation.ts

@@ -1,13 +1,17 @@
+import {isConstructor} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {smush} from '@oscarpalmer/atoms/value';
 import {
+	EXPRESSION_HAS_NUMBER,
+	EXPRESSION_INDEX,
+	EXPRESSION_PROPERTY,
 	PROPERTY_REQUIRED,
 	PROPERTY_TYPE,
 	TYPE_ALL,
 	TYPE_OBJECT,
 	TYPE_UNDEFINED,
 } from '../constants';
-import {isSchematic} from '../is';
+import {isInstance, isSchematic} from '../is';
 import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../models';
 
 function addPropertyType(
@@ -39,6 +43,21 @@ function addPropertyType(
 	}
 }
 
+export function getSchema(schema: unknown): ValidatedSchema {
+	const validated: ValidatedSchema = {
+		enabled: false,
+		keys: {
+			array: [],
+			set: new Set<string>(),
+		},
+		properties: {},
+	};
+
+	return typeof schema === 'object' && schema !== null
+		? getValidatedSchema(schema as Schema, validated)
+		: validated;
+}
+
 function getTypes(
 	value: unknown,
 	validated: ValidatedSchema,
@@ -51,14 +70,21 @@ function getTypes(
 
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
+		const typeOfType = typeof type;
 
-		if (isSchematic(type) || (typeof type === 'string' && TYPE_ALL.has(type as never))) {
+		if (isSchematic(type) || (typeOfType === 'string' && TYPE_ALL.has(type as never))) {
 			propertyTypes.push(type as never);
 
 			continue;
 		}
 
-		if (typeof type !== 'object' || type === null) {
+		if (typeOfType === 'function') {
+			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
+
+			continue;
+		}
+
+		if (typeOfType !== 'object' || type === null) {
 			continue;
 		}
 
@@ -100,11 +126,11 @@ function getValidatedSchema(
 			arrayKeys.add(key);
 		}
 
-		if (/\.\$(required|type)(\.|$)/.test(key)) {
+		if (EXPRESSION_PROPERTY.test(key)) {
 			continue;
 		}
 
-		if (/\d+/.test(key) && arrayKeys.has(key.replace(/\.\d+$/, ''))) {
+		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ''))) {
 			continue;
 		}
 
@@ -129,17 +155,3 @@ function getValidatedSchema(
 
 	return validated;
 }
-
-export function validateSchema(schema: unknown): ValidatedSchema {
-	const validated: ValidatedSchema = {
-		keys: {
-			array: [],
-			set: new Set<string>(),
-		},
-		properties: {},
-	};
-
-	return typeof schema === 'object' && schema !== null
-		? getValidatedSchema(schema as Schema, validated)
-		: validated;
-}

package/src/validation/value.validation.ts

@@ -1,11 +1,19 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {smush} from '@oscarpalmer/atoms/value';
-import {TYPE_OBJECT, TYPE_UNDEFINED} from '../constants';
-import {isDateLike} from '../is';
+import {TYPE_UNDEFINED} from '../constants';
 import type {ValidatedPropertyType, ValidatedSchema, Values} from '../models';
 
 export function validateType(type: ValidatedPropertyType, value: unknown): boolean {
-	return typeof type === 'string' ? validators[type](value) : type.is(value);
+	switch (true) {
+		case typeof type === 'function':
+			return (type as any)(value);
+
+		case typeof type === 'string':
+			return validators[type](value);
+
+		default:
+			return type.is(value);
+	}
 }
 
 export function validateValue(validated: ValidatedSchema, obj: unknown): boolean {
@@ -50,7 +58,7 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 			const type = property.types[typeIndex];
 
 			if (validateType(type, value)) {
-				if (type !== TYPE_OBJECT) {
+				if ((type as never) !== 'object') {
 					ignore.add(key);
 				}
 
@@ -75,11 +83,9 @@ const validators: Record<keyof Values, (value: unknown) => boolean> = {
 	bigint: value => typeof value === 'bigint',
 	boolean: value => typeof value === 'boolean',
 	date: value => value instanceof Date,
-	'date-like': isDateLike,
 	function: value => typeof value === 'function',
 	null: value => value === null,
 	number: value => typeof value === 'number' && !Number.isNaN(value),
-	numerical: value => validators.bigint(value) || validators.number(value),
 	object: value => typeof value === 'object' && value !== null,
 	string: value => typeof value === 'string',
 	symbol: value => typeof value === 'symbol',

package/types/constants.d.ts

@@ -1,4 +1,7 @@
 import type { Values } from './models';
+export declare const EXPRESSION_HAS_NUMBER: RegExp;
+export declare const EXPRESSION_INDEX: RegExp;
+export declare const EXPRESSION_PROPERTY: RegExp;
 export declare const PROPERTY_REQUIRED = "$required";
 export declare const PROPERTY_TYPE = "$type";
 export declare const SCHEMATIC_NAME = "$schematic";

package/types/index.d.ts

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

package/types/is.d.ts

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

package/types/models.d.ts

@@ -1,25 +1,32 @@
 import type { 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 [
+    infer Head,
+    ...infer Tail
+] ? Head extends Seen[number] ? DeduplicateTuple<Tail, Seen> : DeduplicateTuple<Tail, [...Seen, Head]> : Seen;
 /**
  * Infer the TypeScript type from a schema definition
  */
 export type Infer<Model extends Schema> = Simplify<{
-    [Key in InferRequiredKeys<Model>]: Model[Key] extends Schematic<infer SchematicModel> ? SchematicModel : Model[Key] extends SchemaProperty ? InferPropertyValue<Model[Key]> : InferEntryValue<Model[Key]>;
+    [Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]>;
 } & {
-    [Key in InferOptionalKeys<Model>]?: Model[Key] extends Schematic<infer SchematicModel> ? SchematicModel : Model[Key] extends SchemaProperty ? InferPropertyValue<Model[Key]> : never;
+    [Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]>;
 }>;
-type InferEntryValue<Value> = Value extends ValueName ? Values[Value] : Value extends ValueName[] ? Values[Value[number]] : never;
 type InferOptionalKeys<Model extends Schema> = keyof {
     [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never;
 };
-type InferPropertyType<Value> = Value extends (infer Item)[] ? InferTypeValue<Item>[] : InferTypeValue<Value>;
-type InferPropertyValue<Prop> = Prop extends SchemaProperty ? InferPropertyType<Prop['$type']> : never;
+type InferPropertyType<Value> = Value extends (infer Item)[] ? InferPropertyValue<Item> : InferPropertyValue<Value>;
+type InferPropertyValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
 type InferRequiredKeys<Model extends Schema> = keyof {
     [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
 };
-type InferTypeValue<Value> = Value extends SchemaPropertyType ? Value extends Schema ? Infer<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueName ? Values[Value] : Value extends (infer Nested)[] ? InferTypeValue<Nested>[] : Value : 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 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>] : [];
 /**
  * A nested schema with optional requirement flag
  */
@@ -34,9 +41,9 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  * A schema for validating objects
  */
 export type Schema = SchemaIndex;
-type SchemaEntry = NestedSchema | SchemaProperty | Schematic<unknown> | ValueName | ValueName[];
+type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
 interface SchemaIndex {
-    [key: string]: SchemaEntry;
+    [key: string]: SchemaEntry | SchemaEntry[];
 }
 /**
  * A property definition with explicit type(s) and optional requirement flag
@@ -45,18 +52,21 @@ export type SchemaProperty = {
     $required?: boolean;
     $type: SchemaPropertyType | SchemaPropertyType[];
 };
-type SchemaPropertyType = Schema | Schematic<unknown> | ValueName;
-type ToSchemaPropertyType<Value> = UnwrapSingle<UnionToTuple<ToSchemaPropertyTypeEach<Value>>>;
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueName<Value>;
-type ToSchemaType<Value> = UnwrapSingle<UnionToTuple<ToValueName<Value>>>;
-type ToValueName<Value> = {
-    [Key in Exclude<ValueName, ValueNameFallbacks>]: Value extends Values[Key] ? Key : never;
-}[Exclude<ValueName, ValueNameFallbacks>] extends infer Specific ? Specific extends never ? {
-    [Key in ValueNameFallbacks]: Value extends Values[Key] ? Key : never;
-}[ValueNameFallbacks] : Specific : never;
+type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
+type ToSchemaPropertyTypeEach<Value> = 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 TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : {
+    [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [
+        ...Elput,
+        Tuple[Key]
+    ]>;
+}[keyof Tuple & `${number}`];
+type TupleRemoveAt<Items extends unknown[], Item extends string, Prefix extends unknown[] = []> = Items extends [infer Head, ...infer Tail] ? `${Prefix['length']}` extends Item ? [...Prefix, ...Tail] : TupleRemoveAt<Tail, Item, [...Prefix, Head]> : Prefix;
 export type TypedPropertyOptional<Value> = {
     $required: false;
-    $type: ToSchemaPropertyType<Value>;
+    $type: ToSchemaPropertyType<Exclude<Value, undefined>>;
 };
 export type TypedPropertyRequired<Value> = {
     $required?: true;
@@ -74,17 +84,18 @@ type TypedSchemaOptional<Model extends PlainObject> = {
     $required: false;
 } & TypedSchema<Model>;
 type TypedSchemaRequired<Model extends PlainObject> = {
-    $required?: boolean;
+    $required?: true;
 } & TypedSchema<Model>;
-type UnionToIntersection<Value> = (Value extends unknown ? (x: Value) => void : never) extends (x: infer Item) => void ? Item : never;
+type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => void : never) extends (value: infer Item) => void ? Item : never;
 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;
+type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
 export type ValidatedProperty = {
     required: boolean;
     types: ValidatedPropertyType[];
 };
 export type ValidatedPropertyType = Schematic<unknown> | ValueName;
 export type ValidatedSchema = {
+    enabled: boolean;
     keys: {
         array: string[];
         set: Set<string>;
@@ -95,7 +106,6 @@ export type ValidatedSchema = {
  * Valid type name strings
  */
 export type ValueName = keyof Values;
-type ValueNameFallbacks = 'date-like' | 'numerical';
 /**
  * Map of type names to their TypeScript/validatable equivalents
  */
@@ -104,11 +114,9 @@ export type Values = {
     bigint: bigint;
     boolean: boolean;
     date: Date;
-    'date-like': number | string | Date;
     function: Function;
     null: null;
     number: number;
-    numerical: bigint | number;
     object: object;
     string: string;
     symbol: symbol;

package/types/schematic.d.ts

@@ -6,7 +6,7 @@ import type { Infer, Schema, TypedSchema } from './models';
 export declare class Schematic<Model> {
     #private;
     private readonly $schematic;
-    get validatable(): boolean;
+    get enabled(): boolean;
     constructor(schema: Model);
     /**
      * 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 validateSchema(schema: unknown): ValidatedSchema;
+export declare function getSchema(schema: unknown): ValidatedSchema;