@oscarpalmer/jhunal 0.22.0 → 0.23.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,14 @@ 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_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 '<>'";
@@ -37,10 +38,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_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 };

package/dist/constants.mjs

@@ -6,13 +6,14 @@ 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_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 '<>'";
@@ -39,24 +40,45 @@ 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([
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"function",
-	"number",
-	"string",
-	"symbol",
-	TYPE_OBJECT
+	TYPE_ARRAY,
+	TYPE_BIGINT,
+	TYPE_BOOLEAN,
+	TYPE_DATE,
+	TYPE_FUNCTION,
+	TYPE_NUMBER,
+	TYPE_OBJECT,
+	TYPE_STRING,
+	TYPE_SYMBOL
 ]);
 const TYPE_ALL = new Set([
 	...VALIDATABLE_TYPES,
-	"null",
+	TYPE_NULL,
 	TYPE_UNDEFINED
 ]);
+const PREFIXED_TYPES = {
+	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
+	[TYPE_BIGINT]: `a ${TYPE_BIGINT}`,
+	[TYPE_BOOLEAN]: `a ${TYPE_BOOLEAN}`,
+	[TYPE_DATE]: `a ${TYPE_DATE}`,
+	[TYPE_FUNCTION]: `a ${TYPE_FUNCTION}`,
+	[TYPE_NULL]: TYPE_NULL,
+	[TYPE_NUMBER]: `a ${TYPE_NUMBER}`,
+	[TYPE_STRING]: `a ${TYPE_STRING}`,
+	[TYPE_SYMBOL]: `a ${TYPE_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_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 };

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

@@ -0,0 +1,11 @@
+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 getUnknownKeysMessage(keys: string[]): string;
+//#endregion
+export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage };

package/dist/helpers/message.helper.mjs

@@ -0,0 +1,70 @@
+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 { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/helpers/message.helper.ts
+function getInvalidInputMessage(actual) {
+	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
+}
+function getInvalidMissingMessage(key, types) {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
+	return message;
+}
+function getInvalidTypeMessage(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) {
+	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 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 getUnknownKeysMessage(keys) {
+	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
+}
+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);
+}
+//#endregion
+export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, 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(REPORTING_NONE),
+		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 };