@oscarpalmer/jhunal 0.23.0 → 0.25.0

package/dist/index.mjs

@@ -10,8 +10,9 @@ const CONJUNCTION_AND_COMMA = ", and ";
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 const NAME_ERROR_SCHEMATIC = "SchematicError";
 const NAME_ERROR_VALIDATION = "ValidationError";
+const PROPERTY_DEFAULT = "$default";
 const PROPERTY_REQUIRED = "$required";
-const PROPERTY_SCHEMATIC = "$schematic";
+const PROPERTY_SCHEMA = "$schema";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const VALIDATION_MESSAGE_INVALID_INPUT = "Expected an object as input but received <>";
@@ -29,8 +30,10 @@ const REPORTING_TYPES = new Set([
 	REPORTING_NONE,
 	REPORTING_THROW
 ]);
+const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED = "'<>' has a default value but is not required";
+const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE = "Expected default value for property '<>' to be <>";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<>.<>' property is not allowed for schemas in $type";
+const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<>.<>' property is not allowed for plain schemas";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE = "'<>' property must not be 'null' or 'undefined'";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
@@ -39,42 +42,36 @@ const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
 const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
 const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 const TYPE_ARRAY = "array";
-const TYPE_BIGINT = "bigint";
-const TYPE_BOOLEAN = "boolean";
-const TYPE_DATE = "date";
 const TYPE_FUNCTION = "function";
 const TYPE_FUNCTION_RESULT = "a validated value";
 const TYPE_NULL = "null";
-const TYPE_NUMBER = "number";
 const TYPE_OBJECT = "object";
-const TYPE_STRING = "string";
-const TYPE_SYMBOL = "symbol";
 const TYPE_UNDEFINED = "undefined";
 const TYPE_ALL = new Set([
 	...new Set([
 		TYPE_ARRAY,
-		TYPE_BIGINT,
-		TYPE_BOOLEAN,
-		TYPE_DATE,
+		"bigint",
+		"boolean",
+		"date",
 		TYPE_FUNCTION,
-		TYPE_NUMBER,
+		"number",
 		TYPE_OBJECT,
-		TYPE_STRING,
-		TYPE_SYMBOL
+		"string",
+		"symbol"
 	]),
 	TYPE_NULL,
 	TYPE_UNDEFINED
 ]);
 const PREFIXED_TYPES = {
 	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
-	[TYPE_BIGINT]: `a ${TYPE_BIGINT}`,
-	[TYPE_BOOLEAN]: `a ${TYPE_BOOLEAN}`,
-	[TYPE_DATE]: `a ${TYPE_DATE}`,
+	bigint: `a bigint`,
+	boolean: `a boolean`,
+	date: `a date`,
 	[TYPE_FUNCTION]: `a ${TYPE_FUNCTION}`,
 	[TYPE_NULL]: TYPE_NULL,
-	[TYPE_NUMBER]: `a ${TYPE_NUMBER}`,
-	[TYPE_STRING]: `a ${TYPE_STRING}`,
-	[TYPE_SYMBOL]: `a ${TYPE_SYMBOL}`,
+	number: `a number`,
+	string: `a string`,
+	symbol: `a symbol`,
 	[TYPE_OBJECT]: `an ${TYPE_OBJECT}`,
 	[TYPE_UNDEFINED]: TYPE_UNDEFINED
 };
@@ -84,7 +81,7 @@ function getParameters(input) {
 	if (typeof input === "boolean") return {
 		clone: true,
 		output: {},
-		reporting: getReporting(REPORTING_NONE),
+		reporting: getReporting(),
 		strict: input
 	};
 	if (REPORTING_TYPES.has(input)) return {
@@ -128,8 +125,8 @@ function instanceOf(constructor) {
 * @param value Value to check
 * @returns `true` if the value is a schematic, `false` otherwise
 */
-function isSchematic(value) {
-	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
+function isSchema(value) {
+	return typeof value === "object" && value !== null && "$schema" in value && value["$schema"] === true;
 }
 //#endregion
 //#region src/models/validation.model.ts
@@ -154,26 +151,45 @@ var ValidationError = class extends Error {
 };
 //#endregion
 //#region src/helpers/message.helper.ts
-function getInvalidInputMessage(actual) {
+function getDefaultRequiredMessage(key) {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED.replace("<>", key);
+}
+function getDefaultTypeMessage(key, types) {
+	let message = SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE.replace("<>", key);
+	message = message.replace("<>", renderTypes(types));
+	return message;
+}
+function getDisallowedMessage(key, property) {
+	let message = SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", key);
+	message = message.replace("<>", property);
+	return message;
+}
+function getInputTypeMessage(actual) {
 	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
 }
-function getInvalidMissingMessage(key, types) {
+function getInputPropertyMissingMessage(key, types) {
 	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
 	message = message.replace("<>", key);
 	return message;
 }
-function getInvalidTypeMessage(key, types, actual) {
+function getInputPropertyTypeMessage(key, types, actual) {
 	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
 	message = message.replace("<>", key);
 	message = message.replace("<>", getValueType(actual));
 	return message;
 }
-function getInvalidValidatorMessage(key, type, index, length) {
+function getInputPropertyValidatorMessage(key, type, index, length) {
 	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
 	message = message.replace("<>", type);
 	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
 	return message;
 }
+function getSchematicPropertyNullableMessage(key) {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", key);
+}
+function getSchematicPropertyTypeMessage(key) {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", key);
+}
 function getPropertyType(type) {
 	switch (true) {
 		case typeof type === "function": return isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT;
@@ -181,9 +197,6 @@ function getPropertyType(type) {
 		default: return PREFIXED_TYPES[TYPE_OBJECT];
 	}
 }
-function getUnknownKeysMessage(keys) {
-	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
-}
 function getValueType(value) {
 	const valueType = typeof value;
 	switch (true) {
@@ -219,6 +232,12 @@ function renderTypes(types) {
 	}
 	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
 }
+function getRequiredMessage(key) {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key);
+}
+function getUnknownKeysMessage(keys) {
+	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
+}
 //#endregion
 //#region src/validator/base.validator.ts
 function getBaseValidator(validators) {
@@ -245,9 +264,10 @@ function getFunctionValidator(fn) {
 }
 //#endregion
 //#region src/validator/named.handler.ts
-function getNamedHandlers(original, prefix) {
+function getNamedHandlers(original, prefix, allowed) {
 	const handlers = {};
 	if (original == null) return handlers;
+	if (!allowed) throw new TypeError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", PROPERTY_VALIDATORS));
 	if (!isPlainObject(original)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
 	const keys = Object.keys(original);
 	const { length } = keys;
@@ -276,7 +296,7 @@ function getNamedValidator(key, name, handlers) {
 			const information = {
 				key,
 				validator,
-				message: getInvalidValidatorMessage(key.full, name, index, length),
+				message: getInputPropertyValidatorMessage(key.full, name, index, length),
 				value: input
 			};
 			parameters.information?.push(information);
@@ -300,8 +320,8 @@ const namedValidators = {
 };
 //#endregion
 //#region src/validator/schematic.validator.ts
-function getSchematicValidator(schematic) {
-	const validator = schematicValidator.get(schematic);
+function getSchemaValidator(schematic) {
+	const validator = schemaValidators.get(schematic);
 	return (input, parameters, get) => {
 		let result;
 		if (isPlainObject(input)) result = validator(input, parameters, get);
@@ -313,7 +333,13 @@ function getSchematicValidator(schematic) {
 }
 //#endregion
 //#region src/validator/object.validator.ts
+function getDefaults(obj, key, allowed) {
+	if (!("$default" in obj)) return;
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
+	return { value: obj[PROPERTY_DEFAULT] };
+}
 function getDisallowedProperty(obj) {
+	if ("$default" in obj) return PROPERTY_DEFAULT;
 	if ("$required" in obj) return PROPERTY_REQUIRED;
 	if ("$type" in obj) return PROPERTY_TYPE;
 	if ("$validators" in obj) return PROPERTY_VALIDATORS;
@@ -324,14 +350,14 @@ function getObjectValidator(original, origin, fromType) {
 	if (keysLength === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
 	if (fromType ?? false) {
 		const property = getDisallowedProperty(original);
-		if (property != null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", origin.full).replace("<>", property));
+		if (property != null) throw new SchematicError(getDisallowedMessage(origin.full, property));
 	}
 	const set = /* @__PURE__ */ new Set();
 	const items = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 		const value = original[key];
-		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join([origin?.full, key], ".")));
+		if (value == null) throw new SchematicError(getSchematicPropertyNullableMessage(join([origin?.full, key], ".")));
 		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
 		const fullKey = {
 			full: prefixedKey,
@@ -340,16 +366,18 @@ function getObjectValidator(original, origin, fromType) {
 		let handlers = {};
 		let required = true;
 		let typed = false;
+		let defaults;
 		let types;
 		const validators = [];
 		if (isPlainObject(value)) {
 			typed = PROPERTY_TYPE in value;
 			const type = typed ? value[PROPERTY_TYPE] : value;
-			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey);
-			required = getRequired(key, value) ?? required;
+			defaults = getDefaults(value, prefixedKey, typed);
+			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey, typed);
+			required = getRequired(value, prefixedKey, typed) ?? required;
 			types = Array.isArray(type) ? type : [type];
 		} else types = Array.isArray(value) ? value : [value];
-		if (types.length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(value)));
+		if (types.length === 0) throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
 		const typesLength = types.length;
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
@@ -361,23 +389,28 @@ function getObjectValidator(original, origin, fromType) {
 				case isPlainObject(type):
 					validator = getObjectValidator(type, fullKey, typed);
 					break;
-				case isSchematic(type):
-					validator = getSchematicValidator(type);
+				case isSchema(type):
+					validator = getSchemaValidator(type);
 					break;
 				case TYPE_ALL.has(type):
 					validator = getNamedValidator(fullKey, type, handlers);
 					break;
-				default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(type)));
+				default: throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
 			}
 			validators.push(validator);
 		}
-		set.add(key);
+		required = required && !types.includes("undefined");
+		if (defaults != null && !required) throw new SchematicError(getDefaultRequiredMessage(prefixedKey));
+		const validator = getBaseValidator(validators);
+		if (defaults != null && Array.isArray(validator(defaults.value, getParameters(), false))) throw new SchematicError(getDefaultTypeMessage(prefixedKey, types));
 		items.push({
+			defaults,
+			required,
 			types,
-			key: fullKey,
-			required: required && !types.includes("undefined"),
-			validator: getBaseValidator(validators)
+			validator,
+			key: fullKey
 		});
+		set.add(key);
 	}
 	const validatorsLength = items.length;
 	return (input, parameters, get) => {
@@ -389,7 +422,7 @@ function getObjectValidator(original, origin, fromType) {
 					short: ""
 				},
 				value: input,
-				message: getInvalidInputMessage(input)
+				message: getInputTypeMessage(input)
 			};
 			if (parameters.reporting.throw) throw new ValidationError([information]);
 			parameters.information?.push(information);
@@ -414,15 +447,19 @@ function getObjectValidator(original, origin, fromType) {
 		const allInformation = [];
 		const output = {};
 		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
-			const { key, required, types, validator } = items[validatorIndex];
+			const { defaults, key, required, types, validator } = items[validatorIndex];
 			const value = input[key.short];
 			if (value === void 0) {
 				if (required) {
+					if (get && defaults != null) {
+						output[key.short] = clone(defaults.value);
+						continue;
+					}
 					if (parameters.reporting.none) return [];
 					const information = {
 						key,
 						value,
-						message: getInvalidMissingMessage(key.full, types)
+						message: getInputPropertyMissingMessage(key.full, types)
 					};
 					if (parameters.reporting.throw) throw new ValidationError([information]);
 					parameters.information?.push(information);
@@ -446,7 +483,7 @@ function getObjectValidator(original, origin, fromType) {
 			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
 				key,
 				value,
-				message: getInvalidTypeMessage(key.full, types, value)
+				message: getInputPropertyTypeMessage(key.full, types, value)
 			}];
 			if (parameters.reporting.throw) throw new ValidationError(information);
 			if (parameters.reporting.all) {
@@ -460,22 +497,23 @@ function getObjectValidator(original, origin, fromType) {
 		return allInformation.length === 0 ? true : allInformation;
 	};
 }
-function getRequired(key, obj) {
+function getRequired(obj, key, allowed) {
 	if (!("$required" in obj)) return;
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
 	return obj[PROPERTY_REQUIRED];
 }
 //#endregion
-//#region src/schematic.ts
+//#region src/schema.ts
 /**
-* A schematic for validating objects
+* A schema for validating objects
 */
-var Schematic = class {
+var Schema = class {
 	#validator;
 	constructor(validator) {
-		Object.defineProperty(this, PROPERTY_SCHEMATIC, { value: true });
+		Object.defineProperty(this, PROPERTY_SCHEMA, { value: true });
 		this.#validator = validator;
-		schematicValidator.set(this, validator);
+		schemaValidators.set(this, validator);
 	}
 	get(value, options) {
 		const parameters = getParameters(options);
@@ -492,11 +530,11 @@ var Schematic = class {
 		return error(parameters.reporting.all ? result : result[0]);
 	}
 };
-function schematic(schema) {
-	if (isSchematic(schema)) return schema;
+function schema(schema) {
+	if (isSchema(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schematic(getObjectValidator(schema));
+	return new Schema(getObjectValidator(schema));
 }
-const schematicValidator = /* @__PURE__ */ new WeakMap();
+const schemaValidators = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { SchematicError, ValidationError, instanceOf, isSchematic, schematic };
+export { SchematicError, ValidationError, instanceOf, isSchema, schema };

package/dist/models/infer.model.d.mts

@@ -1,35 +1,35 @@
-import { Schematic } from "../schematic.mjs";
-import { PlainSchema, Schema, SchemaProperty } from "./schema.plain.model.mjs";
+import { Schema } from "../schema.mjs";
+import { PlainSchematic, Schematic, SchematicProperty } from "./schematic.plain.model.mjs";
 import { IsOptionalProperty, ValueName, Values } from "./misc.model.mjs";
 import { Constructor, Simplify } from "@oscarpalmer/atoms/models";
 
 //#region src/models/infer.model.d.ts
 /**
- * Infers the TypeScript type from a {@link Schema} definition
+ * Infers the TypeScript type from a {@link Schematic} definition
  *
- * @template Model Schema to infer types from
+ * @template Model Schematic to infer types from
  *
  * @example
  * ```ts
- * const userSchema = {
+ * const userSchematic = {
  *   name: 'string',
  *   age: 'number',
  *   address: { $required: false, $type: 'string' },
- * } satisfies Schema;
+ * } satisfies Schematic;
  *
- * type User = Infer<typeof userSchema>;
+ * type User = Infer<typeof userSchematic>;
  * // { name: string; age: number; address?: string }
  * ```
  */
-type Infer<Model extends Schema> = Simplify<{ [Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]> } & { [Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]> }>;
+type Infer<Model extends Schematic> = Simplify<{ [Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]> } & { [Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]> }>;
 /**
- * Extracts keys from a {@link Schema} whose entries are optional _(i.e., `$required` is `false`)_
+ * Extracts keys from a {@link Schematic} whose entries are optional _(i.e., `$required` is `false`)_
  *
- * @template Model - {@link Schema} to extract optional keys from
+ * @template Model - {@link Schematic} to extract optional keys from
  */
-type InferOptionalKeys<Model extends Schema> = keyof { [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never };
+type InferOptionalKeys<Model extends Schematic> = keyof { [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never };
 /**
- * Infers the TypeScript type from a {@link SchemaProperty}'s `$type` field
+ * Infers the TypeScript type from a {@link SchematicProperty}'s `$type` field
  *
  * @template Value `$type` value _(single or array)_
  */
@@ -37,30 +37,30 @@ type InferPropertyType<Value> = Value extends (infer Item)[] ? InferPropertyValu
 /**
  * Maps a single `$type` definition to its TypeScript equivalent
  *
- * Resolves, in order: {@link Constructor} instances, {@link Schematic} models, {@link ValueName} strings, and nested {@link PlainSchema} objects
+ * Resolves, in order: {@link Constructor}s, {@link Schema} instances, {@link ValueName} values, and nested {@link PlainSchematic} objects
  *
  * @template Value single type definition
  */
-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 InferPropertyValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schema<infer Model> ? Model : Value extends ValueName ? Values[Value & ValueName] : Value extends PlainSchematic ? Infer<Value> : never;
 /**
- * Extracts keys from a {@link Schema} whose entries are required _(i.e., `$required` is not `false`)_
+ * Extracts keys from a {@link Schematic} whose entries are required _(i.e., `$required` is not `false`)_
  *
- * @template Model Schema to extract required keys from
+ * @template Model Schematic to extract required keys from
  */
-type InferRequiredKeys<Model extends Schema> = keyof { [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never };
+type InferRequiredKeys<Model extends Schematic> = keyof { [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never };
 /**
- * Infers the TypeScript type from a top-level {@link Schema} entry
+ * Infers the TypeScript type from a top-level {@link Schematic} entry
  *
- * @template Value Schema entry value _(single or array)_
+ * @template Value Schematic entry value _(single or array)_
  */
 type InferSchemaEntry<Value> = Value extends (infer Item)[] ? InferSchemaEntryValue<Item> : InferSchemaEntryValue<Value>;
 /**
  * Maps a single top-level schema entry to its TypeScript type
  *
- * Resolves, in order: {@link Constructor} instances, {@link Schematic} models, {@link SchemaProperty} objects, {@link PlainSchema} objects, and {@link ValueName} strings
+ * Resolves, in order: {@link Constructor}s, {@link Schema} instances, {@link SchemaProperty} objects, {@link PlainSchematic} objects, and {@link ValueName} values
  *
  * @template Value single schema entry
  */
-type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends PlainSchema ? Infer<Value & Schema> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
+type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schema<infer Model> ? Model : Value extends SchematicProperty ? InferPropertyType<Value['$type']> : Value extends PlainSchematic ? Infer<Value & Schematic> : Value extends ValueName ? Values[Value & ValueName] : never;
 //#endregion
 export { Infer, InferOptionalKeys, InferPropertyType, InferPropertyValue, InferRequiredKeys, InferSchemaEntry, InferSchemaEntryValue };

package/dist/models/misc.model.d.mts

@@ -1,4 +1,4 @@
-import { SchemaProperty } from "./schema.plain.model.mjs";
+import { SchematicProperty } from "./schematic.plain.model.mjs";
 
 //#region src/models/misc.model.d.ts
 /**
@@ -29,11 +29,11 @@ type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends
 /**
  * Determines whether a schema entry is optional
  *
- * Returns `true` if the entry is a {@link SchemaProperty} with `$required` set to `false`; otherwise returns `false`
+ * Returns `true` if the entry is a {@link SchematicProperty} with `$required` set to `false`; otherwise returns `false`
  *
  * @template Value Schema entry to check
  */
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : false;
+type IsOptionalProperty<Value> = Value extends SchematicProperty ? Value['$required'] extends false ? true : false : false;
 /**
  * Extracts the last member from a union type by leveraging contravariance of function parameter types
  *

package/dist/models/{schema.plain.model.d.mts → schematic.plain.model.d.mts}

@@ -1,43 +1,44 @@
-import { Schematic } from "../schematic.mjs";
+import { Schema } from "../schema.mjs";
 import { ExtractValueNames, ValueName, Values } from "./misc.model.mjs";
 import { Constructor } from "@oscarpalmer/atoms/models";
 
-//#region src/models/schema.plain.model.d.ts
+//#region src/models/schematic.plain.model.d.ts
 /**
- * A generic schema allowing nested schemas, {@link SchemaEntry} values, or arrays of {@link SchemaEntry} as values
+ * A generic schematic allowing nested schematics, {@link SchematicEntry} values, or arrays of {@link SchematicEntry} as values
  */
-type PlainSchema = {
-  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[] | undefined;
+type PlainSchematic = {
+  [key: string]: PlainSchematic | SchematicEntry | SchematicEntry[] | undefined;
 } & {
+  $default?: never;
   $required?: never;
   $type?: never;
   $validators?: never;
 };
 /**
- * A schema for validating objects
+ * A schematic for validating objects
  *
  * @example
  * ```ts
- * const schema: Schema = {
+ * const schematic = {
  *   name: 'string',
  *   age: 'number',
  *   tags: ['string', 'number'],
- * };
+ * } satisfies Schematic;
  * ```
  */
-type Schema = PlainSchema;
+type Schematic = PlainSchematic;
 /**
- * A union of all valid types for a single schema entry
+ * A union of all valid types for a single schematic entry
  *
- * Can be a {@link Constructor}, {@link PlainSchema}, {@link SchemaProperty}, {@link Schematic}, {@link ValueName} string, or a custom validator function
+ * Can be a {@link Constructor}, {@link PlainSchematic}, {@link SchematicProperty}, {@link Schema}, {@link ValueName}, or a custom validator function
  */
-type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+type SchematicEntry = Constructor | PlainSchematic | Schema<unknown> | SchematicProperty | ValueName | ((value: unknown) => boolean);
 /**
  * A property definition with explicit type(s), an optional requirement flag, and optional validators
  *
  * @example
  * ```ts
- * const prop: SchemaProperty = {
+ * const prop: SchematicProperty = {
  *   $required: false,
  *   $type: ['string', 'number'],
  *   $validators: {
@@ -47,7 +48,8 @@ type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknow
  * };
  * ```
  */
-type SchemaProperty = {
+type SchematicProperty = {
+  $default?: unknown;
   /**
    * Whether the property is required _(defaults to `true`)_
    */
@@ -62,11 +64,11 @@ type SchemaProperty = {
   $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 /**
- * A union of valid types for a {@link SchemaProperty}'s `$type` field
+ * A union of valid types for a {@link SchematicProperty}'s `$type` field
  *
- * Can be a {@link Constructor}, {@link PlainSchema}, {@link Schematic}, {@link ValueName} string, or a custom validator function
+ * Can be a {@link Constructor}, {@link PlainSchematic}, {@link Schema}, {@link ValueName} string, or a custom validator function
  */
-type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+type SchemaPropertyType = Constructor | PlainSchematic | Schema<unknown> | ValueName | ((value: unknown) => boolean);
 /**
  * A map of optional validator functions keyed by {@link ValueName}, used to add custom validation to {@link SchemaProperty} definitions
  *
@@ -83,4 +85,4 @@ type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | Value
  */
 type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
 //#endregion
-export { PlainSchema, PropertyValidators, Schema, SchemaEntry, SchemaProperty, SchemaPropertyType };
+export { PlainSchematic, PropertyValidators, SchemaPropertyType, Schematic, SchematicEntry, SchematicProperty };

package/dist/models/{schema.typed.model.d.mts → schematic.typed.model.d.mts}

@@ -1,12 +1,12 @@
 import { ToSchemaPropertyType, ToSchemaType } from "./transform.model.mjs";
-import { Schematic } from "../schematic.mjs";
-import { PropertyValidators } from "./schema.plain.model.mjs";
+import { Schema } from "../schema.mjs";
+import { PropertyValidators } from "./schematic.plain.model.mjs";
 import { OptionalKeys, RequiredKeys } from "./misc.model.mjs";
 import { PlainObject, Simplify } from "@oscarpalmer/atoms/models";
 
-//#region src/models/schema.typed.model.d.ts
+//#region src/models/schematic.typed.model.d.ts
 /**
- * A typed optional property definition generated by {@link TypedSchema} for optional keys, with `$required` set to `false` and excludes `undefined` from the type
+ * A typed optional property definition generated by {@link TypedSchematic} for optional keys, with `$required` set to `false` and excludes `undefined` from the type
  *
  * @template Value Property's type _(including `undefined`)_
  *
@@ -18,12 +18,13 @@ import { PlainObject, Simplify } from "@oscarpalmer/atoms/models";
  * ```
  */
 type TypedPropertyOptional<Value> = {
+  $default?: never;
   $required: false;
   $type: ToSchemaPropertyType<Exclude<Value, undefined>>;
   $validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
 };
 /**
- * A typed required property definition generated by {@link TypedSchema} for required keys, with `$required` defaulting to `true`
+ * A typed required property definition generated by {@link TypedSchematic} for required keys, with `$required` defaulting to `true`
  *
  * @template Value Property's type
  *
@@ -35,6 +36,7 @@ type TypedPropertyOptional<Value> = {
  * ```
  */
 type TypedPropertyRequired<Value> = {
+  $default?: unknown;
   $required?: true;
   $type: ToSchemaPropertyType<Value>;
   $validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
@@ -42,7 +44,7 @@ type TypedPropertyRequired<Value> = {
 /**
  * Creates a schema type constrained to match a TypeScript type
  *
- * Required keys map to {@link ToSchemaType} or {@link TypedPropertyRequired}; plain object values may also use {@link Schematic}. Optional keys map to {@link TypedPropertyOptional} or, for plain objects, {@link TypedSchemaOptional}
+ * Required keys map to {@link ToSchemaType} or {@link TypedPropertyRequired}; plain object values may also use {@link Schema}
  *
  * @template Model Object type to generate a schema for
  *
@@ -57,22 +59,6 @@ type TypedPropertyRequired<Value> = {
  * };
  * ```
  */
-type TypedSchema<Model extends PlainObject> = Simplify<{ [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>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]> }>;
-/**
- * A {@link TypedSchema} variant for optional nested objects, with `$required` fixed to `false`
- *
- * @template Model Nested object type
- */
-type TypedSchemaOptional<Model extends PlainObject> = {
-  $required: false;
-} & TypedSchema<Model>;
-/**
- * A {@link TypedSchema} variant for required nested objects, with `$required` defaulting to `true`
- *
- * @template Model Nested object type
- */
-type TypedSchemaRequired<Model extends PlainObject> = {
-  $required?: true;
-} & TypedSchema<Model>;
+type TypedSchematic<Model extends PlainObject> = Simplify<{ [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? Schema<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]> } & { [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? Schema<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]> }>;
 //#endregion
-export { TypedPropertyOptional, TypedPropertyRequired, TypedSchema };
+export { TypedPropertyOptional, TypedPropertyRequired, TypedSchematic };