@decaf-ts/decorator-validation 1.11.23 → 1.12.0

package/lib/validation/Validators/PatternValidator.d.ts

@@ -1,103 +0,0 @@
-import { Validator } from "./Validator";
-import { PatternValidatorOptions } from "../types";
-/**
- * @description Regular expression for parsing string patterns with flags
- * @summary This regular expression is used to parse string patterns in the format "/pattern/flags".
- * It captures the pattern and flags separately, allowing the creation of a RegExp object
- * with the appropriate flags.
- *
- * @const {RegExp}
- * @memberOf module:decorator-validation
- * @category Validation
- */
-export declare const regexpParser: RegExp;
-/**
- * @description Validator for checking if a string matches a regular expression pattern
- * @summary The PatternValidator checks if a string value matches a specified regular expression pattern.
- * It supports both RegExp objects and string representations of patterns, including those with flags.
- * This validator is the foundation for specialized validators like EmailValidator and URLValidator,
- * and is typically used with the @pattern decorator.
- *
- * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
- *
- * @class PatternValidator
- * @extends Validator
- *
- * @example
- * ```typescript
- * // Create a pattern validator with default error message
- * const patternValidator = new PatternValidator();
- *
- * // Create a pattern validator with custom error message
- * const customPatternValidator = new PatternValidator("Value must match the required format");
- *
- * // Validate using a RegExp object
- * const regexOptions = { pattern: /^[A-Z][a-z]+$/ };
- * patternValidator.hasErrors("Hello", regexOptions); // undefined (valid)
- * patternValidator.hasErrors("hello", regexOptions); // Returns error message (invalid)
- *
- * // Validate using a string pattern
- * const stringOptions = { pattern: "^\\d{3}-\\d{2}-\\d{4}$" };
- * patternValidator.hasErrors("123-45-6789", stringOptions); // undefined (valid)
- *
- * // Validate using a string pattern with flags
- * const flagOptions = { pattern: "/^hello$/i" };
- * patternValidator.hasErrors("Hello", flagOptions); // undefined (valid)
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant V as PatternValidator
- *
- *   C->>V: new PatternValidator(message)
- *   C->>V: hasErrors(value, options)
- *   alt value is empty
- *     V-->>C: undefined (valid)
- *   else pattern is missing
- *     V-->>C: Error: Missing Pattern
- *   else pattern is string
- *     V->>V: getPattern(pattern)
- *   end
- *   V->>V: Reset pattern.lastIndex
- *   V->>V: Test value against pattern
- *   alt pattern test passes
- *     V-->>C: undefined (valid)
- *   else pattern test fails
- *     V-->>C: Error message
- *   end
- *
- * @category Validators
- */
-export declare class PatternValidator extends Validator<PatternValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @description Converts a string pattern to a RegExp object
-     * @summary Parses a string representation of a regular expression and converts it to a RegExp object.
-     * It handles both simple string patterns and patterns with flags in the format "/pattern/flags".
-     *
-     * @param {string} pattern - The string pattern to convert
-     * @return {RegExp} A RegExp object created from the string pattern
-     * @private
-     */
-    private getPattern;
-    /**
-     * @description Checks if a string matches a regular expression pattern
-     * @summary Validates that the provided string matches the pattern specified in the options.
-     * If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.
-     * The method resets the pattern's lastIndex property to ensure consistent validation results
-     * for patterns with the global flag.
-     *
-     * @param {string} value - The string to validate against the pattern
-     * @param {PatternValidatorOptions} options - Configuration options containing the pattern
-     *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
-     *
-     * @throws {Error} If no pattern is provided in the options
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: string, options: PatternValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/PatternValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PatternValidator.js","sourceRoot":"","sources":["../../../src/validation/Validators/PatternValidator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwC;AACxC,+CAAqE;AACrE,iDAAyC;AAGzC;;;;;;;;;GASG;AACU,QAAA,YAAY,GAAW,IAAI,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEI,IAAM,gBAAgB,GAAtB,MAAM,gBAAiB,SAAQ,qBAAkC;IACtE,YAAY,UAAkB,kCAAsB,CAAC,OAAO;QAC1D,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;;OAQG;IACK,UAAU,CAAC,OAAe;QAChC,IAAI,CAAC,oBAAY,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,KAAK,GAAQ,OAAO,CAAC,KAAK,CAAC,oBAAY,CAAC,CAAC;QAC/C,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,SAAS,CACd,KAAa,EACb,OAAgC;QAEhC,IAAI,CAAC,KAAK;YAAE,OAAO;QAEnB,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAC1B,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACjD,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3E,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,yDAAyD;QAChF,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;YACzB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;YAClD,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;CACF,CAAA;AApDY,4CAAgB;2BAAhB,gBAAgB;IAD5B,IAAA,sBAAS,EAAC,0BAAc,CAAC,OAAO,CAAC;;GACrB,gBAAgB,CAoD5B"}

package/lib/validation/Validators/RequiredValidator.d.ts

@@ -1,74 +0,0 @@
-import { Validator } from "./Validator";
-import { ValidatorOptions } from "../types";
-/**
- * @description Validator for checking if a value is present and not empty
- * @summary The RequiredValidator ensures that a value is provided and not empty.
- * It handles different types of values appropriately: for booleans and numbers,
- * it checks if they're undefined; for other types (strings, arrays, objects),
- * it checks if they're falsy. This validator is typically used with the @required decorator
- * and is often the first validation applied to important fields.
- *
- * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
- *
- * @class RequiredValidator
- * @extends Validator
- *
- * @example
- * ```typescript
- * // Create a required validator with default error message
- * const requiredValidator = new RequiredValidator();
- *
- * // Create a required validator with custom error message
- * const customRequiredValidator = new RequiredValidator("This field is mandatory");
- *
- * // Validate different types of values
- * requiredValidator.hasErrors("Hello"); // undefined (valid)
- * requiredValidator.hasErrors(""); // Returns error message (invalid)
- * requiredValidator.hasErrors(0); // undefined (valid - 0 is a valid number)
- * requiredValidator.hasErrors(null); // Returns error message (invalid)
- * requiredValidator.hasErrors([]); // undefined (valid - empty array is still an array)
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant V as RequiredValidator
- *
- *   C->>V: new RequiredValidator(message)
- *   C->>V: hasErrors(value, options)
- *   alt typeof value is boolean or number
- *     alt value is undefined
- *       V-->>C: Error message
- *     else value is defined
- *       V-->>C: undefined (valid)
- *     end
- *   else other types
- *     alt value is falsy (null, undefined, empty string)
- *       V-->>C: Error message
- *     else value is truthy
- *       V-->>C: undefined (valid)
- *     end
- *   end
- *
- * @category Validators
- */
-export declare class RequiredValidator extends Validator {
-    constructor(message?: string);
-    /**
-     * @description Checks if a value is present and not empty
-     * @summary Validates that the provided value exists and is not empty.
-     * The validation logic varies by type:
-     * - For booleans and numbers: checks if the value is undefined
-     * - For other types (strings, arrays, objects): checks if the value is falsy
-     *
-     * @param {any} value - The value to validate
-     * @param {ValidatorOptions} [options={}] - Optional configuration options
-     *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: any, options?: ValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/RequiredValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"RequiredValidator.js","sourceRoot":"","sources":["../../../src/validation/Validators/RequiredValidator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwC;AACxC,+CAAqE;AACrE,iDAAyC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEI,IAAM,iBAAiB,GAAvB,MAAM,iBAAkB,SAAQ,qBAAS;IAC9C,YAAY,UAAkB,kCAAsB,CAAC,QAAQ;QAC3D,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,SAAS,CACd,KAAU,EACV,UAA4B,EAAE;QAE9B,QAAQ,OAAO,KAAK,EAAE,CAAC;YACrB,KAAK,SAAS,CAAC;YACf,KAAK,QAAQ;gBACX,OAAO,OAAO,KAAK,KAAK,WAAW;oBACjC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;oBAClD,CAAC,CAAC,SAAS,CAAC;YAChB;gBACE,OAAO,CAAC,KAAK;oBACX,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;oBAClD,CAAC,CAAC,SAAS,CAAC;QAClB,CAAC;IACH,CAAC;CACF,CAAA;AArCY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,sBAAS,EAAC,0BAAc,CAAC,QAAQ,CAAC;;GACtB,iBAAiB,CAqC7B"}

package/lib/validation/Validators/StepValidator.d.ts

@@ -1,29 +0,0 @@
-import { Validator } from "./Validator";
-import { StepValidatorOptions } from "../types";
-/**
- * @summary Step Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}
- *
- * @class StepValidator
- * @extends Validator
- *
- * @category Validators
- */
-export declare class StepValidator extends Validator<StepValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @summary Validates a model
-     *
-     * @param {string} value
-     * @param {number} step
-     * @param {StepValidatorOptions} options
-     *
-     * @return {string | undefined}
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: number | string, options: StepValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/StepValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"StepValidator.js","sourceRoot":"","sources":["../../../src/validation/Validators/StepValidator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwC;AACxC,+CAAqE;AACrE,iDAAyC;AAGzC;;;;;;;;;GASG;AAEI,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,qBAA+B;IAChE,YAAY,UAAkB,kCAAsB,CAAC,IAAI;QACvD,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,SAAS,CACd,KAAsB,EACtB,OAA6B;QAE7B,IAAI,OAAO,KAAK,KAAK,WAAW;YAAE,OAAO;QACzC,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;YAC/C,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC;YAChE,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;CACF,CAAA;AA3BY,sCAAa;wBAAb,aAAa;IADzB,IAAA,sBAAS,EAAC,0BAAc,CAAC,IAAI,CAAC;;GAClB,aAAa,CA2BzB"}

package/lib/validation/Validators/TypeValidator.d.ts

@@ -1,79 +0,0 @@
-import { Validator } from "./Validator";
-import { TypeValidatorOptions } from "../types";
-/**
- * @description Validator for checking if a value is of the expected type(s)
- * @summary The TypeValidator ensures that a value matches one of the specified types.
- * It can validate against a single type, multiple types, or a type with a specific name.
- * This validator is typically used with the @type decorator and is fundamental for
- * ensuring type safety in validated models.
- *
- * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
- *
- * @class TypeValidator
- * @extends Validator
- *
- * @example
- * ```typescript
- * // Create a type validator with default error message
- * const typeValidator = new TypeValidator();
- *
- * // Create a type validator with custom error message
- * const customTypeValidator = new TypeValidator("Value must be of type {0}, but got {1}");
- *
- * // Validate against a single type
- * const stringOptions = { types: "string" };
- * typeValidator.hasErrors("hello", stringOptions); // undefined (valid)
- * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)
- *
- * // Validate against multiple types
- * const multiOptions = { types: ["string", "number"] };
- * typeValidator.hasErrors("hello", multiOptions); // undefined (valid)
- * typeValidator.hasErrors(123, multiOptions); // undefined (valid)
- * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)
- *
- * // Validate against a class type
- * const classOptions = { types: { name: "Date" } };
- * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant V as TypeValidator
- *   participant R as Reflection
- *
- *   C->>V: new TypeValidator(message)
- *   C->>V: hasErrors(value, options)
- *   alt value is undefined
- *     V-->>C: undefined (valid)
- *   else value is defined
- *     V->>R: evaluateDesignTypes(value, types)
- *     alt type evaluation passes
- *       V-->>C: undefined (valid)
- *     else type evaluation fails
- *       V->>V: Format error message with type info
- *       V-->>C: Error message
- *     end
- *   end
- *
- * @category Validators
- */
-export declare class TypeValidator extends Validator<TypeValidatorOptions> {
-    constructor(message?: string);
-    /**
-     * @description Checks if a value is of the expected type(s)
-     * @summary Validates that the provided value matches one of the specified types.
-     * It uses the Reflection utility to evaluate if the value's type matches the expected types.
-     * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.
-     *
-     * @param {any} value - The value to validate
-     * @param {TypeValidatorOptions} options - Configuration options containing the expected types
-     *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
-     *
-     * @override
-     *
-     * @see Validator#hasErrors
-     */
-    hasErrors(value: any, options: TypeValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/TypeValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TypeValidator.js","sourceRoot":"","sources":["../../../src/validation/Validators/TypeValidator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwC;AACxC,+CAAqE;AACrE,iDAAyC;AACzC,oDAA2C;AAM3C,2DAAkD;AAClD,uCAA8C;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEI,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,qBAA+B;IAChE,YAAY,UAAkB,kCAAsB,CAAC,IAAI;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACI,SAAS,CACd,KAAU,EACV,OAA6B;QAE7B,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,CAAC,0CAA0C;QAE3E,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QAE/C,IAAI,EAAE,GAAG,WAAW,IAAI,IAAI,CAAC;QAC7B,EAAE,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC7C,IAAI,OAAO,CAAC,KAAK,QAAQ;gBAAE,OAAO,CAAC,CAAC;YACpC,IAAI,OAAO,CAAC,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,IAAI;gBAAE,CAAC,GAAI,CAAkB,EAAE,CAAC;YAClE,OAAQ,CAAS,CAAC,IAAI,IAAI,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,IAAA,2BAAmB,EAAC,KAAK,EAAE,EAAS,CAAC;YACxC,OAAO,IAAI,CAAC,UAAU,CACpB,OAAO,IAAI,IAAI,CAAC,OAAO,EACvB,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,EACpE,OAAO,KAAK,CACb,CAAC;IACN,CAAC;CACF,CAAA;AA1CY,sCAAa;wBAAb,aAAa;IADzB,IAAA,sBAAS,EAAC,0BAAc,CAAC,IAAI,CAAC;;GAClB,aAAa,CA0CzB;AAED;;;;;;;GAOG;AACH,uBAAU,CAAC,QAAQ,CAAC;IAClB,SAAS,EAAE,aAAiC;IAC5C,aAAa,EAAE,qBAAS,CAAC,IAAI;IAC7B,IAAI,EAAE,KAAK;CACW,CAAC,CAAC"}

package/lib/validation/Validators/URLValidator.d.ts

@@ -1,61 +0,0 @@
-import { PatternValidator } from "./PatternValidator";
-import { PatternValidatorOptions } from "../types";
-/**
- * @description Validator for checking if a string is a valid URL
- * @summary The URLValidator checks if a string matches a standard URL pattern.
- * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
- * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
- * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
- *
- * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
- *
- * @class URLValidator
- * @extends PatternValidator
- *
- * @example
- * ```typescript
- * // Create a URL validator with default error message
- * const urlValidator = new URLValidator();
- *
- * // Create a URL validator with custom error message
- * const customUrlValidator = new URLValidator("Please enter a valid web address");
- *
- * // Validate a URL
- * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
- * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant U as URLValidator
- *   participant P as PatternValidator
- *
- *   C->>U: new URLValidator(message)
- *   U->>P: super(message)
- *   C->>U: hasErrors(value, options)
- *   U->>P: super.hasErrors(value, options with URL pattern)
- *   P-->>U: validation result
- *   U-->>C: validation result
- *
- * @category Validators
- */
-export declare class URLValidator extends PatternValidator {
-    constructor(message?: string);
-    /**
-     * @description Checks if a string is a valid URL
-     * @summary Validates that the provided string matches the URL pattern.
-     * This method extends the PatternValidator's hasErrors method by ensuring
-     * the URL pattern is used, even if not explicitly provided in the options.
-     *
-     * @param {string} value - The string to validate as a URL
-     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
-     *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
-     *
-     * @override
-     *
-     * @see PatternValidator#hasErrors
-     */
-    hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
-}

package/lib/validation/Validators/URLValidator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"URLValidator.js","sourceRoot":"","sources":["../../../src/validation/Validators/URLValidator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAIqB;AACrB,6DAAsD;AACtD,iDAAyC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEI,IAAM,YAAY,GAAlB,MAAM,YAAa,SAAQ,mCAAgB;IAChD,YAAY,UAAkB,kCAAsB,CAAC,GAAG;QACtD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACa,SAAS,CACvB,KAAa,EACb,UAAmC,EAAE;QAErC,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE;YAC5B,GAAG,OAAO;YACV,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;YACxC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,4BAAgB,CAAC,GAAG;SACjD,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AA9BY,oCAAY;uBAAZ,YAAY;IADxB,IAAA,sBAAS,EAAC,0BAAc,CAAC,GAAG,CAAC;;GACjB,YAAY,CA8BxB"}

package/lib/validation/Validators/Validator.d.ts

@@ -1,65 +0,0 @@
-import { ValidatorOptions } from "../types";
-import type { PathProxy } from "../../utils";
-import { BaseValidator } from "./BaseValidator";
-/**
- * @description
- * Abstract class for defining synchronous validators.
- *
- * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
- *
- * Use this when the validation process is immediate and does not require asynchronous operations.
- *
- * @example
- * ```typescript
- * // Example of a synchronous validator that checks if a number is greater than
- * class GreaterThanValidator extends Validator<{ gt?: number }> {
- *   constructor(message: string = "Value must be greater than {0}") {
- *     super(message);
- *   }
- *
- *   hasErrors(value: number, options?: { gt?: number }) {
- *     const minValue = options?.gt ?? 0;
- *     if (value <= minValue) {
- *       return this.getMessage();
- *     }
- *     return undefined;
- *   }
- * }
- *
- * // Example usage:
- * const validator = new GreaterThanValidator();
- * const error = validator.hasErrors(10, { gt: 15 });
- * if (error) {
- *   console.log('Value must be greater than 15')
- * } else {
- *   console.log('Value is valid');
- * }
- * ```
- *
- * - If `value` is less than or equal to `gt`, returns the error message.
- * - Otherwise, returns `undefined` indicating validation success.
- *
- * @see {@link BaseValidator} For the base validator.
- * @see {@link ValidatorOptions} For the base validator options.
- */
-export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> extends BaseValidator<V, false> {
-    protected constructor(message?: string, ...acceptedTypes: string[]);
-    /**
-     * @description Validates a value against specific validation rules
-     * @summary Abstract method that must be implemented by all validator subclasses.
-     * This method contains the core validation logic that determines whether a value
-     * is valid according to the specific rules of the validator. If the value is valid,
-     * the method returns undefined; otherwise, it returns an error message.
-     *
-     * @template V - Type of the options object that can be passed to the validator
-     * @param {any} value - The value to validate
-     * @param {V} [options] - Optional configuration options for customizing validation behavior
-     * @param {PathProxy<any>} proxy -
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
-     *
-     * @abstract
-     *
-     * @see Model#validate
-     */
-    abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): string | undefined;
-}

package/lib/validation/Validators/Validator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../../../src/validation/Validators/Validator.ts"],"names":[],"mappings":";;;AAAA,+CAAqD;AAGrD,uDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAsB,SAEpB,SAAQ,6BAAuB;IAC/B,YACE,UAAkB,kCAAsB,CAAC,OAAO,EAChD,GAAG,aAAuB;QAE1B,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,aAAa,CAAC,CAAC;IAC1C,CAAC;CAwBF;AAhCD,8BAgCC"}

package/lib/validation/Validators/ValidatorRegistry.d.ts

@@ -1,41 +0,0 @@
-import { ValidatorDefinition } from "../types";
-import { IValidatorRegistry } from "../types";
-import { Validator } from "./Validator";
-/**
- * @summary Base Implementation of a Validator Registry
- *
- * @prop {Validator[]} [validators] the initial validators to register
- *
- * @class ValidatorRegistry
- * @implements IValidatorRegistry<T>
- *
- * @category Validation
- */
-export declare class ValidatorRegistry<T extends Validator> implements IValidatorRegistry<T> {
-    private cache;
-    private customKeyCache;
-    constructor(...validators: (ValidatorDefinition | Validator)[]);
-    /**
-     * @summary retrieves the custom keys
-     */
-    getCustomKeys(): {
-        [indexer: string]: string;
-    };
-    /**
-     * @summary retrieves the registered validators keys
-     */
-    getKeys(): string[];
-    /**
-     * @summary Retrieves a validator
-     *
-     * @param {string} validatorKey one of the {@link ValidationKeys}
-     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
-     */
-    get<T extends Validator>(validatorKey: string): T | undefined;
-    /**
-     * @summary Registers the provided validators onto the registry
-     *
-     * @param {T[] | ValidatorDefinition[]} validator
-     */
-    register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
-}

package/lib/validation/Validators/ValidatorRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ValidatorRegistry.js","sourceRoot":"","sources":["../../../src/validation/Validators/ValidatorRegistry.ts"],"names":[],"mappings":";;;AAEA,+CAAwC;AAExC;;;;;;;;;GASG;AACH,MAAa,iBAAiB;IAM5B,YAAY,GAAG,UAA+C;QAHtD,UAAK,GAAQ,EAAE,CAAC;QAItB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAsB,YAAoB;QAC3C,IAAI,CAAC,CAAC,YAAY,IAAI,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAEpD,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACjD,IAAI,qBAAS,CAAC,WAAW,CAAC,eAAe,CAAC;YAAE,OAAO,eAAoB,CAAC;QACxE,MAAM,WAAW,GAAG,eAAe,CAAC,OAAO,IAAI,eAAe,CAAC;QAC/D,MAAM,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,QAAQ,CAAC;QACpC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACH,QAAQ,CACN,GAAG,SAAsC;QAEzC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACtB,IAAI,qBAAS,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7B,YAAY;gBAEZ,IAAK,CAAyB,CAAC,aAAa,IAAI,IAAI,CAAC,KAAK;oBAAE,OAAO;gBACnE,IAAI,CAAC,KAAK,CAAE,CAAyB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YAC3D,CAAC;iBAAM,CAAC;gBACN,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,CAAwB,CAAC;gBACpE,IAAI,aAAa,IAAI,IAAI,CAAC,KAAK;oBAAE,OAAO;gBACxC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;gBACtC,IAAI,CAAC,IAAI;oBAAE,OAAO;gBAClB,MAAM,GAAG,GAA2B,EAAE,CAAC;gBACvC,GAAG,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,GAAG,aAAa,CAAC;gBAEjD,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;YACpE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AApED,8CAoEC"}

package/lib/validation/Validators/constants.d.ts

@@ -1,157 +0,0 @@
-/**
- * @description Object-like set of keys used for comparison-based validations.
- * @summary Provides canonical names for validators that compare two values (equality and ordering checks).
- * @typedef {Object} ComparisonValidationKeysDef
- * @property {"equals"} EQUALS Validates if two values are equal.
- * @property {"different"} DIFF Validates if two values are different.
- * @property {"lessThan"} LESS_THAN Validates if a value is less than another.
- * @property {"lessThanOrEqual"} LESS_THAN_OR_EQUAL Validates if a value is less than or equal to another.
- * @property {"greaterThan"} GREATER_THAN Validates if a value is greater than another.
- * @property {"greaterThanOrEqual"} GREATER_THAN_OR_EQUAL Validates if a value is greater than or equal to another.
- * @memberOf module:decorator-validation.Validation
- */
-/**
- * @description Keys used for comparison-based validations.
- * @summary Canonical key names for comparison validators.
- * @const ComparisonValidationKeys
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- * @type {ComparisonValidationKeysDef}
- */
-export declare const ComparisonValidationKeys: {
-    readonly EQUALS: "equals";
-    readonly DIFF: "different";
-    readonly LESS_THAN: "lessThan";
-    readonly LESS_THAN_OR_EQUAL: "lessThanOrEqual";
-    readonly GREATER_THAN: "greaterThan";
-    readonly GREATER_THAN_OR_EQUAL: "greaterThanOrEqual";
-};
-/**
- * @description Object-like set of keys used across all validators in the system.
- * @summary Defines the canonical namespaced key prefix and the individual validation flags for rules such as required, min/max, length, patterns, types, lists and more.
- * @typedef {Object} ValidationKeysDef
- * @property {string} REFLECT prefixes others (namespace prefix)
- * @property {"required"} REQUIRED sets as required
- * @property {"min"} MIN defines min value
- * @property {"max"} MAX defines max value
- * @property {"step"} STEP defines step
- * @property {"minlength"} MIN_LENGTH defines min length
- * @property {"maxlength"} MAX_LENGTH defines max length
- * @property {"pattern"} PATTERN defines pattern
- * @property {"email"} EMAIL defines email
- * @property {"url"} URL defines url
- * @property {"date"} DATE defines date
- * @property {"type"} TYPE defines type
- * @property {"password"} PASSWORD defines password
- * @property {"list"} LIST defines list
- * @property {"unique"} UNIQUE flags uniqueness
- * @property {"validator"} VALIDATOR custom validator id
- * @memberOf module:decorator-validation.Validation
- */
-/**
- * @description The keys used for validation.
- * @summary A namespaced collection of validation key strings used throughout the library.
- * @const ValidationKeys
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- * @type {ValidationKeysDef}
- */
-export declare const ValidationKeys: {
-    readonly EQUALS: "equals";
-    readonly DIFF: "different";
-    readonly LESS_THAN: "lessThan";
-    readonly LESS_THAN_OR_EQUAL: "lessThanOrEqual";
-    readonly GREATER_THAN: "greaterThan";
-    readonly GREATER_THAN_OR_EQUAL: "greaterThanOrEqual";
-    readonly REFLECT: "validation";
-    readonly DATE: "date";
-    readonly EMAIL: "email";
-    readonly FORMAT: "format";
-    readonly LIST: "list";
-    readonly MAX: "max";
-    readonly MAX_LENGTH: "maxlength";
-    readonly MIN: "min";
-    readonly MIN_LENGTH: "minlength";
-    readonly PASSWORD: "password";
-    readonly PATTERN: "pattern";
-    readonly REQUIRED: "required";
-    readonly STEP: "step";
-    readonly TYPE: "type";
-    readonly UNIQUE: "unique";
-    readonly URL: "url";
-    readonly VALIDATOR: "validator";
-    readonly ENUM: "enum";
-};
-/**
- * @description list of month names
- * @summary Stores month names. Can be changed for localization purposes
- * @const MONTH_NAMES
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export declare const MONTH_NAMES: string[];
-/**
- * @description list of names of days of the week
- * @summary Stores names for days of the week. Can be changed for localization purposes
- * @const DAYS_OF_WEEK_NAMES
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export declare const DAYS_OF_WEEK_NAMES: string[];
-/**
- * @description Type definition for default error message strings keyed by validation type.
- * @summary Enumerates the supported error message keys with their intended meaning; used to localize or override default messages.
- * @typedef {Object} DefaultErrorMessages
- * @property {string} REQUIRED default error message
- * @property {string} MIN default error message
- * @property {string} MAX default error message
- * @property {string} MIN_LENGTH default error message
- * @property {string} MAX_LENGTH default error message
- * @property {string} PATTERN default error message
- * @property {string} EMAIL default error message
- * @property {string} URL default error message
- * @property {string} TYPE default error message
- * @property {string} STEP default error message
- * @property {string} DATE default error message
- * @property {string} DEFAULT default error message
- * @property {string} PASSWORD default error message
- * @property {string} LIST default error message
- * @property {string} LIST_INSIDE default error message
- * @property {string} MODEL_NOT_FOUND default error message
- * @memberOf module:decorator-validation.Validation
- */
-/**
- * @description Defines the default error messages
- * @summary Mapping between validation keys and their default human-readable error messages.
- * @const DEFAULT_ERROR_MESSAGES
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- * @type {DefaultErrorMessages}
- */
-export declare const DEFAULT_ERROR_MESSAGES: Record<string, string>;
-/**
- * @description Type definition for default regular expression patterns used in validation.
- * @summary Captures common regex patterns for email, URL, and password policies, including nested grouping for password-related rules.
- * @typedef {Object} DefaultPatterns
- * @property {RegExp} EMAIL Email address validation pattern
- * @property {RegExp} URL URL validation pattern
- * @property {Object} PASSWORD Password-related regex patterns
- * @property {RegExp} PASSWORD.CHAR8_ONE_OF_EACH At least 8 chars with lower, upper, number, and special char
- * @memberOf module:decorator-validation.Validation
- */
-/**
- * @description Defines the various default regexp patterns used
- * @summary Collection of frequently used validation patterns grouped under semantic keys.
- * @const DEFAULT_PATTERNS
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- * @type {DefaultPatterns}
- */
-export declare const DEFAULT_PATTERNS: {
-    EMAIL: RegExp;
-    URL: RegExp;
-    PASSWORD: {
-        CHAR8_ONE_OF_EACH: RegExp;
-    };
-    asd: string;
-};

package/lib/validation/Validators/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/validation/Validators/constants.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH;;;;;;;GAOG;AACU,QAAA,wBAAwB,GAAG;IACtC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,UAAU;IACrB,kBAAkB,EAAE,iBAAiB;IACrC,YAAY,EAAE,aAAa;IAC3B,qBAAqB,EAAE,oBAAoB;CACnC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACU,QAAA,cAAc,GAAG;IAC5B,OAAO,EAAE,YAAY;IACrB,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,KAAK;IACV,SAAS,EAAE,WAAW;IACtB,IAAI,EAAE,MAAM;IACZ,GAAG,gCAAwB;CACnB,CAAC;AAEX;;;;;;GAMG;AACU,QAAA,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACU,QAAA,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;IAChD,MAAM,EAAE,uCAAuC;IAC/C,IAAI,EAAE,6CAA6C;IACnD,SAAS,EAAE,wCAAwC;IACnD,kBAAkB,EAAE,oDAAoD;IACxE,YAAY,EAAE,2CAA2C;IACzD,qBAAqB,EACnB,uDAAuD;IACzD,MAAM,EAAE,6CAA6C;IACrD,IAAI,EAAE,0CAA0C;CACjD,CAAC;AAEF;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;IACD,GAAG,EAAE,scAAsc;CAC5c,CAAC"}

package/lib/validation/Validators/decorators.d.ts

@@ -1,12 +0,0 @@
-import { Validator } from "./Validator";
-/**
- * @summary Marks the class as a validator for a certain key.
- * @description Registers the class in the {@link Validation} with the provided key
- *
- * @param {string} keys the validation key
- *
- * @function validator
- *
- * @category Class Decorators
- */
-export declare function validator<T extends Validator>(...keys: string[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;