@oscarpalmer/jhunal 0.22.0 → 0.24.0

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

@@ -46,21 +46,42 @@ type ValidationInformationKey = {
   full: string;
   short: string;
 };
-/**
- * Options for validation
- */
-type ValidationOptions<Errors extends ReportingType> = {
+type BaseOptions<Errors extends ReportingType> = {
   /**
    * How should validation failures be reported; see {@link ReportingType} _(defaults to `'none'`)_
    */
-  errors?: Errors;
+  errors: Errors;
   /**
    * Validate if unknown keys are present in the object? _(defaults to `false`)_
    */
   strict?: boolean;
 };
-type Validator = (input: unknown, parameters: ValidatorParameters, get: boolean) => boolean | ValidationInformation[];
+/**
+ * Options for validating and getting a value from an input
+ */
+type GetOptions<Errors extends ReportingType> = BaseOptions<Errors> & {
+  /**
+   * Get a deeply cloned version of the input? _(defaults to `true`)_
+   */
+  clone?: boolean;
+};
+/**
+ * Options for validation an input value
+ */
+type IsOptions<Errors extends ReportingType> = BaseOptions<Errors>;
+type Validator = (input: unknown, parameters: ValidatorParameters, get: boolean) => true | ValidationInformation[];
+type ValidatorDefaults = {
+  value: unknown;
+};
+type ValidatorItem = {
+  defaults: ValidatorDefaults | undefined;
+  key: ValidationInformationKey;
+  required: boolean;
+  types: ValidatorType[];
+  validator: Validator;
+};
 type ValidatorParameters = {
+  clone: boolean;
   information?: ValidationInformation[];
   output: PlainObject;
   reporting: ReportingInformation;
@@ -68,4 +89,4 @@ type ValidatorParameters = {
 };
 type ValidatorType = Function | PlainObject | Schematic<unknown> | ValueName;
 //#endregion
-export { NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, Validator, ValidatorParameters, ValidatorType };
+export { GetOptions, IsOptions, NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, Validator, ValidatorDefaults, ValidatorItem, ValidatorParameters, ValidatorType };

package/dist/schematic.d.mts

@@ -1,6 +1,6 @@
 import { Infer } from "./models/infer.model.mjs";
 import { TypedSchema } from "./models/schema.typed.model.mjs";
-import { ValidationInformation, ValidationOptions, Validator } from "./models/validation.model.mjs";
+import { GetOptions, IsOptions, ValidationInformation, Validator } from "./models/validation.model.mjs";
 import { Schema } from "./models/schema.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 import { Result } from "@oscarpalmer/atoms/result/models";
@@ -21,7 +21,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
    */
-  get(value: unknown, options: ValidationOptions<'throw'>): Model;
+  get(value: unknown, options: GetOptions<'throw'>): Model;
   /**
    * Parse a value according to the schema
    *
@@ -39,7 +39,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Result holding deeply cloned value or all validation information
    */
-  get(value: unknown, options: ValidationOptions<'all'>): Result<Model, ValidationInformation[]>;
+  get(value: unknown, options: GetOptions<'all'>): Result<Model, ValidationInformation[]>;
   /**
    * Parse a value according to the schema
    *
@@ -57,7 +57,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Result holding deeply cloned value or all validation information
    */
-  get(value: unknown, options: ValidationOptions<'first'>): Result<Model, ValidationInformation>;
+  get(value: unknown, options: GetOptions<'first'>): Result<Model, ValidationInformation>;
   /**
    * Parse a value according to the schema
    *
@@ -67,6 +67,15 @@ declare class Schematic<Model> {
    * @returns Result holding deeply cloned value or all validation information
    */
   get(value: unknown, errors: 'first'): Result<Model, ValidationInformation>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or `undefined` if the value does not match the schema
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Deeply cloned value, or `undefined` if it's invalid
+   */
+  get(value: unknown, options: GetOptions<'none'>): Model | undefined;
   /**
    * Parse a value according to the schema
    *
@@ -84,7 +93,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise throws an error
    */
-  is(value: unknown, options: ValidationOptions<'throw'>): asserts value is Model;
+  is(value: unknown, options: IsOptions<'throw'>): asserts value is Model;
   /**
    * Does the value match the schema?
    *
@@ -102,7 +111,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns Result holding `true` or all validation information
    */
-  is(value: unknown, options: ValidationOptions<'all'>): Result<true, ValidationInformation[]>;
+  is(value: unknown, options: IsOptions<'all'>): Result<true, ValidationInformation[]>;
   /**
    * Does the value match the schema?
    *
@@ -120,7 +129,7 @@ declare class Schematic<Model> {
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise `false`
    */
-  is(value: unknown, options: ValidationOptions<'first'>): Result<true, ValidationInformation>;
+  is(value: unknown, options: IsOptions<'first'>): Result<true, ValidationInformation>;
   /**
    * Does the value match the schema?
    *
@@ -130,6 +139,15 @@ declare class Schematic<Model> {
    * @returns `true` if the value matches the schema, otherwise `false`
    */
   is(value: unknown, errors: 'first'): Result<true, ValidationInformation>;
+  /**
+   * Does the value match the schema?
+   *
+   * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures
+   * @param value Value to validate
+   * @param options Validation options
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown, options: IsOptions<'none'>): value is Model;
   /**
    * Does the value match the schema?
    *

package/dist/schematic.mjs

@@ -1,7 +1,7 @@
 import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
-import { getParameters, isSchematic } from "./helpers.mjs";
+import { getParameters, isSchematic } from "./helpers/misc.helper.mjs";
 import { SchematicError } from "./models/validation.model.mjs";
-import { getObjectValidator } from "./validation.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
@@ -18,13 +18,15 @@ var Schematic = class {
 	get(value, options) {
 		const parameters = getParameters(options);
 		const result = this.#validator(value, parameters, true);
-		if (typeof result === "boolean") return parameters.reporting.none ? result ? parameters.output : void 0 : ok(parameters.output);
+		if (result === true) return parameters.reporting.none || parameters.reporting.throw ? parameters.output : ok(parameters.output);
+		if (parameters.reporting.none) return;
 		return error(parameters.reporting.all ? result : result[0]);
 	}
 	is(value, options) {
 		const parameters = getParameters(options);
 		const result = this.#validator(value, parameters, false);
-		if (typeof result === "boolean") return parameters.reporting.none ? result : ok(result);
+		if (result === true) return parameters.reporting.none || parameters.reporting.throw ? result : ok(result);
+		if (parameters.reporting.none) return false;
 		return error(parameters.reporting.all ? result : result[0]);
 	}
 };

package/dist/validator/base.validator.d.mts

@@ -0,0 +1,6 @@
+import { Validator } from "../models/validation.model.mjs";
+
+//#region src/validator/base.validator.d.ts
+declare function getBaseValidator(validators: Validator[]): Validator;
+//#endregion
+export { getBaseValidator };

package/dist/validator/base.validator.mjs

@@ -0,0 +1,19 @@
+//#region src/validator/base.validator.ts
+function getBaseValidator(validators) {
+	const { length } = validators;
+	return (input, parameters, get) => {
+		const allInformation = [];
+		for (let index = 0; index < length; index += 1) {
+			const previousInformation = parameters.information;
+			parameters.information = [];
+			const result = validators[index](input, parameters, get);
+			parameters.information = previousInformation;
+			if (result === true) return true;
+			parameters.information?.push(...result);
+			allInformation.push(...result);
+		}
+		return allInformation;
+	};
+}
+//#endregion
+export { getBaseValidator };

package/dist/validator/function.validator.d.mts

@@ -0,0 +1,6 @@
+import { Validator } from "../models/validation.model.mjs";
+
+//#region src/validator/function.validator.d.ts
+declare function getFunctionValidator(fn: Function): Validator;
+//#endregion
+export { getFunctionValidator };

package/dist/validator/function.validator.mjs

@@ -0,0 +1,9 @@
+import { instanceOf } from "../helpers/misc.helper.mjs";
+import { isConstructor } from "@oscarpalmer/atoms/is";
+//#region src/validator/function.validator.ts
+function getFunctionValidator(fn) {
+	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
+	return (input) => validator(input) ? true : [];
+}
+//#endregion
+export { getFunctionValidator };

package/dist/validator/named.handler.d.mts

@@ -0,0 +1,6 @@
+import { NamedValidatorHandlers } from "../models/validation.model.mjs";
+
+//#region src/validator/named.handler.d.ts
+declare function getNamedHandlers(original: unknown, prefix: string, allowed: boolean): NamedValidatorHandlers;
+//#endregion
+export { getNamedHandlers };

package/dist/validator/named.handler.mjs

@@ -0,0 +1,23 @@
+import { PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "../constants.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/validator/named.handler.ts
+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;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!TYPE_ALL.has(key)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		const value = original[key];
+		handlers[key] = (Array.isArray(value) ? value : [value]).map((item) => {
+			if (typeof item !== "function") throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key).replace("<>", prefix));
+			return item;
+		});
+	}
+	return handlers;
+}
+//#endregion
+export { getNamedHandlers };

package/dist/validator/named.validator.d.mts

@@ -0,0 +1,7 @@
+import { NamedValidatorHandlers, ValidationInformationKey, Validator } from "../models/validation.model.mjs";
+import { ValueName } from "../models/misc.model.mjs";
+
+//#region src/validator/named.validator.d.ts
+declare function getNamedValidator(key: ValidationInformationKey, name: ValueName, handlers: NamedValidatorHandlers): Validator;
+//#endregion
+export { getNamedValidator };

package/dist/validator/named.validator.mjs

@@ -0,0 +1,38 @@
+import { getInputPropertyValidatorMessage } from "../helpers/message.helper.mjs";
+//#region src/validator/named.validator.ts
+function getNamedValidator(key, name, handlers) {
+	const validator = namedValidators[name];
+	const named = handlers[name] ?? [];
+	const { length } = named;
+	return (input, parameters) => {
+		if (!validator(input)) return [];
+		for (let index = 0; index < length; index += 1) {
+			const handler = named[index];
+			if (handler(input) === true) continue;
+			const information = {
+				key,
+				validator,
+				message: getInputPropertyValidatorMessage(key.full, name, index, length),
+				value: input
+			};
+			parameters.information?.push(information);
+			return parameters.reporting.none ? [] : [information];
+		}
+		return true;
+	};
+}
+const namedValidators = {
+	array: Array.isArray,
+	bigint: (value) => typeof value === "bigint",
+	boolean: (value) => typeof value === "boolean",
+	date: (value) => value instanceof Date,
+	function: (value) => typeof value === "function",
+	null: (value) => value === null,
+	number: (value) => typeof value === "number",
+	object: (value) => typeof value === "object" && value !== null,
+	string: (value) => typeof value === "string",
+	symbol: (value) => typeof value === "symbol",
+	undefined: (value) => value === void 0
+};
+//#endregion
+export { getNamedValidator };

package/dist/validator/object.validator.d.mts

@@ -0,0 +1,7 @@
+import { ValidationInformationKey, Validator } from "../models/validation.model.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/validator/object.validator.d.ts
+declare function getObjectValidator(original: PlainObject, origin?: ValidationInformationKey, fromType?: boolean): Validator;
+//#endregion
+export { getObjectValidator };

package/dist/validator/object.validator.mjs

@@ -0,0 +1,185 @@
+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 { 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 { isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms/string";
+import { clone } from "@oscarpalmer/atoms/value/clone";
+//#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;
+}
+function getObjectValidator(original, origin, fromType) {
+	const keys = Object.keys(original);
+	const keysLength = keys.length;
+	if (keysLength === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		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(getSchematicPropertyNullableMessage(join([origin?.full, key], ".")));
+		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
+		const fullKey = {
+			full: prefixedKey,
+			short: key
+		};
+		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;
+			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(getSchematicPropertyTypeMessage(prefixedKey));
+		const typesLength = types.length;
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			const type = types[typeIndex];
+			let validator;
+			switch (true) {
+				case typeof type === "function":
+					validator = getFunctionValidator(type);
+					break;
+				case isPlainObject(type):
+					validator = getObjectValidator(type, fullKey, typed);
+					break;
+				case isSchematic(type):
+					validator = getSchematicValidator(type);
+					break;
+				case TYPE_ALL.has(type):
+					validator = getNamedValidator(fullKey, type, handlers);
+					break;
+				default: throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
+			}
+			validators.push(validator);
+		}
+		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,
+			validator,
+			key: fullKey
+		});
+		set.add(key);
+	}
+	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 (parameters.strict) {
+			const unknownKeys = Object.keys(input).filter((key) => !set.has(key));
+			if (unknownKeys.length > 0) {
+				const information = {
+					key: origin ?? {
+						full: "",
+						short: ""
+					},
+					message: getUnknownKeysMessage(unknownKeys),
+					value: input
+				};
+				if (parameters.reporting.throw) throw new ValidationError([information]);
+				parameters.information?.push(information);
+				return [information];
+			}
+		}
+		const allInformation = [];
+		const output = {};
+		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
+			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: 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];
+				}
+				continue;
+			}
+			const previousOutput = parameters.output;
+			parameters.output = output;
+			const result = validator(value, parameters, get);
+			parameters.output = previousOutput;
+			if (result === true) {
+				if (get && !isPlainObject(value)) output[key.short] = parameters.clone ? clone(value) : value;
+				continue;
+			}
+			if (parameters.reporting.none) return [];
+			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
+				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;
+		}
+		if (get) if (origin == null) parameters.output = output;
+		else parameters.output[origin.short] = output;
+		return allInformation.length === 0 ? true : allInformation;
+	};
+}
+function getRequired(obj, key, allowed) {
+	if (!("$required" in obj)) return;
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
+	return obj[PROPERTY_REQUIRED];
+}
+//#endregion
+export { getObjectValidator };

package/dist/validator/schematic.validator.d.mts

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

package/dist/validator/schematic.validator.mjs

@@ -0,0 +1,16 @@
+import { schematicValidator } from "../schematic.mjs";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/validator/schematic.validator.ts
+function getSchematicValidator(schematic) {
+	const validator = schematicValidator.get(schematic);
+	return (input, parameters, get) => {
+		let result;
+		if (isPlainObject(input)) result = validator(input, parameters, get);
+		else result = [];
+		if (result === true) return result;
+		parameters.information?.push(...result);
+		return result;
+	};
+}
+//#endregion
+export { getSchematicValidator };

package/package.json

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

package/src/constants.ts

@@ -25,6 +25,8 @@ export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
 
 export const NAME_SCHEMATIC = 'Schematic';
 
+export const NAME_SCHEMATIC_PREFIXED = 'a Schematic';
+
 export const NAME_ERROR_SCHEMATIC = 'SchematicError';
 
 export const NAME_ERROR_VALIDATION = 'ValidationError';
@@ -33,6 +35,8 @@ export const NAME_ERROR_VALIDATION = 'ValidationError';
 
 // #region Properties
 
+export const PROPERTY_DEFAULT = '$default';
+
 export const PROPERTY_REQUIRED = '$required';
 
 export const PROPERTY_SCHEMATIC = '$schematic';
@@ -45,7 +49,7 @@ export const PROPERTY_VALIDATORS = '$validators';
 
 // #region Property validation
 
-export const VALIDATION_MESSAGE_INVALID_INPUT = "Expected 'object' as input but received <>";
+export const VALIDATION_MESSAGE_INVALID_INPUT = 'Expected an object as input but received <>';
 
 export const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
 
@@ -81,10 +85,16 @@ export const REPORTING_TYPES = new Set<ReportingType>([
 
 // #region Schematic validation
 
+export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED =
+	"'<>' has a default value but is not required";
+
+export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE =
+	"Expected default value for property '<>' to be <>";
+
 export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
 
 export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED =
-	"'<>.<>' property is not allowed for schemas in $type";
+	"'<>.<>' property is not allowed for plain schemas";
 
 export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE =
 	"'<>' property must not be 'null' or 'undefined'";
@@ -116,6 +126,10 @@ export const TEMPLATE_PATTERN = '<>';
 
 export const TYPE_ARRAY = 'array';
 
+export const TYPE_FUNCTION = 'function';
+
+export const TYPE_FUNCTION_RESULT = 'a validated value';
+
 export const TYPE_NULL = 'null';
 
 export const TYPE_OBJECT = 'object';
@@ -123,17 +137,31 @@ export const TYPE_OBJECT = 'object';
 export const TYPE_UNDEFINED = 'undefined';
 
 export const VALIDATABLE_TYPES = new Set<ValueName>([
-	'array',
+	TYPE_ARRAY,
 	'bigint',
 	'boolean',
 	'date',
-	'function',
+	TYPE_FUNCTION,
 	'number',
+	TYPE_OBJECT,
 	'string',
 	'symbol',
-	TYPE_OBJECT,
 ]);
 
-export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, 'null', TYPE_UNDEFINED]);
+export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, TYPE_NULL, TYPE_UNDEFINED]);
+
+export const PREFIXED_TYPES: Record<ValueName, string> = {
+	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
+	bigint: `a bigint`,
+	boolean: `a boolean`,
+	date: `a date`,
+	[TYPE_FUNCTION]: `a ${TYPE_FUNCTION}`,
+	[TYPE_NULL]: TYPE_NULL,
+	number: `a number`,
+	string: `a string`,
+	symbol: `a symbol`,
+	[TYPE_OBJECT]: `an ${TYPE_OBJECT}`,
+	[TYPE_UNDEFINED]: TYPE_UNDEFINED,
+};
 
 // #endregion