@oscarpalmer/jhunal 0.26.0 → 0.27.0

package/dist/helpers/message.helper.mjs

@@ -1,4 +1,6 @@
-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 { CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, 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, TYPES_ALL, TYPES_PREFIXED, TYPE_ARRAY, TYPE_FUNCTION_RESULT, TYPE_NULL, TYPE_OBJECT, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE, VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX, VALIDATION_MESSAGE_INVALID_VALUE_TYPE, VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR, VALIDATION_MESSAGE_UNKNOWN_KEYS } from "../constants.mjs";
+import { isValidator } from "./misc.helper.mjs";
+import { validatorTypes } from "../validator.mjs";
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/helpers/message.helper.ts
 function getDefaultRequiredMessage(key) {
@@ -23,15 +25,25 @@ function getInputPropertyMissingMessage(key, types) {
 	return message;
 }
 function getInputPropertyTypeMessage(key, types, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
+	let message = VALIDATION_MESSAGE_INVALID_PROPERTY_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);
+	let message = VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR.replace("<>", key);
 	message = message.replace("<>", type);
-	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
+	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX.replace("<>", String(index));
+	return message;
+}
+function getInputValueTypeMessage(types, actual) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE_TYPE.replace("<>", renderTypes(types));
+	message = message.replace("<>", getValueType(actual));
+	return message;
+}
+function getInputValueValidatorMessage(type, index, length) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR.replace("<>", type);
+	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX.replace("<>", String(index));
 	return message;
 }
 function getSchematicPropertyNullableMessage(key) {
@@ -42,18 +54,19 @@ function getSchematicPropertyTypeMessage(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];
+		case typeof type === "function": return [isConstructor(type) ? type.name : TYPE_FUNCTION_RESULT];
+		case isValidator(type): return validatorTypes.get(type).flatMap(getPropertyType);
+		case TYPES_ALL.has(type): return [TYPES_PREFIXED[type]];
+		default: return [TYPES_PREFIXED[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];
+		case Array.isArray(value): return TYPES_PREFIXED[TYPE_ARRAY];
+		case isPlainObject(value): return TYPES_PREFIXED[TYPE_OBJECT];
+		case valueType !== TYPE_OBJECT: return TYPES_PREFIXED[valueType];
 		default: return value.constructor.name;
 	}
 }
@@ -74,11 +87,16 @@ function renderParts(parts, delimiterShort, delimiterLong) {
 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);
+	const typesLength = types.length;
+	for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+		const properties = getPropertyType(types[typeIndex]);
+		const propertiesLength = properties.length;
+		for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
+			const property = properties[propertyIndex];
+			if (unique.has(property)) continue;
+			unique.add(property);
+			parts.push(property);
+		}
 	}
 	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
 }
@@ -89,4 +107,4 @@ function getUnknownKeysMessage(keys) {
 	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
 }
 //#endregion
-export { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };
+export { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputPropertyValidatorMessage, getInputTypeMessage, getInputValueTypeMessage, getInputValueValidatorMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage };

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

@@ -1,9 +1,10 @@
-import { ReportingInformation, ValidatorParameters } from "../models/validation.model.mjs";
+import { ReportingInformation, ValidationHandlerParameters } from "../models/validation.model.mjs";
+import { Validator } from "../validator.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 getParameters(input?: unknown): ValidationHandlerParameters;
 declare function getReporting(value?: unknown): ReportingInformation;
 /**
  * Creates a validator function for a given constructor
@@ -13,10 +14,16 @@ declare function getReporting(value?: unknown): ReportingInformation;
  */
 declare function instanceOf<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
 /**
- * Is the value a schematic?
+ * Is the value a schema?
  * @param value Value to check
- * @returns `true` if the value is a schematic, `false` otherwise
+ * @returns `true` if the value is a schema, `false` otherwise
  */
-declare function isSchema(value: unknown): value is Schema<never>;
+declare function isSchema(value: unknown): value is Schema<unknown>;
+/**
+ * Is the value a validator?
+ * @param value Value to check
+ * @returns `true` if the value is a validator, `false` otherwise
+ */
+declare function isValidator(value: unknown): value is Validator<unknown>;
 //#endregion
-export { getParameters, getReporting, instanceOf, isSchema };
+export { getParameters, getReporting, instanceOf, isSchema, isValidator };

package/dist/helpers/misc.helper.mjs

@@ -27,7 +27,7 @@ function getReporting(value) {
 	return {
 		type,
 		["all"]: type === "all",
-		[REPORTING_FIRST]: type === REPORTING_FIRST,
+		[REPORTING_FIRST]: type === "first" || type === "result",
 		[REPORTING_NONE]: type === REPORTING_NONE,
 		[REPORTING_THROW]: type === REPORTING_THROW
 	};
@@ -45,12 +45,20 @@ function instanceOf(constructor) {
 	};
 }
 /**
-* Is the value a schematic?
+* Is the value a schema?
 * @param value Value to check
-* @returns `true` if the value is a schematic, `false` otherwise
+* @returns `true` if the value is a schema, `false` otherwise
 */
 function isSchema(value) {
 	return typeof value === "object" && value !== null && "$schema" in value && value["$schema"] === true;
 }
+/**
+* Is the value a validator?
+* @param value Value to check
+* @returns `true` if the value is a validator, `false` otherwise
+*/
+function isValidator(value) {
+	return typeof value === "object" && value !== null && "$validator" in value && value["$validator"] === true;
+}
 //#endregion
-export { getParameters, getReporting, instanceOf, isSchema };
+export { getParameters, getReporting, instanceOf, isSchema, isValidator };

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

@@ -0,0 +1,23 @@
+import { PropertyValidation, PropertyValidationKey, ValidationHandlerParameters } from "../models/validation.model.mjs";
+
+//#region src/helpers/report.helper.d.ts
+type ReportParameters<Callback extends (...args: any[]) => string> = {
+  extract?: boolean;
+  information?: ReportParametersInformation;
+  key?: PropertyValidationKey;
+  message: ReportParametersMessage<Callback>;
+  original: ValidationHandlerParameters;
+  value: unknown;
+};
+type ReportParametersMessage<Callback extends (...args: any[]) => string> = {
+  arguments: Parameters<Callback>;
+  callback: Callback;
+};
+type ReportParametersInformation = {
+  all: PropertyValidation[];
+  existing?: PropertyValidation[];
+};
+declare function report<Callback extends (...args: any[]) => string>(parameters: ReportParameters<Callback>, getReports: true): PropertyValidation[];
+declare function report<Callback extends (...args: any[]) => string>(parameters: ReportParameters<Callback>): PropertyValidation[] | undefined;
+//#endregion
+export { report };

package/dist/helpers/report.helper.mjs

@@ -0,0 +1,19 @@
+import { ValidationError } from "../models/validation.model.mjs";
+//#region src/helpers/report.helper.ts
+function report(parameters, getReports) {
+	const { information, message, original } = parameters;
+	let reported;
+	if (information?.existing == null) {
+		reported = [{
+			value: parameters.value,
+			message: message.callback(...message.arguments)
+		}];
+		if (parameters.key != null) reported[0].key = parameters.key;
+	} else reported = information.existing;
+	if (original.reporting.throw) throw new ValidationError(reported);
+	information?.all.push(...reported);
+	if (parameters.extract ?? true) original.information?.push(...reported);
+	if ((getReports ?? false) || !original.reporting.all) return reported;
+}
+//#endregion
+export { report };

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

@@ -0,0 +1,7 @@
+import { ValidationHandler } from "../models/validation.model.mjs";
+
+//#region src/helpers/result.helper.d.ts
+declare function getResult(handler: ValidationHandler, value: unknown, options?: unknown): unknown;
+declare function isResult(handler: ValidationHandler, value: unknown, options?: unknown): unknown;
+//#endregion
+export { getResult, isResult };

package/dist/helpers/result.helper.mjs

@@ -0,0 +1,17 @@
+import { getParameters } from "./misc.helper.mjs";
+import { error, ok } from "@oscarpalmer/atoms/result/misc";
+//#region src/helpers/result.helper.ts
+function getResult(handler, value, options) {
+	const parameters = getParameters(options);
+	const result = handler(value, parameters, true);
+	if (result === true) return parameters.reporting.none || parameters.reporting.throw ? parameters.clone ? parameters.output : value : ok(parameters.clone ? parameters.output : value);
+	if (!parameters.reporting.none) return error(parameters.reporting.all ? result : result[0]);
+}
+function isResult(handler, value, options) {
+	const parameters = getParameters(options);
+	const result = handler(value, parameters, false);
+	if (result === true) return parameters.reporting.none || parameters.reporting.throw ? result : ok(result);
+	return parameters.reporting.none ? false : error(parameters.reporting.all ? result : result[0]);
+}
+//#endregion
+export { getResult, isResult };