@cleverbrush/schema 1.1.10 → 2.0.0

package/dist/builders/NumberSchemaBuilder.d.ts

@@ -1,5 +1,5 @@
-import { Preprocessor, SchemaBuilder, ValidationResult, ValidationContext, Validator } from './SchemaBuilder.js';
-type NumberSchemaBuilderCreateProps<T = number, R extends boolean = true> = Partial<ReturnType<NumberSchemaBuilder<T, R>['introspect']>>;
+import { type BRAND, type PreprocessorEntry, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult, type ValidatorEntry } from './SchemaBuilder.js';
+type NumberSchemaBuilderCreateProps<T = number, R extends boolean = true> = Partial<ReturnType<NumberSchemaBuilder<T, R, any>['introspect']>>;
 /**
  * Number schema builder class. Allows to create Number schemas.
  * Can be required or optional, can be restricted to be equal to a certain value,
@@ -11,143 +11,255 @@ type NumberSchemaBuilderCreateProps<T = number, R extends boolean = true> = Part
  *
  * @example ```ts
  * const schema = number().equals(42);
- * const result = await schema.validate(42);
+ * const result = schema.validate(42);
  * // result.valid === true
  * // result.object === 42
  * ```
  * @example ```ts
  * const schema = number();
- * const result = await schema.validate('42');
+ * const result = schema.validate('42');
  * // result.valid === false
  * // result.errors[0].message === 'is expected to be a number'
  * ```
  * @example ```ts
  * const schema = number().min(0).max(100);
- * const result = await schema.validate(42);
+ * const result = schema.validate(42);
  * // result.valid === true
  * // result.object === 42
  * ```
  *
  * @example ```ts
  * const schema = number().min(0).max(100);
- * const result = await schema.validate(142.5);
+ * const result = schema.validate(142.5);
  * // result.valid === false
  * // result.errors[0].message === 'is expected to be less than or equal to 100'
  * ```
  *
  * @see {@link number}
  */
-export declare class NumberSchemaBuilder<TResult = number, TRequired extends boolean = true> extends SchemaBuilder<TResult, TRequired> {
+export declare class NumberSchemaBuilder<TResult = number, TRequired extends boolean = true, TNullable extends boolean = false, THasDefault extends boolean = false, TExtensions = {}> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
     #private;
-    static create(props: NumberSchemaBuilderCreateProps): NumberSchemaBuilder<number, true>;
-    private constructor();
+    /**
+     * @hidden
+     */
+    static create(props: NumberSchemaBuilderCreateProps): NumberSchemaBuilder<number, true, false, false, {}>;
+    protected constructor(props: NumberSchemaBuilderCreateProps);
     introspect(): {
         /**
          * Min valid value (if defined).
          */
         min: number | undefined;
+        /**
+         * Min valid value error message provider.
+         * If not provided, default error message will be used.
+         */
+        minValidationErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Max valid value (if defined).
          */
         max: number | undefined;
+        /**
+         * Max valid value error message provider.
+         * If not provided, default error message will be used.
+         */
+        maxValidationErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Make sure that object is not `NaN`. `true` by default.
          */
         ensureNotNaN: boolean;
+        /**
+         * EnsureNotNaN error message provider.
+         * If not provided, default error message will be used.
+         */
+        ensureNotNaNErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Make sure that object is not different kinds of `infinity`. `true` by default.
          */
         ensureIsFinite: boolean;
+        /**
+         * EnsureIsFinite error message provider.
+         */
+        ensureIsFiniteErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * If set, restrict object to be equal to a certain value.
          */
         equalsTo: number | undefined;
+        /**
+         * EqualsTo error message provider.
+         * If not provided, default error message will be used.
+         */
+        equalsToValidationErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Allow only integer values (floating point values will be rejected
          * as invalid)
          */
         isInteger: boolean;
+        /**
+         * EnsureIsInteger error message provider.
+         */
+        ensureIsIntegerErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Array of preprocessor functions
          */
-        preprocessors: Preprocessor<TResult>[];
+        preprocessors: PreprocessorEntry<TResult>[];
         /**
          * Array of validator functions
          */
-        validators: Validator<TResult>[];
+        validators: ValidatorEntry<TResult>[];
         type: string;
         isRequired: boolean;
+        isNullable: boolean;
+        isReadonly: boolean;
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TResult | (() => TResult) | undefined;
+        description: string | undefined;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
     };
     /**
-     * @hidden
+     * @inheritdoc
      */
-    hasType<T>(notUsed?: T): NumberSchemaBuilder<T, true>;
+    hasType<T>(_notUsed?: T): NumberSchemaBuilder<T, true, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
-     * @hidden
+     * @inheritdoc
+     */
+    clearHasType(): NumberSchemaBuilder<number, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /** {@inheritDoc SchemaBuilder.validate} */
+    validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /** {@inheritDoc SchemaBuilder.validateAsync} */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    /**
+     * Performs synchronous validation of number schema over `object`.
+     * Throws if any preprocessor, validator, or error message provider returns a Promise.
+     * @param context Optional `ValidationContext` settings.
      */
-    clearHasType(): NumberSchemaBuilder<number, TRequired>;
+    protected _validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
     /**
-     * Performs validion of number schema over `object`.
+     * Performs async validation of number schema over `object`.
+     * Supports async preprocessors, validators, and error message providers.
      * @param context Optional `ValidationContext` settings.
      */
-    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected _validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
     protected createFromProps<T, TReq extends boolean>(props: NumberSchemaBuilderCreateProps<T, TReq>): this;
     /**
      * Restricts number to be equal to `value`.
      */
-    equals<T extends number>(value: T): NumberSchemaBuilder<T, TRequired>;
+    equals<T extends number>(value: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<T, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear `equals()` call.
      */
-    clearEquals(): NumberSchemaBuilder<number, TRequired>;
+    clearEquals(): NumberSchemaBuilder<number, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
+     * @deprecated Use {@link clearIsInteger} instead.
      * Float values will be considered as valid after this call.
      */
-    isFloat(): NumberSchemaBuilder<TResult, TRequired>;
+    isFloat(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Clear `isInteger()` call.
+     */
+    clearIsInteger(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Only integer values will be considered as valid after this call.
      */
-    isInteger(): NumberSchemaBuilder<TResult, TRequired>;
+    isInteger(
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * @hidden
      */
-    required(): NumberSchemaBuilder<TResult, true>;
+    required(errorMessage?: ValidationErrorMessageProvider): NumberSchemaBuilder<TResult, true, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * @hidden
      */
-    optional(): NumberSchemaBuilder<TResult, false>;
+    optional(): NumberSchemaBuilder<TResult, false, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): NumberSchemaBuilder<TResult, true, TNullable, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): NumberSchemaBuilder<TResult, TRequired, TNullable, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): NumberSchemaBuilder<TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<number>`. Since numbers are
+     * already immutable this is an identity operation, but it sets the
+     * `isReadonly` introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): NumberSchemaBuilder<Readonly<TResult>, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Do not accept NaN value
      */
-    notNaN(): NumberSchemaBuilder<TResult, TRequired>;
+    notNaN(
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Consider NaN value as valid
      */
-    canBeNaN(): NumberSchemaBuilder<TResult, TRequired>;
+    canBeNaN(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Do not accept `Infinity`.
      */
-    isFinite(): NumberSchemaBuilder<TResult, TRequired>;
+    isFinite(
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Consider `Infinity` as valid.
      */
-    canBeInfinite(): NumberSchemaBuilder<TResult, TRequired>;
+    canBeInfinite(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Restrict number to be at least `minValue`.
      */
-    min(minValue: number): NumberSchemaBuilder<TResult, TRequired>;
+    min(minValue: number, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear `min()` call.
      */
-    clearMin(): NumberSchemaBuilder<TResult, TRequired>;
+    clearMin(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Restrict number to be no more than `maxValue`.
      */
-    max(maxValue: number): NumberSchemaBuilder<TResult, TRequired>;
+    max(maxValue: number, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear `max()` call.
      */
-    clearMax(): NumberSchemaBuilder<TResult, TRequired>;
+    clearMax(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): NumberSchemaBuilder<TResult, TRequired, true, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): NumberSchemaBuilder<TResult, TRequired, false, THasDefault, TExtensions> & TExtensions;
 }
 /**
  * Creates a number schema restricted to `equals` value.

package/dist/builders/NumberSchemaBuilder.js

@@ -1,386 +1,2 @@
-import { SchemaBuilder } from './SchemaBuilder.js';
-/**
- * Number schema builder class. Allows to create Number schemas.
- * Can be required or optional, can be restricted to be equal to a certain value,
- * can be restricted to be in a certain range, can be restricted to be integer.
- *
- * **NOTE** this class is exported only to give opportunity to extend it
- * by inheriting. It is not recommended to create an instance of this class
- * directly. Use {@link number | number()} function instead.
- *
- * @example ```ts
- * const schema = number().equals(42);
- * const result = await schema.validate(42);
- * // result.valid === true
- * // result.object === 42
- * ```
- * @example ```ts
- * const schema = number();
- * const result = await schema.validate('42');
- * // result.valid === false
- * // result.errors[0].message === 'is expected to be a number'
- * ```
- * @example ```ts
- * const schema = number().min(0).max(100);
- * const result = await schema.validate(42);
- * // result.valid === true
- * // result.object === 42
- * ```
- *
- * @example ```ts
- * const schema = number().min(0).max(100);
- * const result = await schema.validate(142.5);
- * // result.valid === false
- * // result.errors[0].message === 'is expected to be less than or equal to 100'
- * ```
- *
- * @see {@link number}
- */
-export class NumberSchemaBuilder extends SchemaBuilder {
-    #min;
-    #max;
-    #equalsTo;
-    #ensureNotNaN = true;
-    #ensureIsFinite = true;
-    #isInteger = true;
-    static create(props) {
-        return new NumberSchemaBuilder({
-            type: 'number',
-            ...props
-        });
-    }
-    constructor(props) {
-        super(props);
-        if (typeof props.min === 'number') {
-            this.#min = props.min;
-        }
-        if (typeof props.max === 'number') {
-            this.#max = props.max;
-        }
-        if (typeof props.ensureNotNaN === 'boolean') {
-            this.#ensureNotNaN = props.ensureNotNaN;
-        }
-        if (typeof props.ensureIsFinite === 'boolean') {
-            this.#ensureIsFinite = props.ensureIsFinite;
-        }
-        if (typeof props.isInteger === 'boolean') {
-            this.#isInteger = props.isInteger;
-        }
-        if (typeof props.equalsTo === 'number' ||
-            typeof props.equalsTo === 'undefined') {
-            this.#equalsTo = props.equalsTo;
-        }
-    }
-    introspect() {
-        return {
-            ...super.introspect(),
-            /**
-             * Min valid value (if defined).
-             */
-            min: this.#min,
-            /**
-             * Max valid value (if defined).
-             */
-            max: this.#max,
-            /**
-             * Make sure that object is not `NaN`. `true` by default.
-             */
-            ensureNotNaN: this.#ensureNotNaN,
-            /**
-             * Make sure that object is not different kinds of `infinity`. `true` by default.
-             */
-            ensureIsFinite: this.#ensureIsFinite,
-            /**
-             * If set, restrict object to be equal to a certain value.
-             */
-            equalsTo: this.#equalsTo,
-            /**
-             * Allow only integer values (floating point values will be rejected
-             * as invalid)
-             */
-            isInteger: this.#isInteger,
-            /**
-             * Array of preprocessor functions
-             */
-            preprocessors: this.preprocessors,
-            /**
-             * Array of validator functions
-             */
-            validators: this.validators
-        };
-    }
-    /**
-     * @hidden
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    hasType(notUsed) {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * @hidden
-     */
-    clearHasType() {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * Performs validion of number schema over `object`.
-     * @param context Optional `ValidationContext` settings.
-     */
-    async validate(object, context) {
-        const superResult = await super.preValidate(object, context);
-        const { valid, context: prevalidationContext, transaction: preValidationTransaction, errors } = superResult;
-        const { path } = prevalidationContext;
-        if (!valid) {
-            return {
-                valid,
-                errors
-            };
-        }
-        const { object: { validatedObject: objToValidate } } = preValidationTransaction;
-        if ((typeof objToValidate === 'undefined' || objToValidate === null) &&
-            this.isRequired === false) {
-            return {
-                valid: true,
-                object: objToValidate
-            };
-        }
-        if (typeof objToValidate !== 'number')
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `expected type number, but saw ${typeof objToValidate}`,
-                        path: path
-                    }
-                ]
-            };
-        if (typeof this.#equalsTo !== 'undefined' &&
-            objToValidate !== this.#equalsTo) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `is expected to be equal to ${this.#equalsTo}`,
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (this.#ensureNotNaN && Number.isNaN(objToValidate)) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: 'is not expected to be NaN',
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (this.#ensureIsFinite &&
-            !Number.isFinite(objToValidate) &&
-            this.#ensureNotNaN &&
-            !Number.isNaN(objToValidate)) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: 'is expected to be a finite number',
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (this.#isInteger &&
-            !Number.isNaN(objToValidate) &&
-            Number.isFinite(objToValidate) &&
-            !Number.isInteger(objToValidate)) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `is expected to be integer`,
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (typeof this.#min !== 'undefined') {
-            if (objToValidate < this.#min)
-                return {
-                    valid: false,
-                    errors: [
-                        {
-                            message: `expected to be at least ${this.#min}`,
-                            path: path
-                        }
-                    ]
-                };
-        }
-        if (typeof this.#max !== 'undefined') {
-            if (objToValidate > this.#max)
-                return {
-                    valid: false,
-                    errors: [
-                        {
-                            message: `expected to be no more than or equal to ${this.#max}`,
-                            path: path
-                        }
-                    ]
-                };
-        }
-        return {
-            valid: true,
-            object: preValidationTransaction.commit().validatedObject
-        };
-    }
-    createFromProps(props) {
-        return NumberSchemaBuilder.create(props);
-    }
-    /**
-     * Restricts number to be equal to `value`.
-     */
-    equals(value) {
-        if (typeof value !== 'number')
-            throw new Error('number expected');
-        return this.createFromProps({
-            ...this.introspect(),
-            equalsTo: value
-        });
-    }
-    /**
-     * Clear `equals()` call.
-     */
-    clearEquals() {
-        return this.createFromProps({
-            ...this.introspect(),
-            equalsTo: undefined
-        });
-    }
-    /**
-     * Float values will be considered as valid after this call.
-     */
-    isFloat() {
-        return this.createFromProps({
-            ...this.introspect(),
-            isInteger: false
-        });
-    }
-    /**
-     * Only integer values will be considered as valid after this call.
-     */
-    isInteger() {
-        return this.createFromProps({
-            ...this.introspect(),
-            isInteger: true
-        });
-    }
-    /**
-     * @hidden
-     */
-    required() {
-        return super.required();
-    }
-    /**
-     * @hidden
-     */
-    optional() {
-        return super.optional();
-    }
-    /**
-     * Do not accept NaN value
-     */
-    notNaN() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureNotNaN: true
-        });
-    }
-    /**
-     * Consider NaN value as valid
-     */
-    canBeNaN() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureNotNaN: false
-        });
-    }
-    /**
-     * Do not accept `Infinity`.
-     */
-    isFinite() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureIsFinite: true
-        });
-    }
-    /**
-     * Consider `Infinity` as valid.
-     */
-    canBeInfinite() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureIsFinite: false
-        });
-    }
-    /**
-     * Restrict number to be at least `minValue`.
-     */
-    min(minValue) {
-        if (typeof minValue !== 'number')
-            throw new Error('minValue must be a number');
-        return this.createFromProps({
-            ...this.introspect(),
-            min: minValue
-        });
-    }
-    /**
-     * Clear `min()` call.
-     */
-    clearMin() {
-        const schema = this.introspect();
-        delete schema.min;
-        return this.createFromProps({
-            ...schema
-        });
-    }
-    /**
-     * Restrict number to be no more than `maxValue`.
-     */
-    max(maxValue) {
-        if (typeof maxValue !== 'number')
-            throw new Error('maxValue must be a number');
-        return this.createFromProps({
-            ...this.introspect(),
-            max: maxValue
-        });
-    }
-    /**
-     * Clear `max()` call.
-     */
-    clearMax() {
-        const schema = this.introspect();
-        delete schema.max;
-        return this.createFromProps({
-            ...schema
-        });
-    }
-}
-/**
- * Creates a number schema.
- */
-export function number(equals) {
-    if (typeof equals === 'number') {
-        return NumberSchemaBuilder.create({
-            isRequired: true,
-            equalsTo: equals
-        });
-    }
-    return NumberSchemaBuilder.create({
-        isRequired: true
-    });
-}
+import{a,b}from"../chunk-KESLT5EE.js";import"../chunk-CTP4RHDG.js";export{a as NumberSchemaBuilder,b as number};
+//# sourceMappingURL=NumberSchemaBuilder.js.map

package/dist/builders/NumberSchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}