fenextjs-validator - npm Package Compare versions

Comparing version 1.0.5 to 1.0.6

cjs/index.d.ts

		@@ -26,2 +26,8 @@ /**
		/**
		* Método para establecer el nombre asociado a la instancia de FenextjsValidatorClass.
		* @param {string} name - El nombre a establecer para la instancia actual de FenextjsValidatorClass.
		* @returns {FenextjsValidatorClass} - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.
		*/
		setName(name: string): this;
		/**
		* Método para definir la validación "isEqual".
		@@ -111,2 +117,10 @@ * Establece la regla de que los datos deben ser iguales al valor especificado.
		/**
		* Método para habilitar la comparación de valores de referencia.
		* Establece la regla de que los datos deben ser iguales a otro valor de referencia almacenado en la instancia.
		*
		* @param {string} refKey - La clave que identifica el valor de referencia almacenado en la instancia para la comparación.
		* @returns {FenextjsValidatorClass} - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.
		*/
		isCompareRef(refKey: string): this;
		/**
		* Método para validar los datos proporcionados según las reglas establecidas.
		@@ -128,2 +142,2 @@ * Ejecuta todas las reglas de validación habilitadas previamente para los datos.
		*/
		export declare const FenextjsValidator: (props?: FenextjsValidatorClassConstructorProps) => FenextjsValidatorClass<any>;
		export declare const FenextjsValidator: <T = any>(props?: FenextjsValidatorClassConstructorProps) => FenextjsValidatorClass<T>;

cjs/index.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.FenextjsValidator = exports.FenextjsValidatorClass = void 0;
		const fenextjs_error_1 = require("fenextjs-error");
		const Input_1 = require("fenextjs-error/cjs/Input");
		const Fenextjs_1 = require("fenextjs-error/cjs/Fenextjs");
		const fenextjs_interface_1 = require("fenextjs-interface");
		@@ -35,2 +36,8 @@ /**
		#lengthValue = undefined;
		/** Bandera que indica si los datos deben ser una cadena en la validación "isCompareRef". */
		#compareRef = false;
		/** Valor que contiene key para cada propiedad del objeto en la validación "isCompareRef". */
		#compareRefKey = undefined;
		/** Valor que contiene las reglas de validación para cada propiedad del objeto en la validación "isCompareRef". */
		#compareRefValue = undefined;
		/** Bandera que indica si los datos deben ser una fecha en la validación "isDate". */
		@@ -77,3 +84,3 @@ #date = false;
		*/
		#setName(name) {
		setName(name) {
		/**
		@@ -140,3 +147,3 @@ * Nombre asociado a la instancia de FenextjsValidatorClass.
		if (this.#equalValue !== this.#data) {
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_INVALID);
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_NOT_EQUAL);
		}
		@@ -170,3 +177,3 @@ return this;
		this.#data === "") {
		throw new fenextjs_error_1.ErrorInputRequired();
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_REQUIRED);
		}
		@@ -342,4 +349,7 @@ }
		if (!validator.#name) {
		validator.#setName(key);
		validator.setName(key);
		}
		if (validator.#compareRef) {
		validator.#setCompareRef(this.#data?.[validator.#compareRefKey]);
		}
		validator.#setParent(this);
		@@ -386,2 +396,3 @@ const r = validator.onValidate(this.#data?.[key]);
		const item = this.#data[i];
		validator.setName(`${i}`);
		const r = validator.onValidate(item);
		@@ -448,3 +459,3 @@ // Si algún elemento no cumple con las reglas de validación, se lanza el error devuelto por la validación.
		!(minValidate && nMinValue && minValidate > nMinValue)) {
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_INVALID);
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_VALUE_TOO_LOW);
		}
		@@ -455,3 +466,3 @@ // Verifica si se habilitó la regla "isMinOrEqual" y si los datos no superan o igualan el valor mínimo (#minValue).
		!(minValidate && nMinValue && minValidate >= nMinValue)) {
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_INVALID);
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_VALUE_TOO_LOW);
		}
		@@ -512,3 +523,3 @@ }
		!(maxValidate && nMaxValue && maxValidate < nMaxValue)) {
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_INVALID);
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_VALUE_TOO_HIGH);
		}
		@@ -519,23 +530,65 @@ // Verifica si se habilitó la regla "isMaxOrEqual" y si los datos no son menores o iguales al valor máximo (#maxValue).
		!(maxValidate && nMaxValue && maxValidate <= nMaxValue)) {
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_INVALID);
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_VALUE_TOO_HIGH);
		}
		}
		/**
		* Método para habilitar la comparación de valores de referencia.
		* Establece la regla de que los datos deben ser iguales a otro valor de referencia almacenado en la instancia.
		*
		* @param {string} refKey - La clave que identifica el valor de referencia almacenado en la instancia para la comparación.
		* @returns {FenextjsValidatorClass} - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.
		*/
		isCompareRef(refKey) {
		this.#compareRef = true;
		this.#compareRefKey = refKey;
		return this;
		}
		/**
		* Método privado para establecer el valor de referencia para la comparación.
		* Se utiliza junto con "isCompareRef()" para definir el valor de referencia que se utilizará en la comparación de datos.
		*
		* @param {any} refValue - El valor de referencia que se utilizará en la comparación de datos.
		* @returns {FenextjsValidatorClass} - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.
		*/
		#setCompareRef(refValue) {
		this.#compareRefValue = refValue;
		return this;
		}
		/**
		* Método privado para realizar la comparación de valores de referencia.
		* Si se habilitó la comparación de valores de referencia con "isCompareRef()",
		* verifica que los datos sean iguales al valor de referencia establecido con "#setCompareRef()".
		* Si no se cumple, lanza una excepción "ErrorInputInvalid" con el código "ErrorCode.INPUT_INVALID".
		*
		* @returns {void}
		* @throws {ErrorInputInvalid} - Si los datos no son iguales al valor de referencia.
		*/
		#onCompareRef() {
		if (!this.#compareRef \|\| !this.#compareRefValue) {
		return;
		}
		if (this.#compareRefValue !== this.#data) {
		// Lanza una excepción "ErrorInputInvalid" con el código "ErrorCode.INPUT_INVALID".
		this.#onError(fenextjs_interface_1.ErrorCode.INPUT_NOT_EQUAL);
		}
		}
		/**
		* Método privado para manejar errores en la validación.
		* Si se proporciona el código de error "ErrorCode.INPUT_REQUIRED",
		* lanza una excepción "ErrorInputRequired" que indica que se requiere la entrada.
		* De lo contrario, lanza una excepción "ErrorInputInvalid" que indica que la entrada es inválida.
		*
		* @param {ErrorCode} code - Opcional. El código de error que indica el tipo de error ocurrido.
		* @returns {void}
		* @throws {ErrorInputRequired} - Si se proporciona el código "ErrorCode.INPUT_REQUIRED".
		* @throws {ErrorInputInvalid} - Si se proporciona un código diferente de "ErrorCode.INPUT_REQUIRED".
		* @throws {ErrorFenextjs} - Una excepción específica basada en el código de error proporcionado o una excepción general "ErrorFenextjs".
		*/
		#onError(code) {
		if (code == fenextjs_interface_1.ErrorCode.INPUT_REQUIRED) {
		// Lanza una excepción "ErrorInputRequired" si se requiere la entrada.
		throw new fenextjs_error_1.ErrorInputRequired({ input: this.#getName() });
		}
		// Lanza una excepción "ErrorInputInvalid" para cualquier otro código de error.
		throw new fenextjs_error_1.ErrorInputInvalid({ input: this.#getName() });
		// Crear un objeto que mapea los códigos de error a las clases de error correspondientes.
		const props = { input: this.#getName() };
		const sw = {
		INPUT_REQUIRED: new Input_1.ErrorInputRequired(props),
		INPUT_NOT_EQUAL: new Input_1.ErrorInputNotEqual(props),
		INPUT_INVALID: new Input_1.ErrorInputInvalid(props),
		INPUT_VALUE_TOO_HIGH: new Input_1.ErrorInputValueTooHigh(props),
		INPUT_VALUE_TOO_LOW: new Input_1.ErrorInputValueTooLow(props),
		};
		// Lanza una excepción específica basada en el código de error proporcionado o una excepción general "ErrorFenextjs".
		throw sw?.[code ?? fenextjs_interface_1.ErrorCode.ERROR] ?? new Fenextjs_1.ErrorFenextjs(props);
		}
		@@ -564,2 +617,3 @@ /**
		this.#onMax();
		this.#onCompareRef();
		// Si todas las reglas de validación se cumplen, retorna true para indicar que los datos son válidos.
		@@ -566,0 +620,0 @@ return true;

221

cjs/test.js

		@@ -5,55 +5,178 @@ "use strict";
		const _1 = require(".");
		// Crear un validador y establecer la regla "isRequired"
		const r = (0, _1.FenextjsValidator)().isRequired().onValidate("a");
		console.log(r); // Imprimir el resultado de la validación (true si es válido, ErrorInputRequired si no lo es)
		// Crear otro validador y establecer la regla "isBoolean"
		const r2 = (0, _1.FenextjsValidator)().isBoolean().onValidate(false);
		console.log(r2);
		// Crear otro validador y establecer la regla "isEqual" con el valor "aaaa"
		const r3 = (0, _1.FenextjsValidator)().isEqual("aaaa").onValidate("aaaa");
		console.log(r3);
		// Crear otro validador y establecer la regla "isNumber"
		const r4 = (0, _1.FenextjsValidator)().isNumber().onValidate(2);
		console.log(r4);
		// Crear otro validador y establecer la regla "isString"
		const r5 = (0, _1.FenextjsValidator)().isString().onValidate("");
		console.log(r5);
		// Crear otro validador y establecer la regla "isObject" con una regla de validación para la propiedad "a"
		const r6 = (0, _1.FenextjsValidator)({ name: "Obj__" })
		// Ejemplo: Crear un validador y establecer la regla "isRequired"
		const ValidateIsRequired = (0, _1.FenextjsValidator)()
		.setName("ValidateIsRequired") // Establecer un nombre para esta instancia de validador (opcional)
		.isRequired() // Establecer la regla "isRequired", que verifica si el valor es requerido (no puede estar vacío o ser nulo).
		.onValidate(""); // Realizar la validación con el valor "" (cadena vacía)
		console.log(ValidateIsRequired);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputRequired.
		// El mensaje de este objeto puede ser algo como "Input Required [ValidateIsRequired]".
		// Esto indica que el valor proporcionado para la validación está vacío, lo que no cumple con la regla de "isRequired".
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido diferente de una cadena vacía,
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer la regla "isBoolean"
		const ValidateIsBoolean = (0, _1.FenextjsValidator)()
		.setName("ValidateIsBoolean") // Establecer un nombre para esta instancia de validador (opcional)
		.isBoolean() // Establecer la regla "isBoolean", que verifica si el valor es un booleano.
		.onValidate("false"); // Realizar la validación con el valor "false" (cadena)
		console.log(ValidateIsBoolean);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [ValidateIsBoolean]".
		// Esto indica que el valor proporcionado para la validación ("false" en este caso) no es un booleano válido.
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido "true" (valor booleano válido),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer la regla "isEqual"
		const ValidateIsEqual = (0, _1.FenextjsValidator)()
		.setName("ValidateIsEqual") // Establecer un nombre para esta instancia de validador (opcional)
		.isEqual("aaaa") // Establecer la regla "isEqual", que verifica si el valor es igual al valor "aaaa".
		.onValidate("bbbb"); // Realizar la validación con el valor "bbbb" (cadena)
		console.log(ValidateIsEqual);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputNotEqual.
		// El mensaje de este objeto puede ser algo como "Not Equal Input [ValidateIsEqual]".
		// Esto indica que el valor proporcionado para la validación ("bbbb" en este caso) no es igual al valor esperado "aaaa".
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido "aaaa" (valor igual al valor esperado),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer la regla "isNumber"
		const ValidateIsNumber = (0, _1.FenextjsValidator)()
		.setName("ValidateIsNumber") // Establecer un nombre para esta instancia de validador (opcional)
		.isNumber() // Establecer la regla "isNumber", que verifica si el valor es un número.
		.onValidate("not Number"); // Realizar la validación con el valor "not Number" (cadena)
		console.log(ValidateIsNumber);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [FenextjsValidator]".
		// Esto indica que el valor proporcionado para la validación ("not Number" en este caso) no es un número válido.
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido un número, la validación habría sido exitosa,
		// y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer la regla "isString"
		const ValidateIsString = (0, _1.FenextjsValidator)()
		.setName("ValidateIsString") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.onValidate({}); // Realizar la validación con el valor {} (objeto)
		console.log(ValidateIsString);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [FenextjsValidator]".
		// Esto indica que el valor proporcionado para la validación ({}, un objeto) no es una cadena de texto válida.
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena de texto, la validación habría sido exitosa,
		// y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer la regla "isObject" con una regla de validación para la propiedad "key1"
		const ValidateIsObject = (0, _1.FenextjsValidator)()
		.setName("ValidateIsString") // Establecer un nombre para esta instancia de validador (opcional)
		.isObject({
		a: (0, _1.FenextjsValidator)({ name: "test__" }).isString().isEqual("aa"),
		key1: (0, _1.FenextjsValidator)() // Establecer la regla "isString" y "isEqual" para la propiedad "key1"
		.setName("ValidateIsString.key1") // Establecer un nombre para esta subinstancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isEqual("aa"), // Establecer la regla "isEqual", que verifica si el valor es igual a "aa".
		})
		.onValidate({
		a: "aaa",
		key1: "not Equal", // Realizar la validación con el objeto { key1: "not Equal" }
		// Nota: Si el valor de la propiedad "key1" hubiera sido "aa" (una cadena de texto igual a "aa"),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		});
		console.log(r6);
		// Crear otro validador y establecer la regla "isArray" con una regla de validación para los elementos del array
		const r7 = (0, _1.FenextjsValidator)()
		.isArray((0, _1.FenextjsValidator)().isString().isEqual("aa"))
		.onValidate(["aa", "aa"]);
		console.log(r7);
		// Crear otro validador y establecer la regla "isString" y "isMin" (longitud mínima 3 caracteres)
		const r8 = (0, _1.FenextjsValidator)().isString().isMin(3).onValidate("aaaaa");
		console.log(r8);
		// Crear otro validador y establecer la regla "isString" y "isMinOrEqual" (longitud mínima 3 caracteres o igual)
		const r9 = (0, _1.FenextjsValidator)().isString().isMinOrEqual(3).onValidate("aaa");
		console.log(r9);
		// Crear otro validador y establecer la regla "isNumber" y "isMax" (valor máximo 3)
		const r10 = (0, _1.FenextjsValidator)().isNumber().isMax(3).onValidate(2);
		console.log(r10);
		// Crear otro validador y establecer la regla "isString" y "isMaxOrEqual" (longitud máxima 3 caracteres o igual)
		const r11 = (0, _1.FenextjsValidator)().isString().isMaxOrEqual(3).onValidate("aaa");
		console.log(r11);
		// Crear otro validador y establecer la regla "isDate" y "isMax" (fecha máxima: 100)
		const r12 = (0, _1.FenextjsValidator)({ name: "date" })
		.isDate()
		.isMax(new Date(100))
		.onValidate(new Date(10));
		console.log(r12);
		// Ejemplo 13: Crear otro validador y establecer la regla "isLength" con longitud de 4 caracteres
		const r13 = (0, _1.FenextjsValidator)({ name: "InputLength" })
		.isLength(4)
		.onValidate("tesing");
		console.log(r13);
		//INPUT_INVALID: Invalid Input [InputLength]
		console.log(ValidateIsObject);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputNotEqual.
		// El mensaje de este objeto puede ser algo como "Not Equal Input [ValidateIsString.key1]".
		// Esto indica que el valor proporcionado para la validación de la propiedad "key1" ("not Equal" en este caso)
		// no es igual al valor esperado "aa" definido en la regla "isEqual".
		// Además, el mensaje también incluye el nombre del validador asociado ("ValidateIsString.key1")
		// para indicar que la propiedad "key1" del objeto no cumple con la regla de validación "isString" e "isEqual".
		// Ejemplo: Crear un validador y establecer la regla "isArray" con una regla de validación para los elementos del array
		const ValidateIsArray = (0, _1.FenextjsValidator)()
		.setName("ValidateIsArray") // Establecer un nombre para esta instancia de validador (opcional)
		.isArray(
		// Establecer la regla "isArray", que verifica si el valor es un array.
		(0, _1.FenextjsValidator)().isString().isEqual("aa"))
		.onValidate(["aa", "not equal"]); // Realizar la validación con el array ["aa", "not equal"]
		console.log(ValidateIsArray);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputNotEqual.
		// El mensaje de este objeto puede ser algo como "Not Equal Input [ValidateIsArray.1]".
		// Esto indica que el valor proporcionado para la validación del segundo elemento del array ("not equal" en este caso)
		// no es igual al valor esperado "aa" definido en la regla "isEqual".
		// Además, el mensaje también incluye el nombre del validador asociado ("ValidateIsArray.1")
		// para indicar que el segundo elemento del array no cumple con la regla de validación "isString" e "isEqual".
		// Ejemplo: Crear un validador y establecer las reglas "isString" y "isMin" (longitud mínima 3 caracteres)
		const ValidateIsMin = (0, _1.FenextjsValidator)()
		.setName("ValidateIsMin") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isMin(3) // Establecer la regla "isMin", que verifica si la longitud de la cadena es mayor o igual a 3 caracteres.
		.onValidate("NO"); // Realizar la validación con la cadena "NO"
		console.log(ValidateIsMin);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [ValidateIsMin]".
		// Esto indica que el valor proporcionado para la validación ("NO" en este caso) no cumple con la regla de longitud mínima.
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena con al menos 3 caracteres (por ejemplo, "YES"),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer las reglas "isString" y "isMinOrEqual" (longitud mínima 3 caracteres o igual)
		const ValidateIsMinOrEqual = (0, _1.FenextjsValidator)()
		.setName("ValidateIsMinOrEqual") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isMinOrEqual(3) // Establecer la regla "isMinOrEqual", que verifica si la longitud de la cadena es mayor o igual a 3 caracteres.
		.onValidate("aaa"); // Realizar la validación con la cadena "aaa"
		console.log(ValidateIsMinOrEqual);
		// En este caso, el resultado de la validación será "true".
		// Esto indica que el valor proporcionado para la validación ("aaa" en este caso) cumple con la regla de longitud mínima (3 caracteres).
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena con menos de 3 caracteres (por ejemplo, "aa"),
		// la validación habría sido exitosa, y el resultado también habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer las reglas "isNumber" e "isMax" (valor máximo 3)
		const ValidateIsMax = (0, _1.FenextjsValidator)()
		.setName("ValidateIsMax") // Establecer un nombre para esta instancia de validador (opcional)
		.isNumber() // Establecer la regla "isNumber", que verifica si el valor es un número.
		.isMax(3) // Establecer la regla "isMax", que verifica si el valor numérico es menor o igual a 3.
		.onValidate(20); // Realizar la validación con el valor numérico 20
		console.log(ValidateIsMax);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputValueTooHigh.
		// El mensaje de este objeto puede ser algo como "Value Too High [ValidateIsMax]".
		// Esto indica que el valor proporcionado para la validación (20 en este caso) es mayor que el valor máximo permitido (3).
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido un número menor o igual a 3 (por ejemplo, 2),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer las reglas "isString" e "isMaxOrEqual" (longitud máxima 3 caracteres o igual)
		const ValidateIsMaxOrEqual = (0, _1.FenextjsValidator)()
		.setName("ValidateIsMaxOrEqual") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isMaxOrEqual(3) // Establecer la regla "isMaxOrEqual", que verifica si la longitud de la cadena es menor o igual a 3 caracteres.
		.onValidate("aaa"); // Realizar la validación con la cadena "aaa"
		console.log(ValidateIsMaxOrEqual);
		// En este caso, el resultado de la validación será "true".
		// Esto indica que el valor proporcionado para la validación ("aaa" en este caso) cumple con la regla de longitud máxima o es igual a 3 caracteres.
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena con más de 3 caracteres (por ejemplo, "aaaa"),
		// la validación habría sido exitosa, y el resultado también habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer las reglas "isDate" e "isMax" (fecha máxima: 100)
		const ValidateIsDate = (0, _1.FenextjsValidator)()
		.setName("ValidateIsDate") // Establecer un nombre para esta instancia de validador (opcional)
		.isDate() // Establecer la regla "isDate", que verifica si el valor es una fecha válida.
		.isMax(new Date(100)) // Establecer la regla "isMax", que verifica si la fecha es anterior o igual a la fecha máxima (100).
		.onValidate(new Date(10)); // Realizar la validación con la fecha new Date(10)
		console.log(ValidateIsDate);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputValueTooHigh.
		// El mensaje de este objeto puede ser algo como "Value Too High [ValidateIsDate]".
		// Esto indica que la fecha proporcionada para la validación (new Date(10) en este caso) es posterior a la fecha máxima permitida (new Date(100)).
		// Nota: Si la fecha proporcionada en "onValidate()" hubiera sido una fecha anterior o igual a new Date(100),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		// Ejemplo: Crear un validador y establecer la regla "isLength" (longitud debe ser 4 caracteres)
		const ValidateIsLength = (0, _1.FenextjsValidator)()
		.setName("ValidateIsLength") // Establecer un nombre para esta instancia de validador (opcional)
		.isLength(4) // Establecer la regla "isLength", que verifica si la longitud de la cadena es igual a 4 caracteres.
		.onValidate("tesing"); // Realizar la validación con la cadena "tesing"
		console.log(ValidateIsLength);
		// Ejemplo: Crear un validador y establecer la regla "isObject" con dos reglas de validación para las propiedades "keyA" y "keyB"
		const ValidateIsCompareRef = (0, _1.FenextjsValidator)()
		.setName("ValidateIsCompareRef") // Establecer un nombre para esta instancia de validador (opcional)
		.isObject({
		keyA: (0, _1.FenextjsValidator)()
		.setName("ValidateIsCompareRef.keyA") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isCompareRef("keyB"),
		keyB: (0, _1.FenextjsValidator)()
		.setName("ValidateIsCompareRef.keyB") // Establecer un nombre para esta instancia de validador (opcional)
		.isString(), // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		})
		.onValidate({
		keyA: "aaa",
		keyB: "bbb",
		}); // Realizar la validación con el objeto { keyA: "aaa", keyB: "bbb" }
		console.log(ValidateIsCompareRef);
		// En este caso, el resultado de la validación será "true".
		// Esto indica que el objeto proporcionado para la validación cumple con todas las reglas definidas en la estructura de datos ValidateIsCompareRefInteface.
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido un objeto con valores diferentes para "keyA" y "keyB",
		// la validación habría sido fallida, y el resultado habría sido un objeto de tipo ErrorInputNotEqual,
		// que indica que los valores de "keyA" y "keyB" no son iguales.
		//# sourceMappingURL=test.js.map

package.json

		{
		"name": "fenextjs-validator",
		"version": "1.0.5",
		"version": "1.0.6",
		"description": "",
		@@ -40,4 +40,4 @@ "main": "./cjs/index.js",
		"dependencies": {
		"fenextjs-error": "^1.0.6",
		"fenextjs-interface": "^1.0.24"
		"fenextjs-error": "^1.0.8",
		"fenextjs-interface": "^1.0.25"
		},
		@@ -44,0 +44,0 @@ "files": [

488

README.md

		@@ -1,2 +0,2 @@
		# fenextjs-validator
		# Fenextjs-validator

		@@ -22,27 +22,30 @@ ## Classes
		## FenextjsValidatorClass

		Clase que proporciona validación de datos en TypeScript/JavaScript.

		Kind: global class
		Kind: global class

		* [FenextjsValidatorClass](#FenextjsValidatorClass)
		* [new FenextjsValidatorClass(props)](#new_FenextjsValidatorClass_new)
		* _instance_
		* [.isEqual(d)](#FenextjsValidatorClass+isEqual) ⇒
		* [.isRequired()](#FenextjsValidatorClass+isRequired) ⇒
		* [.isBoolean()](#FenextjsValidatorClass+isBoolean) ⇒
		* [.isNumber()](#FenextjsValidatorClass+isNumber) ⇒
		* [.isString()](#FenextjsValidatorClass+isString) ⇒
		* [.isLength(length)](#FenextjsValidatorClass+isLength) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		* [.isDate()](#FenextjsValidatorClass+isDate) ⇒
		* [.isObject(obj)](#FenextjsValidatorClass+isObject) ⇒
		* [.isArray(item)](#FenextjsValidatorClass+isArray) ⇒
		* [.isMin(min)](#FenextjsValidatorClass+isMin) ⇒
		* [.isMinOrEqual(min)](#FenextjsValidatorClass+isMinOrEqual) ⇒
		* [.isMax(max)](#FenextjsValidatorClass+isMax) ⇒
		* [.isMaxOrEqual(max)](#FenextjsValidatorClass+isMaxOrEqual) ⇒
		* [.onValidate(d)](#FenextjsValidatorClass+onValidate) ⇒
		* _static_
		* [.FenextjsValidatorClass](#FenextjsValidatorClass.FenextjsValidatorClass) : <code>string</code> \\| <code>undefined</code>
		* [.FenextjsValidatorClass](#FenextjsValidatorClass.FenextjsValidatorClass) : <code>string</code>
		* [.FenextjsValidatorClass](#FenextjsValidatorClass.FenextjsValidatorClass) : [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		- [FenextjsValidatorClass](#FenextjsValidatorClass)
		- [new FenextjsValidatorClass(props)](#new_FenextjsValidatorClass_new)
		- _instance_
		- [.setName(name)](#FenextjsValidatorClass+setName) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		- [.isEqual(d)](#FenextjsValidatorClass+isEqual) ⇒
		- [.isRequired()](#FenextjsValidatorClass+isRequired) ⇒
		- [.isBoolean()](#FenextjsValidatorClass+isBoolean) ⇒
		- [.isNumber()](#FenextjsValidatorClass+isNumber) ⇒
		- [.isString()](#FenextjsValidatorClass+isString) ⇒
		- [.isLength(length)](#FenextjsValidatorClass+isLength) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		- [.isDate()](#FenextjsValidatorClass+isDate) ⇒
		- [.isObject(obj)](#FenextjsValidatorClass+isObject) ⇒
		- [.isArray(item)](#FenextjsValidatorClass+isArray) ⇒
		- [.isMin(min)](#FenextjsValidatorClass+isMin) ⇒
		- [.isMinOrEqual(min)](#FenextjsValidatorClass+isMinOrEqual) ⇒
		- [.isMax(max)](#FenextjsValidatorClass+isMax) ⇒
		- [.isMaxOrEqual(max)](#FenextjsValidatorClass+isMaxOrEqual) ⇒
		- [.isCompareRef(refKey)](#FenextjsValidatorClass+isCompareRef) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		- [.onValidate(d)](#FenextjsValidatorClass+onValidate) ⇒
		- _static_
		- [.FenextjsValidatorClass](#FenextjsValidatorClass.FenextjsValidatorClass) : <code>string</code> \\| <code>undefined</code>
		- [.FenextjsValidatorClass](#FenextjsValidatorClass.FenextjsValidatorClass) : <code>string</code>
		- [.FenextjsValidatorClass](#FenextjsValidatorClass.FenextjsValidatorClass) : [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)

		@@ -52,12 +55,26 @@ <a name="new_FenextjsValidatorClass_new"></a>
		### new FenextjsValidatorClass(props)

		Constructor de la clase FenextjsValidatorClass.

		\| Param \| Type \| Description \|
		\| ----- \| --------------------------------------------------- \| ------------------------------------------------------------------------------------------------------------------------------------------------------------------ \|
		\| props \| <code>FenextjsValidatorClassConstructorProps</code> \| Opcional. Propiedades que se pueden pasar al constructor. Un objeto que contiene las propiedades del constructor. Por ejemplo, puede contener la propiedad "name". \|

		\| Param \| Type \| Description \|
		\| --- \| --- \| --- \|
		\| props \| <code>FenextjsValidatorClassConstructorProps</code> \| Opcional. Propiedades que se pueden pasar al constructor. Un objeto que contiene las propiedades del constructor. Por ejemplo, puede contener la propiedad "name". \|
		<a name="FenextjsValidatorClass+setName"></a>

		### fenextjsValidatorClass.setName(name) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)

		Método para establecer el nombre asociado a la instancia de FenextjsValidatorClass.

		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass) - - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.

		\| Param \| Type \| Description \|
		\| ----- \| ------------------- \| -------------------------------------------------------------------------- \|
		\| name \| <code>string</code> \| El nombre a establecer para la instancia actual de FenextjsValidatorClass. \|

		<a name="FenextjsValidatorClass+isEqual"></a>

		### fenextjsValidatorClass.isEqual(d) ⇒

		Método para definir la validación "isEqual".
		@@ -67,7 +84,7 @@ Establece la regla de que los datos deben ser iguales al valor especificado.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| d \| Valor a comparar con los datos. \|
		\| Param \| Description \|
		\| ----- \| ------------------------------- \|
		\| d \| Valor a comparar con los datos. \|

		@@ -77,2 +94,3 @@ <a name="FenextjsValidatorClass+isRequired"></a>
		### fenextjsValidatorClass.isRequired() ⇒

		Método para habilitar la validación "isRequired".
		@@ -86,2 +104,3 @@ Establece la regla de que los datos deben estar presentes y no ser nulos o indefinidos.
		### fenextjsValidatorClass.isBoolean() ⇒

		Método para habilitar la validación "isBoolean".
		@@ -95,2 +114,3 @@ Establece la regla de que los datos deben ser de tipo booleano.
		### fenextjsValidatorClass.isNumber() ⇒

		Método para habilitar la validación "isNumber".
		@@ -104,2 +124,3 @@ Establece la regla de que los datos deben ser de tipo número.
		### fenextjsValidatorClass.isString() ⇒

		Método para habilitar la validación "isString".
		@@ -113,2 +134,3 @@ Establece la regla de que los datos deben ser de tipo cadena (string).
		### fenextjsValidatorClass.isLength(length) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)

		Método para habilitar la validación de longitud.
		@@ -118,6 +140,6 @@ Establece la regla de que los datos deben tener una longitud específica.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass) - - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.
		Returns: [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass) - - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.

		\| Param \| Type \| Description \|
		\| --- \| --- \| --- \|
		\| Param \| Type \| Description \|
		\| ------ \| ------------------- \| ------------------------------------------------------------------------ \|
		\| length \| <code>number</code> \| La longitud que deben tener los datos para que la validación sea válida. \|
		@@ -128,2 +150,3 @@
		### fenextjsValidatorClass.isDate() ⇒

		Método para habilitar la validación "isDate".
		@@ -137,2 +160,3 @@ Establece la regla de que los datos deben ser de tipo Date (fecha).
		### fenextjsValidatorClass.isObject(obj) ⇒

		Método para habilitar la validación "isObject".
		@@ -142,7 +166,7 @@ Establece la regla de que los datos deben ser de tipo objeto.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| obj \| Objeto con las reglas de validación para cada propiedad del objeto. \|
		\| Param \| Description \|
		\| ----- \| ------------------------------------------------------------------- \|
		\| obj \| Objeto con las reglas de validación para cada propiedad del objeto. \|

		@@ -152,2 +176,3 @@ <a name="FenextjsValidatorClass+isArray"></a>
		### fenextjsValidatorClass.isArray(item) ⇒

		Método para habilitar la validación "isArray".
		@@ -157,7 +182,7 @@ Establece la regla de que los datos deben ser un array.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| item \| Instancia de FenextjsValidatorClass que define las reglas de validación para cada elemento del array. \|
		\| Param \| Description \|
		\| ----- \| ----------------------------------------------------------------------------------------------------- \|
		\| item \| Instancia de FenextjsValidatorClass que define las reglas de validación para cada elemento del array. \|

		@@ -167,2 +192,3 @@ <a name="FenextjsValidatorClass+isMin"></a>
		### fenextjsValidatorClass.isMin(min) ⇒

		Método para habilitar la validación "isMin".
		@@ -172,7 +198,7 @@ Establece la regla de que los datos deben ser mayores que un valor específico.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| min \| Valor mínimo que los datos deben superar. \|
		\| Param \| Description \|
		\| ----- \| ----------------------------------------- \|
		\| min \| Valor mínimo que los datos deben superar. \|

		@@ -182,2 +208,3 @@ <a name="FenextjsValidatorClass+isMinOrEqual"></a>
		### fenextjsValidatorClass.isMinOrEqual(min) ⇒

		Método para habilitar la validación "isMinOrEqual".
		@@ -187,7 +214,7 @@ Establece la regla de que los datos deben ser mayores o iguales que un valor específico.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| min \| Valor mínimo que los datos deben superar o igualar. \|
		\| Param \| Description \|
		\| ----- \| --------------------------------------------------- \|
		\| min \| Valor mínimo que los datos deben superar o igualar. \|

		@@ -197,2 +224,3 @@ <a name="FenextjsValidatorClass+isMax"></a>
		### fenextjsValidatorClass.isMax(max) ⇒

		Método para habilitar la validación "isMax".
		@@ -202,7 +230,7 @@ Establece la regla de que los datos deben ser menores que un valor específico.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| max \| Valor máximo que los datos deben ser menores que él. \|
		\| Param \| Description \|
		\| ----- \| ---------------------------------------------------- \|
		\| max \| Valor máximo que los datos deben ser menores que él. \|

		@@ -212,2 +240,3 @@ <a name="FenextjsValidatorClass+isMaxOrEqual"></a>
		### fenextjsValidatorClass.isMaxOrEqual(max) ⇒

		Método para habilitar la validación "isMaxOrEqual".
		@@ -217,11 +246,26 @@ Establece la regla de que los datos deben ser menores o iguales que un valor específico.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: Instancia de FenextjsValidatorClass.
		Returns: Instancia de FenextjsValidatorClass.

		\| Param \| Description \|
		\| --- \| --- \|
		\| max \| Valor máximo que los datos deben ser menores o igual que él. \|
		\| Param \| Description \|
		\| ----- \| ------------------------------------------------------------ \|
		\| max \| Valor máximo que los datos deben ser menores o igual que él. \|

		<a name="FenextjsValidatorClass+isCompareRef"></a>

		### fenextjsValidatorClass.isCompareRef(refKey) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)

		Método para habilitar la comparación de valores de referencia.
		Establece la regla de que los datos deben ser iguales a otro valor de referencia almacenado en la instancia.

		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass) - - La instancia actual de la clase FenextjsValidatorClass, lo que permite el encadenamiento de métodos.

		\| Param \| Type \| Description \|
		\| ------ \| ------------------- \| ---------------------------------------------------------------------------------------------- \|
		\| refKey \| <code>string</code> \| La clave que identifica el valor de referencia almacenado en la instancia para la comparación. \|

		<a name="FenextjsValidatorClass+onValidate"></a>

		### fenextjsValidatorClass.onValidate(d) ⇒

		Método para validar los datos proporcionados según las reglas establecidas.
		@@ -231,7 +275,7 @@ Ejecuta todas las reglas de validación habilitadas previamente para los datos.
		Kind: instance method of [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)
		Returns: True si los datos cumplen con todas las reglas de validación; de lo contrario, devuelve el error que indica la regla de validación que falló.
		Returns: True si los datos cumplen con todas las reglas de validación; de lo contrario, devuelve el error que indica la regla de validación que falló.

		\| Param \| Description \|
		\| --- \| --- \|
		\| d \| Datos que se deben validar. \|
		\| Param \| Description \|
		\| ----- \| --------------------------- \|
		\| d \| Datos que se deben validar. \|

		@@ -241,2 +285,3 @@ <a name="FenextjsValidatorClass.FenextjsValidatorClass"></a>
		### FenextjsValidatorClass.FenextjsValidatorClass : <code>string</code> \\| <code>undefined</code>

		Nombre asociado a la instancia de FenextjsValidatorClass.
		@@ -248,2 +293,3 @@
		### FenextjsValidatorClass.FenextjsValidatorClass : <code>string</code>

		Nombre asociado a la instancia de FenextjsValidatorClass.
		@@ -255,2 +301,3 @@
		### FenextjsValidatorClass.FenextjsValidatorClass : [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)

		El padre de la instancia actual de FenextjsValidatorClass.
		@@ -262,87 +309,294 @@
		## FenextjsValidator(props) ⇒ [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass)

		Función para crear una instancia de la clase FenextjsValidatorClass y obtener un validador.

		Kind: global function
		Returns: [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass) - - Una nueva instancia de la clase FenextjsValidatorClass que se utilizará para definir reglas de validación y validar datos.
		Returns: [<code>FenextjsValidatorClass</code>](#FenextjsValidatorClass) - - Una nueva instancia de la clase FenextjsValidatorClass que se utilizará para definir reglas de validación y validar datos.

		\| Param \| Type \| Description \|
		\| --- \| --- \| --- \|
		\| props \| <code>FenextjsValidatorClassConstructorProps</code> \| Opcional. Propiedades que se pueden pasar al constructor de FenextjsValidatorClass. Un objeto que contiene las propiedades del constructor de la clase FenextjsValidatorClass. Por ejemplo, puede contener la propiedad "name". \|
		\| Param \| Type \| Description \|
		\| ----- \| --------------------------------------------------- \| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- \|
		\| props \| <code>FenextjsValidatorClassConstructorProps</code> \| Opcional. Propiedades que se pueden pasar al constructor de FenextjsValidatorClass. Un objeto que contiene las propiedades del constructor de la clase FenextjsValidatorClass. Por ejemplo, puede contener la propiedad "name". \|

		## Import

		## Example

		```ts
		// Importar la función FenextjsValidator
		import { FenextjsValidator } from "fenextjs-validator";
		```

		// Ejemplo 1: Crear un validador y establecer la regla "isRequired"
		const r = FenextjsValidator().isRequired().onValidate("a");
		console.log(r); // Imprimir el resultado de la validación (true si es válido, ErrorInputRequired si no lo es)
		## Example

		// Ejemplo 2: Crear otro validador y establecer la regla "isBoolean"
		const r2 = FenextjsValidator().isBoolean().onValidate(false);
		console.log(r2);
		#### Ejemplo: Crear un validador y establecer la regla "isRequired"

		// Ejemplo 3: Crear otro validador y establecer la regla "isEqual" con el valor "aaaa"
		const r3 = FenextjsValidator().isEqual("aaaa").onValidate("aaaa");
		console.log(r3);
		```ts
		const ValidateIsRequired = FenextjsValidator()
		.setName("ValidateIsRequired") // Establecer un nombre para esta instancia de validador (opcional)
		.isRequired() // Establecer la regla "isRequired", que verifica si el valor es requerido (no puede estar vacío o ser nulo).
		.onValidate(""); // Realizar la validación con el valor "" (cadena vacía)

		// Ejemplo 4: Crear otro validador y establecer la regla "isNumber"
		const r4 = FenextjsValidator().isNumber().onValidate(2);
		console.log(r4);
		console.log(ValidateIsRequired);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputRequired.
		// El mensaje de este objeto puede ser algo como "Input Required [ValidateIsRequired]".
		// Esto indica que el valor proporcionado para la validación está vacío, lo que no cumple con la regla de "isRequired".

		// Ejemplo 5: Crear otro validador y establecer la regla "isString"
		const r5 = FenextjsValidator().isString().onValidate("");
		console.log(r5);
		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido diferente de una cadena vacía,
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		// Ejemplo 6: Crear otro validador y establecer la regla "isObject" con una regla de validación para la propiedad "a"
		const r6 = FenextjsValidator({ name: "Obj__" })
		#### Ejemplo: Crear un validador y establecer la regla "isBoolean"

		```ts
		const ValidateIsBoolean = FenextjsValidator()
		.setName("ValidateIsBoolean") // Establecer un nombre para esta instancia de validador (opcional)
		.isBoolean() // Establecer la regla "isBoolean", que verifica si el valor es un booleano.
		.onValidate("false"); // Realizar la validación con el valor "false" (cadena)

		console.log(ValidateIsBoolean);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [ValidateIsBoolean]".
		// Esto indica que el valor proporcionado para la validación ("false" en este caso) no es un booleano válido.

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido "true" (valor booleano válido),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer la regla "isEqual"

		```ts
		const ValidateIsEqual = FenextjsValidator()
		.setName("ValidateIsEqual") // Establecer un nombre para esta instancia de validador (opcional)
		.isEqual("aaaa") // Establecer la regla "isEqual", que verifica si el valor es igual al valor "aaaa".
		.onValidate("bbbb"); // Realizar la validación con el valor "bbbb" (cadena)

		console.log(ValidateIsEqual);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputNotEqual.
		// El mensaje de este objeto puede ser algo como "Not Equal Input [ValidateIsEqual]".
		// Esto indica que el valor proporcionado para la validación ("bbbb" en este caso) no es igual al valor esperado "aaaa".

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido "aaaa" (valor igual al valor esperado),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer la regla "isNumber"

		```ts
		const ValidateIsNumber = FenextjsValidator()
		.setName("ValidateIsNumber") // Establecer un nombre para esta instancia de validador (opcional)
		.isNumber() // Establecer la regla "isNumber", que verifica si el valor es un número.
		.onValidate("not Number"); // Realizar la validación con el valor "not Number" (cadena)

		console.log(ValidateIsNumber);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [FenextjsValidator]".
		// Esto indica que el valor proporcionado para la validación ("not Number" en este caso) no es un número válido.

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido un número, la validación habría sido exitosa,
		// y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer la regla "isString"

		```ts
		const ValidateIsString = FenextjsValidator()
		.setName("ValidateIsString") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.onValidate({}); // Realizar la validación con el valor {} (objeto)

		console.log(ValidateIsString);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [FenextjsValidator]".
		// Esto indica que el valor proporcionado para la validación ({}, un objeto) no es una cadena de texto válida.

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena de texto, la validación habría sido exitosa,
		// y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer la regla "isObject" con una regla de validación para la propiedad "key1"

		```ts
		const ValidateIsObject = FenextjsValidator()
		.setName("ValidateIsString") // Establecer un nombre para esta instancia de validador (opcional)
		.isObject({
		a: FenextjsValidator({ name: "test__" }).isString().isEqual("aa"),
		key1: FenextjsValidator() // Establecer la regla "isString" y "isEqual" para la propiedad "key1"
		.setName("ValidateIsString.key1") // Establecer un nombre para esta subinstancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isEqual("aa"), // Establecer la regla "isEqual", que verifica si el valor es igual a "aa".
		})
		.onValidate({
		a: "aaa",
		key1: "not Equal", // Realizar la validación con el objeto { key1: "not Equal" }

		// Nota: Si el valor de la propiedad "key1" hubiera sido "aa" (una cadena de texto igual a "aa"),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		});
		console.log(r6);
		//INPUT_INVALID: Invalid Input [Obj__.test__]

		// Ejemplo 7: Crear otro validador y establecer la regla "isArray" con una regla de validación para los elementos del array
		const r7 = FenextjsValidator()
		.isArray(FenextjsValidator().isString().isEqual("aa"))
		.onValidate(["aa", "aa"]);
		console.log(r7);
		console.log(ValidateIsObject);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputNotEqual.
		// El mensaje de este objeto puede ser algo como "Not Equal Input [ValidateIsString.key1]".
		// Esto indica que el valor proporcionado para la validación de la propiedad "key1" ("not Equal" en este caso)
		// no es igual al valor esperado "aa" definido en la regla "isEqual".

		// Ejemplo 8: Crear otro validador y establecer la regla "isString" y "isMin" (longitud mínima 3 caracteres)
		const r8 = FenextjsValidator().isString().isMin(3).onValidate("aaaaa");
		console.log(r8);
		// Además, el mensaje también incluye el nombre del validador asociado ("ValidateIsString.key1")
		// para indicar que la propiedad "key1" del objeto no cumple con la regla de validación "isString" e "isEqual".
		```

		// Ejemplo 9: Crear otro validador y establecer la regla "isString" y "isMinOrEqual" (longitud mínima 3 caracteres o igual)
		const r9 = FenextjsValidator().isString().isMinOrEqual(3).onValidate("aaa");
		console.log(r9);
		#### Ejemplo: Crear un validador y establecer la regla "isArray" con una regla de validación para los elementos del array

		// Ejemplo 10: Crear otro validador y establecer la regla "isNumber" y "isMax" (valor máximo 3)
		const r10 = FenextjsValidator().isNumber().isMax(3).onValidate(2);
		console.log(r10);
		```ts
		const ValidateIsArray = FenextjsValidator()
		.setName("ValidateIsArray") // Establecer un nombre para esta instancia de validador (opcional)
		.isArray(
		// Establecer la regla "isArray", que verifica si el valor es un array.
		FenextjsValidator().isString().isEqual("aa"), // Establecer la regla "isString" y "isEqual" para los elementos del array
		)
		.onValidate(["aa", "not equal"]); // Realizar la validación con el array ["aa", "not equal"]

		// Ejemplo 11: Crear otro validador y establecer la regla "isString" y "isMaxOrEqual" (longitud máxima 3 caracteres o igual)
		const r11 = FenextjsValidator().isString().isMaxOrEqual(3).onValidate("aaa");
		console.log(r11);
		console.log(ValidateIsArray);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputNotEqual.
		// El mensaje de este objeto puede ser algo como "Not Equal Input [ValidateIsArray.1]".
		// Esto indica que el valor proporcionado para la validación del segundo elemento del array ("not equal" en este caso)
		// no es igual al valor esperado "aa" definido en la regla "isEqual".

		// Ejemplo 12: Crear otro validador y establecer la regla "isDate" y "isMax" (fecha máxima: 100)
		const r12 = FenextjsValidator({ name: "date" })
		.isDate()
		.isMax(new Date(100))
		.onValidate(new Date(10));
		console.log(r12);
		// Además, el mensaje también incluye el nombre del validador asociado ("ValidateIsArray.1")
		// para indicar que el segundo elemento del array no cumple con la regla de validación "isString" e "isEqual".
		```

		// Ejemplo 13: Crear otro validador y establecer la regla "isLength" con longitud de 4 caracteres
		const r13 = FenextjsValidator({ name: "InputLength" })
		.isLength(4)
		.onValidate("tesing");
		console.log(r13);
		//INPUT_INVALID: Invalid Input [InputLength]
		#### Ejemplo: Crear un validador y establecer las reglas "isString" y "isMin" (longitud mínima 3 caracteres)

		```ts
		const ValidateIsMin = FenextjsValidator()
		.setName("ValidateIsMin") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isMin(3) // Establecer la regla "isMin", que verifica si la longitud de la cadena es mayor o igual a 3 caracteres.
		.onValidate("NO"); // Realizar la validación con la cadena "NO"

		console.log(ValidateIsMin);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [ValidateIsMin]".
		// Esto indica que el valor proporcionado para la validación ("NO" en este caso) no cumple con la regla de longitud mínima.

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena con al menos 3 caracteres (por ejemplo, "YES"),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer las reglas "isString" y "isMinOrEqual" (longitud mínima 3 caracteres o igual)

		```ts
		const ValidateIsMinOrEqual = FenextjsValidator()
		.setName("ValidateIsMinOrEqual") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isMinOrEqual(3) // Establecer la regla "isMinOrEqual", que verifica si la longitud de la cadena es mayor o igual a 3 caracteres.
		.onValidate("aaa"); // Realizar la validación con la cadena "aaa"

		console.log(ValidateIsMinOrEqual);
		// En este caso, el resultado de la validación será "true".
		// Esto indica que el valor proporcionado para la validación ("aaa" en este caso) cumple con la regla de longitud mínima (3 caracteres).

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena con menos de 3 caracteres (por ejemplo, "aa"),
		// la validación habría sido exitosa, y el resultado también habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer las reglas "isNumber" e "isMax" (valor máximo 3)

		```ts
		const ValidateIsMax = FenextjsValidator()
		.setName("ValidateIsMax") // Establecer un nombre para esta instancia de validador (opcional)
		.isNumber() // Establecer la regla "isNumber", que verifica si el valor es un número.
		.isMax(3) // Establecer la regla "isMax", que verifica si el valor numérico es menor o igual a 3.
		.onValidate(20); // Realizar la validación con el valor numérico 20

		console.log(ValidateIsMax);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputValueTooHigh.
		// El mensaje de este objeto puede ser algo como "Value Too High [ValidateIsMax]".
		// Esto indica que el valor proporcionado para la validación (20 en este caso) es mayor que el valor máximo permitido (3).

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido un número menor o igual a 3 (por ejemplo, 2),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer las reglas "isString" e "isMaxOrEqual" (longitud máxima 3 caracteres o igual)

		```ts
		const ValidateIsMaxOrEqual = FenextjsValidator()
		.setName("ValidateIsMaxOrEqual") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isMaxOrEqual(3) // Establecer la regla "isMaxOrEqual", que verifica si la longitud de la cadena es menor o igual a 3 caracteres.
		.onValidate("aaa"); // Realizar la validación con la cadena "aaa"

		console.log(ValidateIsMaxOrEqual);
		// En este caso, el resultado de la validación será "true".
		// Esto indica que el valor proporcionado para la validación ("aaa" en este caso) cumple con la regla de longitud máxima o es igual a 3 caracteres.

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido una cadena con más de 3 caracteres (por ejemplo, "aaaa"),
		// la validación habría sido exitosa, y el resultado también habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer las reglas "isDate" e "isMax" (fecha máxima: 100)

		```ts
		const ValidateIsDate = FenextjsValidator()
		.setName("ValidateIsDate") // Establecer un nombre para esta instancia de validador (opcional)
		.isDate() // Establecer la regla "isDate", que verifica si el valor es una fecha válida.
		.isMax(new Date(100)) // Establecer la regla "isMax", que verifica si la fecha es anterior o igual a la fecha máxima (100).
		.onValidate(new Date(10)); // Realizar la validación con la fecha new Date(10)

		console.log(ValidateIsDate);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputValueTooHigh.
		// El mensaje de este objeto puede ser algo como "Value Too High [ValidateIsDate]".
		// Esto indica que la fecha proporcionada para la validación (new Date(10) en este caso) es posterior a la fecha máxima permitida (new Date(100)).

		// Nota: Si la fecha proporcionada en "onValidate()" hubiera sido una fecha anterior o igual a new Date(100),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer la regla "isLength" (longitud debe ser 4 caracteres)

		```ts
		const ValidateIsLength = FenextjsValidator()
		.setName("ValidateIsLength") // Establecer un nombre para esta instancia de validador (opcional)
		.isLength(4) // Establecer la regla "isLength", que verifica si la longitud de la cadena es igual a 4 caracteres.
		.onValidate("tesing"); // Realizar la validación con la cadena "tesing"

		console.log(ValidateIsLength);
		// En este caso, el resultado de la validación será un objeto de tipo ErrorInputInvalid.
		// El mensaje de este objeto puede ser algo como "Invalid Input [ValidateIsLength]".
		// Esto indica que la cadena proporcionada para la validación ("tesing" en este caso) no cumple con la regla de longitud (4 caracteres).

		// Nota: Si la cadena proporcionada en "onValidate()" hubiera sido una cadena de 4 caracteres (por ejemplo, "test"),
		// la validación habría sido exitosa, y el resultado habría sido "true" (indicando que el valor es válido).
		```

		#### Ejemplo: Crear un validador y establecer la regla "isObject" con dos reglas de validación para las propiedades "keyA" y "keyB"

		```ts
		// Definir la interfaz que describe la estructura de datos para la validación
		interface ValidateIsCompareRefInteface {
		keyA: string;
		keyB: string;
		}

		const ValidateIsCompareRef = FenextjsValidator<ValidateIsCompareRefInteface>()
		.setName("ValidateIsCompareRef") // Establecer un nombre para esta instancia de validador (opcional)
		.isObject({
		keyA: FenextjsValidator()
		.setName("ValidateIsCompareRef.keyA") // Establecer un nombre para esta instancia de validador (opcional)
		.isString() // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		.isCompareRef("keyB"), // Establecer la regla "isCompareRef", que compara el valor de "keyA" con el valor de "keyB".
		keyB: FenextjsValidator()
		.setName("ValidateIsCompareRef.keyB") // Establecer un nombre para esta instancia de validador (opcional)
		.isString(), // Establecer la regla "isString", que verifica si el valor es una cadena de texto.
		})
		.onValidate({
		keyA: "aaa",
		keyB: "bbb",
		}); // Realizar la validación con el objeto { keyA: "aaa", keyB: "bbb" }

		console.log(ValidateIsCompareRef);
		// En este caso, el resultado de la validación será "true".
		// Esto indica que el objeto proporcionado para la validación cumple con todas las reglas definidas en la estructura de datos ValidateIsCompareRefInteface.

		// Nota: Si el valor proporcionado en "onValidate()" hubiera sido un objeto con valores diferentes para "keyA" y "keyB",
		// la validación habría sido fallida, y el resultado habría sido un objeto de tipo ErrorInputNotEqual,
		// que indica que los valores de "keyA" y "keyB" no son iguales.
		```

		## Developer
		@@ -349,0 +603,0 @@

cjs/index.js.map

Sorry, the diff of this file is not supported yet

cjs/test.js.map

Sorry, the diff of this file is not supported yet

fenextjs-validator - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Dependency changes