@oscarpalmer/jhunal 0.22.0 → 0.24.0

package/dist/constants.d.mts

@@ -1,5 +1,5 @@
 import { ReportingType } from "./models/validation.model.mjs";
-import { Values } from "./models/misc.model.mjs";
+import { ValueName, Values } from "./models/misc.model.mjs";
 
 //#region src/constants.d.ts
 declare const COMMA = ", ";
@@ -9,13 +9,15 @@ 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_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_TYPE = "$type";
 declare const PROPERTY_VALIDATORS = "$validators";
-declare const VALIDATION_MESSAGE_INVALID_INPUT = "Expected 'object' as input but received <>";
+declare const VALIDATION_MESSAGE_INVALID_INPUT = "Expected an object as input but received <>";
 declare const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
 declare const VALIDATION_MESSAGE_INVALID_TYPE = "Expected <> for '<>' but received <>";
 declare const VALIDATION_MESSAGE_INVALID_VALUE = "Value does not satisfy validator for '<>' and type '<>'";
@@ -26,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";
@@ -37,10 +41,13 @@ declare const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an
 declare const SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 declare const TEMPLATE_PATTERN = "<>";
 declare const TYPE_ARRAY = "array";
+declare const TYPE_FUNCTION = "function";
+declare const TYPE_FUNCTION_RESULT = "a validated value";
 declare const TYPE_NULL = "null";
 declare const TYPE_OBJECT = "object";
 declare const TYPE_UNDEFINED = "undefined";
 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, 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_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_SCHEMATIC, NAME_SCHEMATIC_PREFIXED, PREFIXED_TYPES, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMATIC, 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

@@ -6,13 +6,15 @@ 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_ERROR_SCHEMATIC = "SchematicError";
 const NAME_ERROR_VALIDATION = "ValidationError";
+const PROPERTY_DEFAULT = "$default";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_SCHEMATIC = "$schematic";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
-const VALIDATION_MESSAGE_INVALID_INPUT = "Expected 'object' as input but received <>";
+const VALIDATION_MESSAGE_INVALID_INPUT = "Expected an object as input but received <>";
 const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
 const VALIDATION_MESSAGE_INVALID_TYPE = "Expected <> for '<>' but received <>";
 const VALIDATION_MESSAGE_INVALID_VALUE = "Value does not satisfy validator for '<>' and type '<>'";
@@ -28,8 +30,10 @@ const REPORTING_TYPES = new Set([
 	REPORTING_NONE,
 	REPORTING_THROW
 ]);
+const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED = "'<>' has a default value but is not required";
+const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE = "Expected default value for property '<>' to be <>";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<>.<>' property is not allowed for schemas in $type";
+const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<>.<>' property is not allowed for plain schemas";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE = "'<>' property must not be 'null' or 'undefined'";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
@@ -39,24 +43,39 @@ 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_FUNCTION = "function";
+const TYPE_FUNCTION_RESULT = "a validated value";
 const TYPE_NULL = "null";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
 const VALIDATABLE_TYPES = new Set([
-	"array",
+	TYPE_ARRAY,
 	"bigint",
 	"boolean",
 	"date",
-	"function",
+	TYPE_FUNCTION,
 	"number",
+	TYPE_OBJECT,
 	"string",
-	"symbol",
-	TYPE_OBJECT
+	"symbol"
 ]);
 const TYPE_ALL = new Set([
 	...VALIDATABLE_TYPES,
-	"null",
+	TYPE_NULL,
 	TYPE_UNDEFINED
 ]);
+const PREFIXED_TYPES = {
+	[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
-export { COMMA, CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION, NAME_SCHEMATIC, 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_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_SCHEMATIC, NAME_SCHEMATIC_PREFIXED, PREFIXED_TYPES, PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_SCHEMATIC, 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

@@ -0,0 +1,17 @@
+import { ValidatorType } from "../models/validation.model.mjs";
+import { ValueName } from "../models/misc.model.mjs";
+
+//#region src/helpers/message.helper.d.ts
+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 { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };

package/dist/helpers/message.helper.mjs

@@ -0,0 +1,92 @@
+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 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 getInputPropertyMissingMessage(key, types) {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
+	return message;
+}
+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 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;
+		case TYPE_ALL.has(type): return PREFIXED_TYPES[type];
+		default: return PREFIXED_TYPES[TYPE_OBJECT];
+	}
+}
+function getValueType(value) {
+	const valueType = typeof value;
+	switch (true) {
+		case value === null: return TYPE_NULL;
+		case Array.isArray(value): return PREFIXED_TYPES[TYPE_ARRAY];
+		case isPlainObject(value): return PREFIXED_TYPES[TYPE_OBJECT];
+		case valueType !== TYPE_OBJECT: return PREFIXED_TYPES[valueType];
+		default: return value.constructor.name;
+	}
+}
+function renderKeys(keys) {
+	return renderParts(keys.map((key) => `'${key}'`), CONJUNCTION_AND, CONJUNCTION_AND_COMMA);
+}
+function renderParts(parts, delimiterShort, delimiterLong) {
+	const { length } = parts;
+	if (length === 1) return parts[0];
+	let rendered = "";
+	for (let index = 0; index < length; index += 1) {
+		rendered += parts[index];
+		if (index < length - 2) rendered += ", ";
+		else if (index === length - 2) rendered += parts.length > 2 ? delimiterLong : delimiterShort;
+	}
+	return rendered;
+}
+function renderTypes(types) {
+	const unique = /* @__PURE__ */ new Set();
+	const parts = [];
+	for (let index = 0; index < types.length; index += 1) {
+		const rendered = getPropertyType(types[index]);
+		if (unique.has(rendered)) continue;
+		unique.add(rendered);
+		parts.push(rendered);
+	}
+	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 { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };

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

@@ -0,0 +1,22 @@
+import { ReportingInformation, ValidatorParameters } from "../models/validation.model.mjs";
+import { Schematic } from "../schematic.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;
+/**
+ * Creates a validator function for a given constructor
+ * @param constructor - Constructor to check against
+ * @throws Will throw a `TypeError` if the provided argument is not a valid constructor
+ * @returns Validator function that checks if a value is an instance of the constructor
+ */
+declare function instanceOf<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
+/**
+ * Is the value a schematic?
+ * @param value Value to check
+ * @returns `true` if the value is a schematic, `false` otherwise
+ */
+declare function isSchematic(value: unknown): value is Schematic<never>;
+//#endregion
+export { getParameters, getReporting, instanceOf, isSchematic };

package/dist/helpers/misc.helper.mjs

@@ -0,0 +1,56 @@
+import { MESSAGE_CONSTRUCTOR, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES } from "../constants.mjs";
+import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/helpers/misc.helper.ts
+function getParameters(input) {
+	if (typeof input === "boolean") return {
+		clone: true,
+		output: {},
+		reporting: getReporting(),
+		strict: input
+	};
+	if (REPORTING_TYPES.has(input)) return {
+		clone: true,
+		output: {},
+		reporting: getReporting(input),
+		strict: false
+	};
+	const options = isPlainObject(input) ? input : {};
+	return {
+		clone: typeof options.clone === "boolean" ? options.clone : true,
+		output: {},
+		reporting: getReporting(options.errors),
+		strict: typeof options.strict === "boolean" ? options.strict : false
+	};
+}
+function getReporting(value) {
+	const type = REPORTING_TYPES.has(value) ? value : REPORTING_NONE;
+	return {
+		type,
+		["all"]: type === "all",
+		[REPORTING_FIRST]: type === REPORTING_FIRST,
+		[REPORTING_NONE]: type === REPORTING_NONE,
+		[REPORTING_THROW]: type === REPORTING_THROW
+	};
+}
+/**
+* Creates a validator function for a given constructor
+* @param constructor - Constructor to check against
+* @throws Will throw a `TypeError` if the provided argument is not a valid constructor
+* @returns Validator function that checks if a value is an instance of the constructor
+*/
+function instanceOf(constructor) {
+	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
+	return (value) => {
+		return value instanceof constructor;
+	};
+}
+/**
+* Is the value a schematic?
+* @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;
+}
+//#endregion
+export { getParameters, getReporting, instanceOf, isSchematic };