@oscarpalmer/jhunal 0.23.0 → 0.25.0

package/dist/constants.d.mts

@@ -8,12 +8,13 @@ declare const CONJUNCTION_OR_COMMA = ", or ";
 declare const CONJUNCTION_AND = " and ";
 declare const CONJUNCTION_AND_COMMA = ", and ";
 declare const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
-declare const NAME_SCHEMATIC = "Schematic";
-declare const NAME_SCHEMATIC_PREFIXED = "a Schematic";
+declare const NAME_SCHEMA = "Schema";
+declare const NAME_SCHEMA_PREFIXED = "a Schema";
 declare const NAME_ERROR_SCHEMATIC = "SchematicError";
 declare const NAME_ERROR_VALIDATION = "ValidationError";
+declare const PROPERTY_DEFAULT = "$default";
 declare const PROPERTY_REQUIRED = "$required";
-declare const PROPERTY_SCHEMATIC = "$schematic";
+declare const PROPERTY_SCHEMA = "$schema";
 declare const PROPERTY_TYPE = "$type";
 declare const PROPERTY_VALIDATORS = "$validators";
 declare const VALIDATION_MESSAGE_INVALID_INPUT = "Expected an object as input but received <>";
@@ -27,8 +28,10 @@ declare const REPORTING_FIRST: ReportingType;
 declare const REPORTING_NONE: ReportingType;
 declare const REPORTING_THROW: ReportingType;
 declare const REPORTING_TYPES: Set<ReportingType>;
+declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED = "'<>' has a default value but is not required";
+declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE = "Expected default value for property '<>' to be <>";
 declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<>.<>' property is not allowed for schemas in $type";
+declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<>.<>' property is not allowed for plain schemas";
 declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE = "'<>' property must not be 'null' or 'undefined'";
 declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 declare const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
@@ -47,4 +50,4 @@ declare const VALIDATABLE_TYPES: Set<keyof Values>;
 declare const TYPE_ALL: Set<keyof Values>;
 declare const PREFIXED_TYPES: Record<ValueName, string>;
 //#endregion
-export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMATIC, NAME_SCHEMATIC_PREFIXED, PREFIXED_TYPES, PROPERTY_REQUIRED, PROPERTY_SCHEMATIC, PROPERTY_TYPE, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS };
+export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMA, NAME_SCHEMA_PREFIXED, PREFIXED_TYPES, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMA, PROPERTY_TYPE, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS };

package/dist/constants.mjs

@@ -5,12 +5,13 @@ const CONJUNCTION_OR_COMMA = ", or ";
 const CONJUNCTION_AND = " and ";
 const CONJUNCTION_AND_COMMA = ", and ";
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
-const NAME_SCHEMATIC = "Schematic";
-const NAME_SCHEMATIC_PREFIXED = "a Schematic";
+const NAME_SCHEMA = "Schema";
+const NAME_SCHEMA_PREFIXED = "a Schema";
 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";
@@ -40,27 +43,21 @@ 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 TEMPLATE_PATTERN = "<>";
 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 VALIDATABLE_TYPES = 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"
 ]);
 const TYPE_ALL = new Set([
 	...VALIDATABLE_TYPES,
@@ -69,16 +66,16 @@ const TYPE_ALL = new Set([
 ]);
 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
 };
 //#endregion
-export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMATIC, NAME_SCHEMATIC_PREFIXED, PREFIXED_TYPES, PROPERTY_REQUIRED, PROPERTY_SCHEMATIC, PROPERTY_TYPE, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS };
+export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMA, NAME_SCHEMA_PREFIXED, PREFIXED_TYPES, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMA, PROPERTY_TYPE, PROPERTY_VALIDATORS, REPORTING_ALL, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TEMPLATE_PATTERN, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS };

package/dist/helpers/message.helper.d.mts

@@ -2,10 +2,16 @@ import { ValidatorType } from "../models/validation.model.mjs";
 import { ValueName } from "../models/misc.model.mjs";
 
 //#region src/helpers/message.helper.d.ts
-declare function getInvalidInputMessage(actual: unknown): string;
-declare function getInvalidMissingMessage(key: string, types: ValidatorType[]): string;
-declare function getInvalidTypeMessage(key: string, types: ValidatorType[], actual: unknown): string;
-declare function getInvalidValidatorMessage(key: string, type: ValueName, index: number, length: number): string;
+declare function getDefaultRequiredMessage(key: string): string;
+declare function getDefaultTypeMessage(key: string, types: ValidatorType[]): string;
+declare function getDisallowedMessage(key: string, property: string): string;
+declare function getInputTypeMessage(actual: unknown): string;
+declare function getInputPropertyMissingMessage(key: string, types: ValidatorType[]): string;
+declare function getInputPropertyTypeMessage(key: string, types: ValidatorType[], actual: unknown): string;
+declare function getInputPropertyValidatorMessage(key: string, type: ValueName, index: number, length: number): string;
+declare function getSchematicPropertyNullableMessage(key: string): string;
+declare function getSchematicPropertyTypeMessage(key: string): string;
+declare function getRequiredMessage(key: string): string;
 declare function getUnknownKeysMessage(keys: string[]): string;
 //#endregion
-export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage };
+export { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };

package/dist/helpers/message.helper.mjs

@@ -1,26 +1,45 @@
-import { CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, PREFIXED_TYPES, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS } from "../constants.mjs";
+import { CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, PREFIXED_TYPES, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, TYPE_ALL, TYPE_ARRAY, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS } from "../constants.mjs";
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 //#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;
@@ -28,9 +47,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) {
@@ -66,5 +82,11 @@ 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
-export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage };
+export { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };

package/dist/helpers/misc.helper.d.mts

@@ -1,10 +1,10 @@
 import { ReportingInformation, ValidatorParameters } from "../models/validation.model.mjs";
-import { Schematic } from "../schematic.mjs";
+import { Schema } from "../schema.mjs";
 import { Constructor } from "@oscarpalmer/atoms/models";
 
 //#region src/helpers/misc.helper.d.ts
 declare function getParameters(input?: unknown): ValidatorParameters;
-declare function getReporting(value: unknown): ReportingInformation;
+declare function getReporting(value?: unknown): ReportingInformation;
 /**
  * Creates a validator function for a given constructor
  * @param constructor - Constructor to check against
@@ -17,6 +17,6 @@ declare function instanceOf<Instance>(constructor: Constructor<Instance>): (valu
  * @param value Value to check
  * @returns `true` if the value is a schematic, `false` otherwise
  */
-declare function isSchematic(value: unknown): value is Schematic<never>;
+declare function isSchema(value: unknown): value is Schema<never>;
 //#endregion
-export { getParameters, getReporting, instanceOf, isSchematic };
+export { getParameters, getReporting, instanceOf, isSchema };

package/dist/helpers/misc.helper.mjs

@@ -5,7 +5,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 {
@@ -49,8 +49,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
-export { getParameters, getReporting, instanceOf, isSchematic };
+export { getParameters, getReporting, instanceOf, isSchema };

package/dist/index.d.mts

@@ -1,42 +1,43 @@
 import { Constructor, GenericCallback, PlainObject, Simplify } from "@oscarpalmer/atoms/models";
 import { Result } from "@oscarpalmer/atoms/result/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: {
@@ -46,7 +47,8 @@ type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknow
  * };
  * ```
  */
-type SchemaProperty = {
+type SchematicProperty = {
+  $default?: unknown;
   /**
    * Whether the property is required _(defaults to `true`)_
    */
@@ -61,11 +63,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
  *
@@ -111,11 +113,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
  *
@@ -225,31 +227,31 @@ type Values = {
 //#endregion
 //#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)_
  */
@@ -257,31 +259,31 @@ 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
 //#region src/models/transform.model.d.ts
 /**
@@ -305,11 +307,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
  *
@@ -319,7 +321,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
  *
@@ -330,11 +332,11 @@ 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
-//#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`)_
  *
@@ -346,12 +348,13 @@ type ToValueType<Value> = Value extends Schematic<any> ? Value : { [Key in keyof
  * ```
  */
 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
  *
@@ -363,6 +366,7 @@ type TypedPropertyOptional<Value> = {
  * ```
  */
 type TypedPropertyRequired<Value> = {
+  $default?: unknown;
   $required?: true;
   $type: ToSchemaPropertyType<Value>;
   $validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
@@ -370,7 +374,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
  *
@@ -385,31 +389,15 @@ 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
-//#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
@@ -557,21 +545,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 function schema<Model extends PlainObject>(schema: TypedSchematic<Model>): Schema<Model>;
 //#endregion
 //#region src/models/validation.model.d.ts
 type ReportingInformation = Record<ReportingType, boolean> & {
@@ -660,6 +648,6 @@ declare function instanceOf<Instance>(constructor: Constructor<Instance>): (valu
  * @param value Value to check
  * @returns `true` if the value is a schematic, `false` otherwise
  */
-declare function isSchematic(value: unknown): value is Schematic<never>;
+declare function isSchema(value: unknown): value is Schema<never>;
 //#endregion
-export { type GetOptions, type IsOptions, type Schema, type Schematic, SchematicError, type TypedSchema, ValidationError, instanceOf, isSchematic, schematic };
+export { type GetOptions, type IsOptions, type Schema, type Schematic, SchematicError, type TypedSchematic, ValidationError, instanceOf, isSchema, schema };