@cleverbrush/schema 1.1.11 → 3.0.0

package/dist/builders/AnySchemaBuilder.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 AnySchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<AnySchemaBuilder<R>['introspect']>>;
 /**
  * Any schema builder class. Similar to the `any` type
@@ -12,40 +12,80 @@ type AnySchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<
  * @example
  * ```ts
  * const schema = any();
- * const result = await schema.validate(123);
+ * const result = schema.validate(123);
  * // result.valid === true
  * // result.object === 123
  * ```
  */
-export declare class AnySchemaBuilder<TRequired extends boolean = true, TExplicitType = undefined, TResult = TExplicitType extends undefined ? any : TExplicitType> extends SchemaBuilder<TResult, TRequired> {
+export declare class AnySchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TResult = TExplicitType extends undefined ? any : TExplicitType> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
     /**
      * @hidden
      */
-    static create(props: AnySchemaBuilderCreateProps<any>): AnySchemaBuilder<true, undefined, any>;
-    private constructor();
+    static create(props: AnySchemaBuilderCreateProps<any>): AnySchemaBuilder<true, false, undefined, false, {}, any>;
+    protected constructor(props: AnySchemaBuilderCreateProps<TRequired>);
     /**
-     * @hidden
+     * @inheritdoc
      */
-    hasType<T>(notUsed?: T): AnySchemaBuilder<true, T>;
+    hasType<T>(_notUsed?: T): AnySchemaBuilder<true, TNullable, T, THasDefault, TExtensions> & TExtensions;
     /**
-     * @hidden
+     * @inheritdoc
+     */
+    clearHasType(): AnySchemaBuilder<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.
      */
-    clearHasType(): AnySchemaBuilder<TRequired, undefined>;
+    protected _validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
     /**
-     * Performs validation of the schema over `object`. Basically runs
-     * validators, preprocessors and checks for required (if schema is not optional).
+     * Performs async validation of the 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<TReq extends boolean>(props: AnySchemaBuilderCreateProps<TReq>): this;
     /**
      * @hidden
      */
-    required(): AnySchemaBuilder<true, TExplicitType>;
+    required(errorMessage?: ValidationErrorMessageProvider): AnySchemaBuilder<true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): AnySchemaBuilder<false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): AnySchemaBuilder<true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): AnySchemaBuilder<TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): AnySchemaBuilder<TRequired, TNullable, TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<T>`. Sets the `isReadonly`
+     * introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): AnySchemaBuilder<TRequired, TNullable, Readonly<TResult>, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): AnySchemaBuilder<TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
     /**
      * @hidden
      */
-    optional(): AnySchemaBuilder<false, TExplicitType>;
+    notNullable(): AnySchemaBuilder<TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
 }
 /**
  * Creates a `any` schema.

package/dist/builders/AnySchemaBuilder.js

@@ -1,112 +1,2 @@
-import { SchemaBuilder } from './SchemaBuilder.js';
-/**
- * Any schema builder class. Similar to the `any` type
- * in TypeScript. Allows to define a schema for `any` value.
- * Use it when you don't know the type of the 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 `any()` function instead.
- *
- * @example
- * ```ts
- * const schema = any();
- * const result = await schema.validate(123);
- * // result.valid === true
- * // result.object === 123
- * ```
- */
-export class AnySchemaBuilder extends SchemaBuilder {
-    /**
-     * @hidden
-     */
-    static create(props) {
-        return new AnySchemaBuilder({
-            type: 'any',
-            ...props
-        });
-    }
-    constructor(props) {
-        super(props);
-    }
-    /**
-     * @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 validation 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, transaction: preValidationTransaction, errors } = superResult;
-        if (!valid) {
-            return {
-                valid,
-                errors
-            };
-        }
-        const { object: { validatedObject: objToValidate } } = preValidationTransaction;
-        return {
-            valid: true,
-            object: objToValidate
-        };
-    }
-    createFromProps(props) {
-        return AnySchemaBuilder.create(props);
-    }
-    /**
-     * @hidden
-     */
-    required() {
-        return super.required();
-    }
-    /**
-     * @hidden
-     */
-    optional() {
-        return super.optional();
-    }
-}
-/**
- * Creates a `any` schema.
- * @example
- * ```
- *  const anyObject = any();
- *
- * // null - invalid
- * // undefined - invalid
- * // string - valid
- * // {} - valid
- * // Date -valid
- * // { someProp: 123 } - valid
- * // etc
- * ```
- * @example
- * ```
- *  const anyObject = any().optional();
- *  // null - valid
- *  // undefined - valid
- *  // string - valid
- *  // {} - valid
- *  // Date -valid
- *  // { someProp: 123 } - valid
- * ```
- */
-export const any = () => AnySchemaBuilder.create({
-    isRequired: true
-});
+import{a,b}from"../chunk-HN774HD7.js";import"../chunk-3JMDGYDT.js";export{a as AnySchemaBuilder,b as any};
+//# sourceMappingURL=AnySchemaBuilder.js.map

package/dist/builders/AnySchemaBuilder.js.map

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

package/dist/builders/ArraySchemaBuilder.d.ts

@@ -1,5 +1,29 @@
-import { SchemaBuilder, ValidationResult, ValidationContext, InferType } from './SchemaBuilder.js';
-type ArraySchemaBuilderCreateProps<TElementSchema extends SchemaBuilder<any, any>, R extends boolean = true> = Partial<ReturnType<ArraySchemaBuilder<TElementSchema, R>['introspect']>>;
+import type { ObjectSchemaBuilder, ObjectSchemaValidationResult } from './ObjectSchemaBuilder.js';
+import { type BRAND, type InferType, type NestedValidationResult, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+import type { UnionSchemaBuilder, UnionSchemaValidationResult } from './UnionSchemaBuilder.js';
+/**
+ * Maps an element schema type to the appropriate validation result type.
+ * Union schema elements get `UnionSchemaValidationResult`,
+ * Object schema elements get `ObjectSchemaValidationResult`,
+ * other types get `ValidationResult`.
+ */
+export type ElementValidationResult<TElementSchema extends SchemaBuilder<any, any, any, any, any>> = TElementSchema extends UnionSchemaBuilder<infer UOptions extends readonly SchemaBuilder<any, any, any, any, any>[], any, any> ? UnionSchemaValidationResult<InferType<TElementSchema>, UOptions> : TElementSchema extends ObjectSchemaBuilder<any, any, any, any, any> ? ObjectSchemaValidationResult<InferType<TElementSchema>, TElementSchema> : ValidationResult<InferType<TElementSchema>>;
+/**
+ * Validation result type returned by `ArraySchemaBuilder.validate()`.
+ * Extends `ValidationResult` with `getNestedErrors` for root-level array
+ * errors and per-element validation results.
+ */
+export type ArraySchemaValidationResult<TResult, TElementSchema extends SchemaBuilder<any, any, any, any, any>> = ValidationResult<TResult> & {
+    /**
+     * Returns root-level array validation errors combined with
+     * per-element validation results.
+     * The returned value has both `NestedValidationResult` properties
+     * (`errors`, `isValid`, `descriptor`, `seenValue`) and indexed
+     * element results (`[0]`, `[1]`, etc.).
+     */
+    getNestedErrors(): Array<ElementValidationResult<TElementSchema>> & NestedValidationResult<any, any, any>;
+};
+type ArraySchemaBuilderCreateProps<TElementSchema extends SchemaBuilder<any, any, any, any, any>, R extends boolean = true> = Partial<ReturnType<ArraySchemaBuilder<TElementSchema, R>['introspect']>>;
 /**
  * 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.
@@ -18,27 +42,41 @@ type ArraySchemaBuilderCreateProps<TElementSchema extends SchemaBuilder<any, any
  * directly. Use {@link array | array()} function instead.
  * @see {@link array}
  */
-export declare class ArraySchemaBuilder<TElementSchema extends SchemaBuilder<any, any>, TRequired extends boolean = true, TExplicitType = undefined, TResult = TExplicitType extends undefined ? TElementSchema extends undefined ? Array<any> : TElementSchema extends SchemaBuilder<infer T1, infer T2> ? Array<InferType<SchemaBuilder<T1, T2>>> : never : TExplicitType> extends SchemaBuilder<TResult, TRequired> {
+export declare class ArraySchemaBuilder<TElementSchema extends SchemaBuilder<any, any, any, any, any>, TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TResult = TExplicitType extends undefined ? TElementSchema extends undefined ? Array<any> : TElementSchema extends SchemaBuilder<infer T1, infer T2> ? Array<InferType<SchemaBuilder<T1, T2>>> : never : TExplicitType> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
     #private;
     /**
      * @hidden
      */
-    static create(props: ArraySchemaBuilderCreateProps<any, any>): ArraySchemaBuilder<SchemaBuilder<any, any>, true, undefined, any[]>;
-    private constructor();
+    static create(props: ArraySchemaBuilderCreateProps<any, any>): ArraySchemaBuilder<SchemaBuilder<any, any, any, any, any>, true, false, undefined, false, {}, any[]>;
+    protected constructor(props: ArraySchemaBuilderCreateProps<TElementSchema, TRequired>);
     /**
-     * @hidden
+     * @inheritdoc
      */
-    hasType<T>(notUsed?: T): ArraySchemaBuilder<TElementSchema, true, T>;
+    hasType<T>(_notUsed?: T): ArraySchemaBuilder<TElementSchema, true, TNullable, T, THasDefault, TExtensions> & TExtensions;
     /**
-     * @hidden
+     * @inheritdoc
      */
-    clearHasType(): ArraySchemaBuilder<TElementSchema, TRequired, undefined>;
+    clearHasType(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, undefined, THasDefault, TExtensions> & TExtensions;
     /**
-     * Performs validion of the schema over `object`. Basically runs
-     * validators, preprocessors and checks for required (if schema is not optional).
+     * Performs synchronous validation of the schema over `object`. {@inheritDoc SchemaBuilder.validate}
+     */
+    validate(object: TResult, context?: ValidationContext): ArraySchemaValidationResult<TResult, TElementSchema>;
+    /**
+     * Performs asynchronous validation of the schema over `object`. {@inheritDoc SchemaBuilder.validateAsync}
+     */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<ArraySchemaValidationResult<TResult, TElementSchema>>;
+    /**
+     * 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): ArraySchemaValidationResult<TResult, TElementSchema>;
+    /**
+     * 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<ArraySchemaValidationResult<TResult, TElementSchema>>;
     /**
      * @hidden
      */
@@ -46,11 +84,33 @@ export declare class ArraySchemaBuilder<TElementSchema extends SchemaBuilder<any
     /**
      * @hidden
      */
-    required(): ArraySchemaBuilder<TElementSchema, true, TExplicitType>;
+    required(errorMessage?: ValidationErrorMessageProvider): ArraySchemaBuilder<TElementSchema, true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): ArraySchemaBuilder<TElementSchema, false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): ArraySchemaBuilder<TElementSchema, true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
     /**
      * @hidden
      */
-    optional(): ArraySchemaBuilder<TElementSchema, false, TExplicitType>;
+    clearDefault(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `ReadonlyArray<T>` — disables `push`,
+     * `pop`, and other mutating methods at the type level. Validation
+     * behaviour is unchanged.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, ReadonlyArray<TElementSchema extends SchemaBuilder<infer T1, infer T2> ? InferType<SchemaBuilder<T1, T2>> : any>, THasDefault, TExtensions> & TExtensions;
     introspect(): {
         /**
          * Schema of array item (if defined)
@@ -60,38 +120,81 @@ export declare class ArraySchemaBuilder<TElementSchema extends SchemaBuilder<any
          * Min length of a valid array
          */
         minLength: number | undefined;
+        /**
+         * Min length validation error message provider.
+         * If not provided, default error message provider is used.
+         */
+        minLengthValidationErrorMessageProvider: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, false, {}, TExplicitType extends undefined ? TElementSchema extends undefined ? any[] : TElementSchema extends SchemaBuilder<infer T1, infer T2 extends boolean, false, false, {}> ? (T2 extends true ? T1 : T1 | undefined)[] : never : TExplicitType>>;
         /**
          * Max length of a valid array
          */
         maxLength: number | undefined;
+        /**
+         * Max length validation error message provider.
+         * If not provided, default error message provider is used.
+         */
+        maxLengthValidationErrorMessageProvider: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, false, {}, TExplicitType extends undefined ? TElementSchema extends undefined ? any[] : TElementSchema extends SchemaBuilder<infer T1, infer T2 extends boolean, false, false, {}> ? (T2 extends true ? T1 : T1 | undefined)[] : never : TExplicitType>>;
         type: string;
         isRequired: boolean;
-        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TResult>[];
-        validators: readonly import("./SchemaBuilder.js").Validator<TResult>[];
+        isNullable: boolean;
+        isReadonly: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").PreprocessorEntry<TResult>[];
+        validators: readonly import("./SchemaBuilder.js").ValidatorEntry<TResult>[];
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TResult | (() => TResult) | undefined;
+        description: string | undefined;
+        schemaName: string | undefined;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
+        example: unknown;
     };
     /**
      * 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<TSchema extends SchemaBuilder<any, any>>(schema: TSchema): ArraySchemaBuilder<TSchema, TRequired, TExplicitType>;
-    clearOf(): ArraySchemaBuilder<any, TRequired, TExplicitType>;
+    of<TSchema extends SchemaBuilder<any, any, any, any, any>>(schema: TSchema): ArraySchemaBuilder<TSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Clears the element schema set by `of()`. After this call,
+     * array items of any type will be accepted.
+     */
+    clearOf(): ArraySchemaBuilder<any, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
     /**
      * Set minimal length of the valid array value for schema.
      */
-    minLength<T extends number>(length: T): ArraySchemaBuilder<TElementSchema, TRequired, TExplicitType>;
+    minLength<T extends number>(length: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType>>): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear minimal length of the valid array value for schema.
      */
-    clearMinLength(): ArraySchemaBuilder<TElementSchema, TRequired, TExplicitType>;
+    clearMinLength(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
     /**
      * Set max length of the valid array value for schema.
      */
-    maxLength<T extends number>(length: T): ArraySchemaBuilder<TElementSchema, TRequired, TExplicitType>;
+    maxLength<T extends number>(length: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType>>): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear max length of the valid array value for schema.
      */
-    clearMaxLength(): ArraySchemaBuilder<TElementSchema, TRequired, TExplicitType>;
+    clearMaxLength(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): ArraySchemaBuilder<TElementSchema, TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): ArraySchemaBuilder<TElementSchema, TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
 }
 /**
  * Creates a `Array` schema.
@@ -109,5 +212,5 @@ export declare class ArraySchemaBuilder<TElementSchema extends SchemaBuilder<any
  *  // undefined - invalid
  * ```
  */
-export declare const array: <TElementSchema extends SchemaBuilder<any, any>>(elementSchema?: TElementSchema) => ArraySchemaBuilder<TElementSchema, true>;
+export declare const array: <TElementSchema extends SchemaBuilder<any, any, any, any, any>>(elementSchema?: TElementSchema) => ArraySchemaBuilder<TElementSchema, true>;
 export {};