@cleverbrush/schema 1.1.11 → 3.0.0

package/dist/builders/ArraySchemaBuilder.js

@@ -1,284 +1,2 @@
-import { SchemaBuilder } from './SchemaBuilder.js';
-/**
- * Similar to the `Array` type in TypeScript. It can be used to validate arrays of any type.
- * It can also be used to validate arrays of specific type.
- * For example, if you want to validate an array of numbers,
- * you can use `array(number())` to create a schema builder.
- * If you want to validate an array of users, you can use
- * `array().of(object({ name: string(), age: number() }))` to create a schema builder.
- * If you want to validate an array of numbers or strings,
- * you can use `array(union(number()).or(string()))`.
- *
- * Also you can limit the length of the array by using `minLength`
- * and `maxLength` methods.
- *
- * **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 array | array()} function instead.
- * @see {@link array}
- */
-export class ArraySchemaBuilder extends SchemaBuilder {
-    #minLength;
-    #maxLength;
-    #elementSchema;
-    /**
-     * @hidden
-     */
-    static create(props) {
-        return new ArraySchemaBuilder({
-            type: 'array',
-            ...props
-        });
-    }
-    constructor(props) {
-        super(props);
-        if (typeof props.minLength === 'number') {
-            this.#minLength = props.minLength;
-        }
-        if (typeof props.maxLength === 'number') {
-            this.#maxLength = props.maxLength;
-        }
-        if (props.elementSchema instanceof SchemaBuilder) {
-            this.#elementSchema = props.elementSchema;
-        }
-    }
-    /**
-     * @hidden
-     */
-    hasType(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    notUsed) {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * @hidden
-     */
-    clearHasType() {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * Performs validion of the schema over `object`. Basically runs
-     * validators, preprocessors and checks for required (if schema is not optional).
-     * @param context Optional `ValidationContext` settings.
-     */
-    async validate(object, context) {
-        const superResult = await super.preValidate(object, context);
-        const { valid, context: prevalidationContext, errors, transaction: preValidationTransaction } = 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 (!Array.isArray(objToValidate)) {
-            return {
-                valid: false,
-                errors: [{ message: 'array expected', path: path }]
-            };
-        }
-        if (typeof this.#maxLength === 'number' &&
-            objToValidate.length > this.#maxLength) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `cannot contain more than ${this.#maxLength} elements`,
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (typeof this.#minLength === 'number' &&
-            objToValidate.length < this.#minLength) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `cannot contain less than ${this.#minLength} elements`,
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (objToValidate.length > 0 &&
-            this.#elementSchema instanceof SchemaBuilder) {
-            if (prevalidationContext.doNotStopOnFirstError) {
-                const results = await Promise.all(objToValidate.map((o) => this.#elementSchema?.validate(o, prevalidationContext)));
-                let valid = true;
-                for (let i = 0; i < results.length; i++) {
-                    if (!results[i]?.valid) {
-                        valid = false;
-                    }
-                }
-                return Object.assign({
-                    valid
-                }, valid
-                    ? {}
-                    : {
-                        errors: results
-                            .map((r) => r?.errors)
-                            .filter((r) => r)
-                            .map((e) => e?.map((r, index) => ({
-                            ...r,
-                            path: `${r.path}[${index}]`
-                        })))
-                            .flat()
-                    }, valid
-                    ? {
-                        object: results.map((r) => r?.object)
-                    }
-                    : {});
-            }
-            else {
-                for (let i = 0; i < objToValidate.length; i++) {
-                    const { valid, errors, object: validatedItem } = await this.#elementSchema.validate(objToValidate[i], {
-                        ...prevalidationContext,
-                        path: `${path}[${i}]`
-                    });
-                    if (valid) {
-                        objToValidate[i] = validatedItem;
-                    }
-                    else {
-                        return {
-                            valid: false,
-                            errors: Array.isArray(errors) && errors.length > 0
-                                ? [errors[0]]
-                                : []
-                        };
-                    }
-                }
-            }
-        }
-        return {
-            valid: true,
-            object: objToValidate
-        };
-    }
-    /**
-     * @hidden
-     */
-    createFromProps(props) {
-        return ArraySchemaBuilder.create(props);
-    }
-    /**
-     * @hidden
-     */
-    required() {
-        return super.required();
-    }
-    /**
-     * @hidden
-     */
-    optional() {
-        return super.optional();
-    }
-    introspect() {
-        return {
-            ...super.introspect(),
-            /**
-             * Schema of array item (if defined)
-             */
-            elementSchema: this.#elementSchema,
-            /**
-             * Min length of a valid array
-             */
-            minLength: this.#minLength,
-            /**
-             * Max length of a valid array
-             */
-            maxLength: this.#maxLength
-        };
-    }
-    /**
-     * Set a schema that every array item has to satisfy. If it is not set,
-     * Item of any type is allowed.
-     * @param schema Schema that every array item has to satisfy
-     */
-    of(schema) {
-        return ArraySchemaBuilder.create({
-            ...this.introspect(),
-            elementSchema: schema
-        });
-    }
-    clearOf() {
-        return ArraySchemaBuilder.create({
-            ...this.introspect(),
-            elementSchema: undefined
-        });
-    }
-    /**
-     * Set minimal length of the valid array value for schema.
-     */
-    minLength(length) {
-        if (typeof length !== 'number' || length < 0)
-            throw new Error('length is expected to be a number which is >= 0');
-        return ArraySchemaBuilder.create({
-            ...this.introspect(),
-            minLength: length
-        });
-    }
-    /**
-     * Clear minimal length of the valid array value for schema.
-     */
-    clearMinLength() {
-        const schema = this.introspect();
-        delete schema.minLength;
-        return this.createFromProps({
-            ...schema
-        });
-    }
-    /**
-     * Set max length of the valid array value for schema.
-     */
-    maxLength(length) {
-        if (typeof length !== 'number' || length < 0)
-            throw new Error('length is expected to be a number which is >= 0');
-        return ArraySchemaBuilder.create({
-            ...this.introspect(),
-            maxLength: length
-        });
-    }
-    /**
-     * Clear max length of the valid array value for schema.
-     */
-    clearMaxLength() {
-        const schema = this.introspect();
-        delete schema.maxLength;
-        return this.createFromProps({
-            ...schema
-        });
-    }
-}
-/**
- * Creates a `Array` schema.
- *
- * @example
- * ```typescript
- *  const schema = array().minLength(2).maxLength(5).of(string());
- *  // [] - invalid
- *  // ['a', 'b'] - valid
- *  // ['a', 'b', 'c', 'd', 'e', 'f'] - invalid
- *  // ['a', 'b', 'c', 'd', 'e'] - valid
- *  // ['a', 'b', 'c', 'd', 1] - invalid
- *  // ['a', 'b', null] - invalid
- *  // null - invalid
- *  // undefined - invalid
- * ```
- */
-export const array = (elementSchema) => ArraySchemaBuilder.create({
-    isRequired: true,
-    elementSchema
-});
+import{a,b}from"../chunk-NUW3VXZV.js";import"../chunk-3JMDGYDT.js";export{a as ArraySchemaBuilder,b as array};
+//# sourceMappingURL=ArraySchemaBuilder.js.map

package/dist/builders/ArraySchemaBuilder.js.map

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

package/dist/builders/BooleanSchemaBuilder.d.ts

@@ -1,4 +1,4 @@
-import { SchemaBuilder, ValidationResult, ValidationContext } from './SchemaBuilder.js';
+import { type BRAND, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
 type BooleanSchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<BooleanSchemaBuilder<R>['introspect']>>;
 /**
  * Similar to `boolean` type in TypeScript.
@@ -11,58 +11,148 @@ type BooleanSchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnT
  *
  * @example ```ts
  * const schema = boolean().equals(true);
- * const result = await schema.validate(true);
+ * const result = schema.validate(true);
  * // result.valid === true
  * // result.object === true
  * ```
  * @example ```ts
  * const schema = boolean().equals(false);
- * const result = await schema.validate(true);
+ * const result = schema.validate(true);
  * // result.valid === false
  * // result.errors[0].message === 'is expected to be equal to 'false''
  * ```
  * @example ```ts
  * const schema = boolean().equals(true).optional();
- * const result = await schema.validate(undefined);
+ * const result = schema.validate(undefined);
  * // result.valid === true
  * // result.object === undefined
  * ```
  *
  * @see {@link boolean}
  */
-export declare class BooleanSchemaBuilder<TResult = boolean, TRequired extends boolean = true, TExplicitType = undefined, TFinalResult = TExplicitType extends undefined ? TResult : TExplicitType> extends SchemaBuilder<TFinalResult, TRequired> {
+export declare class BooleanSchemaBuilder<TResult = boolean, TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TFinalResult = TExplicitType extends undefined ? TResult : TExplicitType> extends SchemaBuilder<TFinalResult, TRequired, TNullable, THasDefault, TExtensions> {
     #private;
-    static create(props: BooleanSchemaBuilderCreateProps<any>): BooleanSchemaBuilder<boolean, any, undefined, boolean>;
-    private constructor();
+    /**
+     * @hidden
+     */
+    static create(props: BooleanSchemaBuilderCreateProps<any>): BooleanSchemaBuilder<boolean, any, false, undefined, false, {}, boolean>;
+    protected constructor(props: BooleanSchemaBuilderCreateProps<TRequired>);
     introspect(): {
         /**
          * If set, restrict object to be equal to a certain value.
          */
         equalsTo: boolean | undefined;
+        /**
+         * Equals to validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        equalsToValidationErrorMessageProvider: ValidationErrorMessageProvider<BooleanSchemaBuilder<TResult, TRequired, false, undefined, false, {}, TResult>>;
         type: string;
         isRequired: boolean;
-        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TFinalResult>[];
-        validators: readonly import("./SchemaBuilder.js").Validator<TFinalResult>[];
+        isNullable: boolean;
+        isReadonly: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").PreprocessorEntry<TFinalResult>[];
+        validators: readonly import("./SchemaBuilder.js").ValidatorEntry<TFinalResult>[];
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TFinalResult | (() => TFinalResult) | undefined;
+        description: string | undefined;
+        schemaName: string | undefined;
+        hasCatch: boolean;
+        catchValue: TFinalResult | (() => TFinalResult) | undefined;
+        example: unknown;
     };
-    hasType<T>(notUsed?: T): BooleanSchemaBuilder<TResult, true, T>;
-    clearHasType(): BooleanSchemaBuilder<TResult, TRequired, undefined>;
     /**
-     * Performs validion of the schema over `object`. Basically runs
-     * validators, preprocessors and checks for required (if schema is not optional).
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): BooleanSchemaBuilder<TResult, true, TNullable, T, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): BooleanSchemaBuilder<TResult, TRequired, TNullable, undefined, 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 the schema over `object`.
+     * Throws if any preprocessor, validator, or error message provider returns a Promise.
      * @param context Optional `ValidationContext` settings.
      */
-    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected _validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /**
+     * Performs async validation of the schema over `object`.
+     * Supports async preprocessors, validators, and error message providers.
+     * @param context Optional `ValidationContext` settings.
+     */
+    protected _validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
     protected createFromProps<TReq extends boolean>(props: BooleanSchemaBuilderCreateProps<TReq>): this;
-    required(): BooleanSchemaBuilder<TResult, true, TExplicitType>;
-    optional(): BooleanSchemaBuilder<TResult, false, TExplicitType>;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): BooleanSchemaBuilder<TResult, true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): BooleanSchemaBuilder<TResult, false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TFinalResult | (() => TFinalResult)): BooleanSchemaBuilder<TResult, true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): BooleanSchemaBuilder<TResult, TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): BooleanSchemaBuilder<TResult, TRequired, TNullable, TFinalResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<boolean>`. Since booleans are
+     * already immutable this is an identity operation, but it sets the
+     * `isReadonly` introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): BooleanSchemaBuilder<TResult, TRequired, TNullable, Readonly<TFinalResult>, THasDefault, TExtensions> & TExtensions;
     /**
      * Restricts object to be equal to `value`.
      */
-    equals<T extends boolean>(value: T): BooleanSchemaBuilder<T, TRequired, TExplicitType>;
+    equals<T extends boolean>(value: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<BooleanSchemaBuilder<TResult, TRequired>>): BooleanSchemaBuilder<T, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Removes a `value` defined by `equals()` call.
+     */
+    clearEquals(): BooleanSchemaBuilder<boolean, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Adds a preprocessor that coerces a string value to a boolean.
+     * Accepts `"true"` → `true` and `"false"` → `false`; other values are
+     * left unchanged so the boolean schema rejects them.
+     *
+     * @example ```ts
+     * const schema = boolean().coerce();
+     * const result = schema.validate('true');
+     * // result.valid === true
+     * // result.object === true
+     * ```
+     */
+    coerce(): BooleanSchemaBuilder<TResult, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): BooleanSchemaBuilder<TResult, TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
     /**
-     * Removes a `value` defeined by `equals()` call.
+     * @hidden
      */
-    clearEquals(): BooleanSchemaBuilder<boolean, TRequired, TExplicitType>;
+    notNullable(): BooleanSchemaBuilder<TResult, TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
 }
 /**
  * Creates a `boolean` schema.

package/dist/builders/BooleanSchemaBuilder.js

@@ -1,150 +1,2 @@
-import { SchemaBuilder } from './SchemaBuilder.js';
-/**
- * Similar to `boolean` type in TypeScript.
- * Allows to define a schema for a boolean value. It can be required or optional.
- * It can be restricted to be equal to a certain value.
- *
- * **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 boolean | boolean()} function instead.
- *
- * @example ```ts
- * const schema = boolean().equals(true);
- * const result = await schema.validate(true);
- * // result.valid === true
- * // result.object === true
- * ```
- * @example ```ts
- * const schema = boolean().equals(false);
- * const result = await schema.validate(true);
- * // result.valid === false
- * // result.errors[0].message === 'is expected to be equal to 'false''
- * ```
- * @example ```ts
- * const schema = boolean().equals(true).optional();
- * const result = await schema.validate(undefined);
- * // result.valid === true
- * // result.object === undefined
- * ```
- *
- * @see {@link boolean}
- */
-export class BooleanSchemaBuilder extends SchemaBuilder {
-    #equalsTo;
-    static create(props) {
-        return new BooleanSchemaBuilder({
-            type: 'boolean',
-            ...props
-        });
-    }
-    constructor(props) {
-        super(props);
-        if (typeof props.equalsTo === 'boolean' ||
-            typeof props.equalsTo === 'undefined') {
-            this.#equalsTo = props.equalsTo;
-        }
-    }
-    introspect() {
-        return {
-            ...super.introspect(),
-            /**
-             * If set, restrict object to be equal to a certain value.
-             */
-            equalsTo: this.#equalsTo
-        };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    hasType(notUsed) {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    clearHasType() {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * Performs validion of the schema over `object`. Basically runs
-     * validators, preprocessors and checks for required (if schema is not optional).
-     * @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 !== 'boolean') {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: 'expected to be boolean',
-                        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
-                    }
-                ]
-            };
-        }
-        return {
-            valid: true,
-            object: objToValidate
-        };
-    }
-    createFromProps(props) {
-        return BooleanSchemaBuilder.create(props);
-    }
-    required() {
-        return super.required();
-    }
-    optional() {
-        return super.optional();
-    }
-    /**
-     * Restricts object to be equal to `value`.
-     */
-    equals(value) {
-        if (typeof value !== 'boolean')
-            throw new Error('boolean expected');
-        return this.createFromProps({
-            ...this.introspect(),
-            equalsTo: value
-        });
-    }
-    /**
-     * Removes a `value` defeined by `equals()` call.
-     */
-    clearEquals() {
-        return this.createFromProps({
-            ...this.introspect(),
-            equalsTo: undefined
-        });
-    }
-}
-/**
- * Creates a `boolean` schema.
- */
-export const boolean = () => BooleanSchemaBuilder.create({
-    isRequired: true
-});
+import{a,b}from"../chunk-CFIJQ4GP.js";import"../chunk-3JMDGYDT.js";export{a as BooleanSchemaBuilder,b as boolean};
+//# sourceMappingURL=BooleanSchemaBuilder.js.map

package/dist/builders/BooleanSchemaBuilder.js.map

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