@lucania/schema 2.0.4 → 3.0.0

package/build/error/TopLevelValidationError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "./ValidationError";
+import { ValidationPass } from "./ValidationPass";
+export declare class TopLevelValidationError extends ValidationError {
+    constructor(pass: ValidationPass);
+}

package/build/error/ValidationPass.d.ts

@@ -4,14 +4,19 @@ import { ValidationError } from "./ValidationError";
 export declare class ValidationPass {
     readonly originalSchema: BaseSchemaAny;
     readonly originalSource: SourceValue<any, boolean, DefaultValue<any>>;
+    private _parent;
     private _path;
     private _schema;
     private _source;
-    constructor(originalSchema: BaseSchemaAny, originalSource: SourceValue<any, boolean, DefaultValue<any>>);
+    private _errors;
+    constructor(originalSchema: BaseSchemaAny, originalSource: SourceValue<any, boolean, DefaultValue<any>>, parent: ValidationPass | undefined);
     get path(): string[];
     get schema(): BaseSchemaAny;
     get source(): any;
     next(path: string[], schema: BaseSchemaAny, source: SourceValue<any, boolean, DefaultValue<any>>): ValidationPass;
     assert(condition: boolean, message: string): void;
-    getError(message?: string): ValidationError;
+    causeError(message?: string): ValidationError;
+    addError(error: ValidationError): void;
+    get errors(): ValidationError[];
+    get topLevel(): boolean;
 }

package/build/index.js

@@ -13,24 +13,34 @@
         }
     }
 
+    class TopLevelValidationError extends ValidationError {
+        constructor(pass) {
+            super(pass, `Encountered ${pass.errors.length} error(s).\n * ${pass.errors.map((error) => error.message).join("\n * ")}`);
+        }
+    }
+
     class ValidationPass {
         originalSchema;
         originalSource;
+        _parent;
         _path;
         _schema;
         _source;
-        constructor(originalSchema, originalSource) {
+        _errors;
+        constructor(originalSchema, originalSource, parent) {
+            this._parent = parent;
             this.originalSchema = originalSchema;
             this.originalSource = originalSource;
             this._path = [];
             this._schema = originalSchema;
             this._source = originalSource;
+            this._errors = [];
         }
         get path() { return this._path; }
         get schema() { return this._schema; }
         get source() { return this._source; }
         next(path, schema, source) {
-            const nextPass = new ValidationPass(this.originalSchema, this.originalSource);
+            const nextPass = new ValidationPass(this.originalSchema, this.originalSource, this);
             nextPass._path = path;
             nextPass._source = source;
             nextPass._schema = schema;
@@ -38,17 +48,31 @@
         }
         assert(condition, message) {
             if (!condition) {
-                throw this.getError(message);
+                throw this.causeError(message);
             }
         }
-        getError(message) {
+        causeError(message) {
             if (message === undefined) {
-                return this.getError(`Validation failed.`);
+                return this.causeError(`Validation failed.`);
             }
             else {
-                return new ValidationError(this, message);
+                const error = new ValidationError(this, message);
+                this.addError(error);
+                if (this._parent !== undefined) {
+                    this._parent.causeError(error.message);
+                }
+                return error;
             }
         }
+        addError(error) {
+            this._errors.push(error);
+        }
+        get errors() {
+            return this._errors;
+        }
+        get topLevel() {
+            return this._parent === undefined;
+        }
     }
 
     class BaseSchema {
@@ -67,35 +91,49 @@
                 afterAll: []
             } : additionalValidationPasses;
         }
-        validate(source, pass) {
+        validate(source, options, pass) {
             pass = this._ensurePass(source, pass);
             let result = source;
-            result = this._executeAdditionalValidator(result, pass, "beforeAll");
-            result = this._executeAdditionalValidator(result, pass, "beforeDefault");
-            if (!BaseSchema.isPresent(result) && this.hasDefault()) {
-                result = this.getDefault(pass);
-            }
-            result = this._executeAdditionalValidator(result, pass, "afterDefault");
-            result = this._executeAdditionalValidator(result, pass, "beforeConversion");
-            if (BaseSchema.isPresent(result)) {
-                if (BaseSchema.getType(result) !== this.type) {
-                    result = this.convert(result, pass);
+            const presentOptions = {
+                collectErrors: options?.collectErrors || false
+            };
+            try {
+                result = this._executeAdditionalValidator(result, pass, "beforeAll");
+                result = this._executeAdditionalValidator(result, pass, "beforeDefault");
+                if (!BaseSchema.isPresent(result) && this.hasDefault()) {
+                    result = this.getDefault(pass);
                 }
-                result = this._validate(result, pass);
-                result = this._executeAdditionalValidator(result, pass, "afterConversion");
-            }
-            else {
-                if (this._required) {
-                    throw pass.getError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
+                result = this._executeAdditionalValidator(result, pass, "afterDefault");
+                result = this._executeAdditionalValidator(result, pass, "beforeConversion");
+                if (BaseSchema.isPresent(result)) {
+                    if (BaseSchema.getType(result) !== this.type) {
+                        result = this.convert(result, pass);
+                    }
+                    result = this._validate(result, presentOptions, pass);
+                    result = this._executeAdditionalValidator(result, pass, "afterConversion");
                 }
                 else {
+                    if (this._required) {
+                        throw pass.causeError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
+                    }
+                    else {
+                        result = undefined;
+                    }
+                }
+                if (this._required || result !== undefined) {
+                    result = this._executeAdditionalValidator(result, pass, "afterAll");
+                }
+            }
+            catch (error) {
+                if (error instanceof ValidationError && presentOptions.collectErrors) {
                     result = undefined;
                 }
-                result = this._validate(result, pass);
-                result = this._executeAdditionalValidator(result, pass, "afterConversion");
+                else {
+                    throw error;
+                }
             }
-            if (this._required || result !== undefined) {
-                result = this._executeAdditionalValidator(result, pass, "afterAll");
+            if (pass.topLevel && pass.errors.length > 0) {
+                throw new TopLevelValidationError(pass);
             }
             return result;
         }
@@ -136,7 +174,7 @@
                 return this._default;
             }
             else {
-                throw pass.getError(`Failed to get default. Invalid default value.`);
+                throw pass.causeError(`Failed to get default. Invalid default value.`);
             }
         }
         _getValueDisplay(value) {
@@ -150,7 +188,7 @@
             };
         }
         _getJsonSchemaDescription() {
-            const pass = new ValidationPass(this, this._default);
+            const pass = new ValidationPass(this, this._default, undefined);
             const descriptionPieces = [];
             descriptionPieces.push(`A ${this._required ? "required" : "optional"} ${this.type}`);
             if (this.hasDefault()) {
@@ -173,7 +211,7 @@
         }
         _ensurePass(source, pass) {
             if (pass === undefined) {
-                pass = new ValidationPass(this, source);
+                pass = new ValidationPass(this, source, undefined);
             }
             return pass;
         }
@@ -239,7 +277,7 @@
 
     class AnySchema extends BaseSchema {
         get type() { return "any"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -260,24 +298,12 @@
             this.subschema = subschema;
         }
         get type() { return "array"; }
-        // public validate(source: SourceValue<ArraySource<Subschema>, Required, Default>, pass?: ValidationPass):
-        //     ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     const result: any = super.validate(source, pass);
-        //     if (result !== undefined) {
-        //         for (const key in result) {
-        //             const nestedValue = result[key];
-        //             result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
-        //         }
-        //     }
-        //     return result;
-        // }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const result = [];
             if (source !== undefined) {
                 for (const key in source) {
                     const nestedValue = source[key];
-                    result[key] = this.subschema.validate(source[key], pass.next([...pass.path, key], this.subschema, nestedValue));
+                    result[key] = this.subschema.validate(source[key], options, pass.next([...pass.path, key], this.subschema, nestedValue));
                 }
             }
             return result;
@@ -290,7 +316,7 @@
                 return [value];
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to array.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to array.`);
             }
         }
         getJsonSchema() {
@@ -310,7 +336,7 @@
 
     class BooleanSchema extends BaseSchema {
         get type() { return "boolean"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -329,7 +355,7 @@
                 return false;
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to boolean.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to boolean.`);
             }
         }
         clone() {
@@ -346,7 +372,7 @@
     const StandardDate = globalThis.Date;
     class DateSchema extends BaseSchema {
         get type() { return "Date"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -357,7 +383,7 @@
                 return new StandardDate(value);
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to Date.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to Date.`);
             }
         }
         before(date, message) {
@@ -412,24 +438,12 @@
             this.subschema = subschema;
         }
         get type() { return "object"; }
-        // public validate(source: SourceValue<DynamicObjectSource<Subschema>, Required, Default>, pass?: ValidationPass):
-        //     ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     const result: any = super.validate(source, pass);
-        //     if (result !== undefined) {
-        //         for (const key in result) {
-        //             const nestedValue = result[key];
-        //             result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
-        //         }
-        //     }
-        //     return result;
-        // }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const result = source;
             if (result !== undefined) {
                 for (const key in result) {
                     const nestedValue = result[key];
-                    result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
+                    result[key] = this.subschema.validate(result[key], options, pass.next([...pass.path, key], this.subschema, nestedValue));
                 }
             }
             return result;
@@ -466,11 +480,9 @@
             this.members = members;
         }
         get type() { return "string"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const result = source;
-            if (this._required) {
-                pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
-            }
+            pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
             return result;
         }
         convert(value, pass) {
@@ -490,7 +502,7 @@
 
     class NumberSchema extends BaseSchema {
         get type() { return "number"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -510,18 +522,18 @@
                 return value.getTime();
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to number.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to number.`);
             }
         }
         min(minimum, message) {
             return this.custom((model, pass) => {
-                pass.assert(model >= minimum, message === undefined ? `Number ${model} failed minimum check. (${minimum})` : message);
+                pass.assert(model >= minimum, message === undefined ? `Number ${model} failed minimum check. (Must be >= ${minimum})` : message);
                 return model;
             }, "afterAll");
         }
         max(maximum, message) {
             return this.custom((model, pass) => {
-                pass.assert(model <= maximum, message === undefined ? `Number ${model} failed maximum check. (${maximum})` : message);
+                pass.assert(model <= maximum, message === undefined ? `Number ${model} failed maximum check. (Must be <= ${maximum})` : message);
                 return model;
             }, "afterAll");
         }
@@ -552,7 +564,7 @@
             this.subschema = subschema;
         }
         get type() { return "object"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const input = source;
             let output = input;
             if (typeof input === "object" && input !== null) {
@@ -560,7 +572,7 @@
                 for (const key in this.subschema) {
                     const nestedSchema = this.subschema[key];
                     const nestedValue = input[key];
-                    output[key] = this.subschema[key].validate(input[key], pass.next([...pass.path, key], nestedSchema, nestedValue));
+                    output[key] = this.subschema[key].validate(input[key], options, pass.next([...pass.path, key], nestedSchema, nestedValue));
                 }
             }
             return output;
@@ -631,7 +643,7 @@
         get type() {
             return "string";
         }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             let result = source;
             if (result !== undefined) {
                 let done = false;
@@ -640,7 +652,7 @@
                     const schema = this.schemas[i];
                     try {
                         if (BaseSchema.getType(result) === schema.type) {
-                            result = schema.validate(result, pass);
+                            result = schema.validate(result, options, pass);
                             done = true;
                         }
                     }
@@ -678,7 +690,7 @@
         // public required() { return new StringSchema(true, this._default, this._additionalValidationPasses); }
         // public optional() { return new StringSchema(false, this._default, this._additionalValidationPasses); }
         // public default<Default extends DefaultValue<StringSource>>(defaultValue: Default) { return new StringSchema(this._required, defaultValue, this._additionalValidationPasses); }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {

package/build/schema/AnySchema.d.ts

@@ -1,9 +1,9 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { DefaultValue, ModelValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export declare class AnySchema<Required extends boolean, Default extends DefaultValue<any>> extends BaseSchema<any, any, Required, Default> {
     get type(): string;
-    protected _validate(source: ModelValue<any, any, Required, Default>, pass: ValidationPass): ModelValue<any, any, Required, Default>;
+    protected _validate(source: ModelValue<any, any, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<any, any, Required, Default>;
     convert(value: any, pass: ValidationPass): any;
     getJsonSchema(): object;
     clone(): AnySchema<Required, Default>;

package/build/schema/ArraySchema.d.ts

@@ -1,6 +1,6 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type ArraySource<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>[]) : never);
 export type ArrayModel<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>[]) : never);
@@ -8,7 +8,7 @@ export declare class ArraySchema<Subschema extends BaseSchemaAny, Required exten
     readonly subschema: Subschema;
     constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<ArraySource<Subschema>, ArrayModel<Subschema>>);
     get type(): string;
-    protected _validate(source: ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
+    protected _validate(source: ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
     convert(value: ArraySource<Subschema>, pass: ValidationPass): ArrayModel<Subschema>;
     getJsonSchema(): object;
     clone(): ArraySchema<Subschema, Required, Default>;

package/build/schema/BaseSchema.d.ts

@@ -1,14 +1,14 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import type { AdditionalValidationPasses, AdditionalValidator, AdditionalValidatorAfterType, AdditionalValidatorBeforeType, DefaultValue, EnsureValidator, ModelValue, SourceValue } from "../typing/toolbox";
+import type { AdditionalValidationPasses, AdditionalValidator, AdditionalValidatorAfterType, AdditionalValidatorBeforeType, DefaultValue, EnsureValidator, ModelValue, OptionalValidationOptions, SourceValue, ValidationOptions } from "../typing/toolbox";
 export declare abstract class BaseSchema<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> {
     protected readonly _required: Required;
     protected readonly _default: Default;
     protected readonly _additionalValidationPasses: AdditionalValidationPasses<Source, Model>;
     constructor(required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Source, Model>);
     abstract get type(): string;
-    validate(source: SourceValue<Source, Required, Default>, pass?: ValidationPass): ModelValue<Source, Model, Required, Default>;
-    protected abstract _validate(source: ModelValue<Source, Model, Required, Default>, pass: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    validate(source: SourceValue<Source, Required, Default>, options?: OptionalValidationOptions, pass?: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    protected abstract _validate(source: ModelValue<Source, Model, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Source, Model, Required, Default>;
     abstract convert(value: Source, pass: ValidationPass): Model;
     custom(additionalValidator: AdditionalValidator<SourceValue<Source, Required, Default>>, type: AdditionalValidatorBeforeType): this;
     custom(additionalValidator: AdditionalValidator<Model>, type: AdditionalValidatorAfterType): this;

package/build/schema/BooleanSchema.d.ts

@@ -1,10 +1,10 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { DefaultValue, ModelValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type BooleanSource = boolean | number | string | null | undefined;
 export declare class BooleanSchema<Required extends boolean, Default extends DefaultValue<BooleanSource>> extends BaseSchema<BooleanSource, boolean, Required, Default> {
     get type(): string;
-    protected _validate(source: ModelValue<BooleanSource, boolean, Required, Default>, pass: ValidationPass): ModelValue<BooleanSource, boolean, Required, Default>;
+    protected _validate(source: ModelValue<BooleanSource, boolean, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<BooleanSource, boolean, Required, Default>;
     convert(value: BooleanSource, pass: ValidationPass): boolean;
     clone(): BooleanSchema<Required, Default>;
     getJsonSchema(): object;

package/build/schema/DateSchema.d.ts

@@ -1,12 +1,12 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { DefaultValue, ModelValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 type StandardDate = globalThis.Date;
 declare const StandardDate: DateConstructor;
 export type DateSource = string | number | StandardDate;
 export declare class DateSchema<Required extends boolean, Default extends DefaultValue<DateSource>> extends BaseSchema<DateSource, StandardDate, Required, Default> {
     get type(): string;
-    protected _validate(source: ModelValue<DateSource, Date, Required, Default>, pass: ValidationPass): ModelValue<DateSource, Date, Required, Default>;
+    protected _validate(source: ModelValue<DateSource, Date, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<DateSource, Date, Required, Default>;
     convert(value: DateSource, pass: ValidationPass): StandardDate;
     before(date: Date, message?: string): this;
     after(date: Date, message?: string): this;

package/build/schema/DynamicObjectSchema.d.ts

@@ -1,6 +1,6 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type DynamicObjectSource<Subschema extends BaseSchemaAny> = ({
     [Key: string]: (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
@@ -12,7 +12,7 @@ export declare class DynamicObjectSchema<Subschema extends BaseSchemaAny, Requir
     readonly subschema: Subschema;
     constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>>);
     get type(): string;
-    protected _validate(source: ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
+    protected _validate(source: ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
     convert(source: DynamicObjectSource<Subschema>, pass: ValidationPass): DynamicObjectModel<Subschema>;
     getJsonSchema(): object;
     clone(): DynamicObjectSchema<Subschema, Required, Default>;

package/build/schema/EnumerationSchema.d.ts

@@ -1,11 +1,11 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { AdditionalValidationPasses, DefaultValue, ModelValue } from "../typing/toolbox";
+import { AdditionalValidationPasses, DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export declare class EnumerationSchema<Members extends string, Required extends boolean, Default extends DefaultValue<Members>> extends BaseSchema<Members, Members, Required, Default> {
     readonly members: Members[];
     constructor(members: Members[], required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Members, Members>);
     get type(): string;
-    protected _validate(source: ModelValue<Members, Members, Required, Default>, pass: ValidationPass): ModelValue<Members, Members, Required, Default>;
+    protected _validate(source: ModelValue<Members, Members, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Members, Members, Required, Default>;
     convert(value: Members, pass: ValidationPass): Members;
     clone(): EnumerationSchema<Members, Required, Default>;
     getJsonSchema(): object;

package/build/schema/NumberSchema.d.ts

@@ -1,10 +1,10 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { DefaultValue, ModelValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type NumberSource = number | bigint | string | boolean | null | undefined | Date;
 export declare class NumberSchema<Required extends boolean, Default extends DefaultValue<NumberSource>> extends BaseSchema<NumberSource, number, Required, Default> {
     get type(): string;
-    protected _validate(source: ModelValue<NumberSource, number, Required, Default>, pass: ValidationPass): ModelValue<NumberSource, number, Required, Default>;
+    protected _validate(source: ModelValue<NumberSource, number, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<NumberSource, number, Required, Default>;
     convert(value: NumberSource, pass: ValidationPass): number;
     min(minimum: number, message?: string): this;
     max(maximum: number, message?: string): this;

package/build/schema/ObjectSchema.d.ts

@@ -1,6 +1,6 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import type { AdditionalValidationPasses, DefaultValue, Merge, ModelRequirement, ModelValue, SourceRequirement, SourceValue } from "../typing/toolbox";
+import type { AdditionalValidationPasses, DefaultValue, Merge, ModelRequirement, ModelValue, SourceRequirement, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type ObjectSubschema = {
     [Key: string]: BaseSchemaAny;
@@ -19,7 +19,7 @@ export declare class ObjectSchema<Subschema extends ObjectSubschema, Required ex
     readonly subschema: Subschema;
     constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<ObjectSource<Subschema>, ObjectModel<Subschema>>);
     get type(): string;
-    protected _validate(source: ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
+    protected _validate(source: ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
     convert(value: ObjectSource<Subschema>, pass: ValidationPass): ObjectModel<Subschema>;
     extend<ExtensionSubschema extends ObjectSubschema, ExtensionDefault extends DefaultValue<ObjectSource<ExtensionSubschema>>>(schema: ObjectSchema<ExtensionSubschema, Required, ExtensionDefault>): ObjectSchema<Subschema & ExtensionSubschema, Required, any>;
     getJsonSchema(): object;

package/build/schema/OrSetSchema.d.ts

@@ -1,6 +1,6 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type OrSetSchemaSource<MemberSchema extends BaseSchemaAny> = (MemberSchema extends BaseSchema<infer Source, any, infer Required, infer Default> ? SourceValue<Source, Required, Default> : never);
 export type OrSetSchemaModel<MemberSchema extends BaseSchemaAny> = (MemberSchema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? ModelValue<Source, Model, Required, Default> : never);
@@ -8,7 +8,7 @@ export declare class OrSetSchema<MemberSchema extends BaseSchemaAny, Required ex
     readonly schemas: MemberSchema[];
     constructor(schemas: MemberSchema[], required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>>);
     get type(): string;
-    protected _validate(source: ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>, pass: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>;
+    protected _validate(source: ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>;
     convert(value: OrSetSchemaSource<MemberSchema>, pass: ValidationPass): OrSetSchemaModel<MemberSchema>;
     clone(): OrSetSchema<MemberSchema, Required, Default>;
     getJsonSchema(): object;

package/build/schema/StringSchema.d.ts

@@ -1,10 +1,10 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { DefaultValue, ModelValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type StringSource = string | number | boolean | null | undefined | Date;
 export declare class StringSchema<Required extends boolean, Default extends DefaultValue<StringSource>> extends BaseSchema<StringSource, string, Required, Default> {
     get type(): string;
-    protected _validate(source: ModelValue<StringSource, string, Required, Default>, pass: ValidationPass): ModelValue<StringSource, string, Required, Default>;
+    protected _validate(source: ModelValue<StringSource, string, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<StringSource, string, Required, Default>;
     convert(value: StringSource, pass: ValidationPass): string;
     /**
      * Trims strings validated by this schema.

package/build/typing/toolbox.d.ts

@@ -1,6 +1,10 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchema } from "../schema/BaseSchema";
 import { BaseSchemaAny } from "./extended";
+export type ValidationOptions = {
+    collectErrors: boolean;
+};
+export type OptionalValidationOptions = Partial<ValidationOptions>;
 export type SourceRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (Default extends undefined ? true : false) : (false)) : never);
 export type SourceValue<Source, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? (undefined extends Default ? (Source) : (Source | undefined)) : Source | undefined);
 export type ModelRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (true) : (Default extends undefined ? false : true)) : never);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "2.0.4",
+    "version": "3.0.0",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -37,4 +37,4 @@
         "tslib": "^2.6.3",
         "typescript": "^5.4.5"
     }
-}
+}