@cleverbrush/schema 1.1.11 → 3.0.0

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-BUEVZ3KA.js";import"../chunk-3JMDGYDT.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":[]}