@oscarpalmer/jhunal 0.24.0 → 0.26.0

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,13 +1,13 @@
-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;
@@ -15,30 +15,30 @@ type PlainSchema = {
   $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: {
@@ -48,7 +48,7 @@ type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknow
  * };
  * ```
  */
-type SchemaProperty = {
+type SchematicProperty = {
   $default?: unknown;
   /**
    * Whether the property is required _(defaults to `true`)_
@@ -64,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
  *
@@ -85,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`)_
  *
@@ -24,7 +24,7 @@ type TypedPropertyOptional<Value> = {
   $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
  *
@@ -44,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
  *
@@ -59,6 +59,6 @@ type TypedPropertyRequired<Value> = {
  * };
  * ```
  */
-type TypedSchema<Model extends PlainObject> = Simplify<{ [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? Schematic<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]> } & { [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]> }>;
+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 };

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

@@ -1,5 +1,5 @@
-import { TypedSchema } from "./schema.typed.model.mjs";
-import { Schematic } from "../schematic.mjs";
+import { TypedSchematic } from "./schematic.typed.model.mjs";
+import { Schema } from "../schema.mjs";
 import { DeduplicateTuple, UnionToTuple, UnwrapSingle, Values } from "./misc.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 
@@ -25,11 +25,11 @@ type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaProp
 /**
  * Converts a single type to its schema property equivalent
  *
- * Plain objects become {@link TypedSchema}; primitives go through {@link ToValueType}
+ * Plain objects become {@link TypedSchematic}; primitives go through {@link ToValueType}
  *
  * @template Value Type to convert
  */
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchematic<Value> : ToValueType<Value>;
 /**
  * Converts a TypeScript type to its {@link ValueName} representation, suitable for use as a top-level schema entry
  *
@@ -39,7 +39,7 @@ type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionTo
 /**
  * Maps a type to its {@link ValueName} string equivalent
  *
- * Resolves {@link Schematic} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
+ * Resolves {@link Schema} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
  *
  * @template Value Type to map
  *
@@ -50,6 +50,6 @@ type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionTo
  * // ToValueType<Date>      => 'date'
  * ```
  */
-type ToValueType<Value> = Value extends Schematic<any> ? Value : { [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never }[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
+type ToValueType<Value> = Value extends Schema<any> ? Value : { [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never }[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
 //#endregion
 export { MapToSchemaPropertyTypes, MapToValueTypes, ToSchemaPropertyType, ToSchemaPropertyTypeEach, ToSchemaType, ToValueType };

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

@@ -1,4 +1,4 @@
-import { Schematic } from "../schematic.mjs";
+import { Schema } from "../schema.mjs";
 import { ValueName } from "./misc.model.mjs";
 import { GenericCallback, PlainObject } from "@oscarpalmer/atoms/models";
 
@@ -87,6 +87,6 @@ type ValidatorParameters = {
   reporting: ReportingInformation;
   strict: boolean;
 };
-type ValidatorType = Function | PlainObject | Schematic<unknown> | ValueName;
+type ValidatorType = Function | PlainObject | Schema<unknown> | ValueName;
 //#endregion
 export { GetOptions, IsOptions, NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, Validator, ValidatorDefaults, ValidatorItem, ValidatorParameters, ValidatorType };

package/dist/{schematic.d.mts → schema.d.mts}

@@ -1,17 +1,17 @@
 import { Infer } from "./models/infer.model.mjs";
-import { TypedSchema } from "./models/schema.typed.model.mjs";
+import { TypedSchematic } from "./models/schematic.typed.model.mjs";
 import { GetOptions, IsOptions, ValidationInformation, Validator } from "./models/validation.model.mjs";
-import { Schema } from "./models/schema.plain.model.mjs";
+import { Schematic } from "./models/schematic.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 import { Result } from "@oscarpalmer/atoms/result/models";
 
-//#region src/schematic.d.ts
+//#region src/schema.d.ts
 /**
- * A schematic for validating objects
+ * A schema for validating objects
  */
-declare class Schematic<Model> {
+declare class Schema<Model> {
   #private;
-  private readonly $schematic;
+  private readonly $schema;
   constructor(validator: Validator);
   /**
    * Parse a value according to the schema
@@ -75,7 +75,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Deeply cloned value, or `undefined` if it's invalid
    */
-  get(value: unknown, options: GetOptions<'none'>): Model | undefined;
+  get(value: unknown, options: Partial<GetOptions<'none'>>): Model | undefined;
   /**
    * Parse a value according to the schema
    *
@@ -147,7 +147,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise `false`
    */
-  is(value: unknown, options: IsOptions<'none'>): value is Model;
+  is(value: unknown, options: Partial<IsOptions<'none'>>): value is Model;
   /**
    * Does the value match the schema?
    *
@@ -159,21 +159,21 @@ declare class Schematic<Model> {
   is(value: unknown, strict?: true): value is Model;
 }
 /**
- * Create a schematic from a schema
+ * Create a schema from a schematic
  * @template Model Schema type
- * @param schema Schema to create the schematic from
- * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
- * @returns A schematic for the given schema
+ * @param schema Schematic to create the schema from
+ * @throws Throws {@link SchematicError} if the schematic can not be converted into a schema
+ * @returns A schema for the given schematic
  */
-declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
+declare function schema<Model extends Schematic>(schema: Model): Schema<Infer<Model>>;
 /**
- * Create a schematic from a typed schema
+ * Create a schema from a typed schematic
  * @template Model Existing type
- * @param schema Typed schema to create the schematic from
- * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
- * @returns A schematic for the given typed schema
+ * @param schema Typed schematic to create the schema from
+ * @throws Throws {@link SchematicError} if the schematic can not be converted into a schema
+ * @returns A schema for the given typed schematic
  */
-declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
-declare const schematicValidator: WeakMap<Schematic<unknown>, Validator>;
+declare function schema<Model extends PlainObject>(schema: TypedSchematic<Model>): Schema<Model>;
+declare const schemaValidators: WeakMap<Schema<unknown>, Validator>;
 //#endregion
-export { Schematic, schematic, schematicValidator };
+export { Schema, schema, schemaValidators };

package/dist/{schematic.mjs → schema.mjs}

@@ -1,24 +1,24 @@
-import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
-import { getParameters, isSchematic } from "./helpers/misc.helper.mjs";
+import { PROPERTY_SCHEMA, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
+import { getParameters, isSchema } from "./helpers/misc.helper.mjs";
 import { SchematicError } from "./models/validation.model.mjs";
 import { getObjectValidator } from "./validator/object.validator.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 import { error, ok } from "@oscarpalmer/atoms/result/misc";
-//#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);
 		const result = this.#validator(value, parameters, true);
-		if (result === true) return parameters.reporting.none || parameters.reporting.throw ? parameters.output : ok(parameters.output);
+		if (result === true) return parameters.reporting.none || parameters.reporting.throw ? parameters.clone ? parameters.output : value : ok(parameters.clone ? parameters.output : value);
 		if (parameters.reporting.none) return;
 		return error(parameters.reporting.all ? result : result[0]);
 	}
@@ -30,11 +30,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 { Schematic, schematic, schematicValidator };
+export { Schema, schema, schemaValidators };

package/dist/validator/object.validator.mjs

@@ -1,12 +1,12 @@
 import { PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, TYPE_ALL } from "../constants.mjs";
-import { getParameters, isSchematic } from "../helpers/misc.helper.mjs";
+import { getParameters, isSchema } from "../helpers/misc.helper.mjs";
 import { SchematicError, ValidationError } from "../models/validation.model.mjs";
 import { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage } from "../helpers/message.helper.mjs";
 import { getBaseValidator } from "./base.validator.mjs";
 import { getFunctionValidator } from "./function.validator.mjs";
 import { getNamedHandlers } from "./named.handler.mjs";
 import { getNamedValidator } from "./named.validator.mjs";
-import { getSchematicValidator } from "./schematic.validator.mjs";
+import { getSchemaValidator } from "./schema.validator.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
 import { clone } from "@oscarpalmer/atoms/value/clone";
@@ -35,8 +35,8 @@ function getObjectValidator(original, origin, fromType) {
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 		const value = original[key];
-		if (value == null) throw new SchematicError(getSchematicPropertyNullableMessage(join([origin?.full, key], ".")));
 		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
+		if (value == null) throw new SchematicError(getSchematicPropertyNullableMessage(prefixedKey));
 		const fullKey = {
 			full: prefixedKey,
 			short: key
@@ -67,8 +67,8 @@ 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);
@@ -92,20 +92,18 @@ function getObjectValidator(original, origin, fromType) {
 	}
 	const validatorsLength = items.length;
 	return (input, parameters, get) => {
-		if (!isPlainObject(input)) {
-			if (origin != null) return [];
-			const information = {
-				key: {
-					full: "",
-					short: ""
-				},
-				value: input,
-				message: getInputTypeMessage(input)
-			};
-			if (parameters.reporting.throw) throw new ValidationError([information]);
-			parameters.information?.push(information);
-			return [information];
-		}
+		if (!isPlainObject(input)) return origin == null ? report({
+			key: {
+				full: "",
+				short: ""
+			},
+			message: {
+				arguments: [input],
+				callback: getInputTypeMessage
+			},
+			original: parameters,
+			value: input
+		}, true) : [];
 		if (parameters.strict) {
 			const unknownKeys = Object.keys(input).filter((key) => !set.has(key));
 			if (unknownKeys.length > 0) {
@@ -122,6 +120,7 @@ function getObjectValidator(original, origin, fromType) {
 				return [information];
 			}
 		}
+		const getAndClone = get && parameters.clone;
 		const allInformation = [];
 		const output = {};
 		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
@@ -130,22 +129,24 @@ function getObjectValidator(original, origin, fromType) {
 			if (value === void 0) {
 				if (required) {
 					if (get && defaults != null) {
-						output[key.short] = clone(defaults.value);
+						const defaultValue = clone(defaults.value);
+						if (parameters.clone) output[key.short] = defaultValue;
+						else input[key.short] = defaultValue;
 						continue;
 					}
 					if (parameters.reporting.none) return [];
-					const information = {
+					const reported = report({
 						key,
 						value,
-						message: getInputPropertyMissingMessage(key.full, types)
-					};
-					if (parameters.reporting.throw) throw new ValidationError([information]);
-					parameters.information?.push(information);
-					if (parameters.reporting.all) {
-						allInformation.push(information);
-						continue;
-					}
-					return [information];
+						information: { all: allInformation },
+						message: {
+							arguments: [key.full, types],
+							callback: getInputPropertyMissingMessage
+						},
+						original: parameters
+					});
+					if (reported == null) continue;
+					return reported;
 				}
 				continue;
 			}
@@ -154,23 +155,32 @@ function getObjectValidator(original, origin, fromType) {
 			const result = validator(value, parameters, get);
 			parameters.output = previousOutput;
 			if (result === true) {
-				if (get && !isPlainObject(value)) output[key.short] = parameters.clone ? clone(value) : value;
+				if (getAndClone && !isPlainObject(value)) output[key.short] = clone(value);
 				continue;
 			}
 			if (parameters.reporting.none) return [];
-			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
+			const reported = report({
 				key,
 				value,
-				message: getInputPropertyTypeMessage(key.full, types, value)
-			}];
-			if (parameters.reporting.throw) throw new ValidationError(information);
-			if (parameters.reporting.all) {
-				allInformation.push(...information);
-				continue;
-			}
-			return information;
+				extract: false,
+				information: {
+					all: allInformation,
+					existing: typeof result !== "boolean" && result.length > 0 ? result : void 0
+				},
+				message: {
+					arguments: [
+						key.full,
+						types,
+						value
+					],
+					callback: getInputPropertyTypeMessage
+				},
+				original: parameters
+			});
+			if (reported == null) continue;
+			return reported;
 		}
-		if (get) if (origin == null) parameters.output = output;
+		if (getAndClone) if (origin == null) parameters.output = output;
 		else parameters.output[origin.short] = output;
 		return allInformation.length === 0 ? true : allInformation;
 	};
@@ -181,5 +191,17 @@ function getRequired(obj, key, allowed) {
 	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
 	return obj[PROPERTY_REQUIRED];
 }
+function report(parameters, getReports) {
+	const { information, message, original } = parameters;
+	const reported = information?.existing ?? [{
+		key: parameters.key,
+		value: parameters.value,
+		message: message.callback(...message.arguments)
+	}];
+	if (original.reporting.throw) throw new ValidationError(reported);
+	information?.all.push(...reported);
+	if (parameters.extract ?? true) original.information?.push(...reported);
+	if ((getReports ?? false) || !original.reporting.all) return reported;
+}
 //#endregion
 export { getObjectValidator };

package/dist/validator/schema.validator.d.mts

@@ -0,0 +1,7 @@
+import { Validator } from "../models/validation.model.mjs";
+import { Schema } from "../schema.mjs";
+
+//#region src/validator/schema.validator.d.ts
+declare function getSchemaValidator(schematic: Schema<unknown>): Validator;
+//#endregion
+export { getSchemaValidator };

package/dist/validator/{schematic.validator.mjs → schema.validator.mjs}

@@ -1,8 +1,8 @@
-import { schematicValidator } from "../schematic.mjs";
+import { schemaValidators } from "../schema.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
-//#region src/validator/schematic.validator.ts
-function getSchematicValidator(schematic) {
-	const validator = schematicValidator.get(schematic);
+//#region src/validator/schema.validator.ts
+function getSchemaValidator(schematic) {
+	const validator = schemaValidators.get(schematic);
 	return (input, parameters, get) => {
 		let result;
 		if (isPlainObject(input)) result = validator(input, parameters, get);
@@ -13,4 +13,4 @@ function getSchematicValidator(schematic) {
 	};
 }
 //#endregion
-export { getSchematicValidator };
+export { getSchemaValidator };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/jhunal",
-	"version": "0.24.0",
+	"version": "0.26.0",
 	"description": "Flies free beneath the glistening moons…",
 	"keywords": [
 		"schema",