justus 0.0.0-alpha.0 → 0.0.1

package/dist/index.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts", "../src/errors.ts", "../src/types.ts", "../src/validators/any.ts", "../src/validators/constant.ts", "../src/validators/tuple.ts", "../src/validators/object.ts", "../src/utilities.ts", "../src/schema.ts", "../src/validators/union.ts", "../src/validators/array.ts", "../src/validators/boolean.ts", "../src/validators/date.ts", "../src/validators/number.ts", "../src/validators/string.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/index.d.ts

@@ -1,7 +1,504 @@
-export { Validator, any, boolean, constant } from './basics';
-export { string, number } from './primitives';
-export { array } from './arrays';
-export { object } from './objects';
-export { additionalProperties, readonly, optional } from './schemas';
-export { allOf, oneOf } from './unions';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * An interface defining whether a `Schema` should include additional
+ * properties, and the `Validator` used to validate them.
+ */
+export declare interface AdditionalProperties<V extends Validator | false> {
+    [additionalValidator]: V;
+}
+
+/** A symbol indicating the `Validator` for a `Schema`'s additional properties. */
+export declare const additionalValidator: unique symbol;
+
+/** Validate a value as _all of_ the specified arguments */
+export declare function allOf<A extends UnionArguments>(...args: A): AllOfValidator<A>;
+
+/** A `Validator` validating a value as _all of_ the specified arguments. */
+export declare class AllOfValidator<A extends UnionArguments> extends Validator<InferAllOfValidationType<A>> {
+    readonly validators: readonly Validator[];
+    constructor(args: A);
+    validate(value: unknown, options: ValidationOptions): InferAllOfValidationType<A>;
+}
+
+/**
+ * Allow additional properties in `Schema`s.
+ *
+ * This function can be called with a `boolean` argument (`true` allow _any_
+ * additional property, `false` do not allow additional properties) or with a
+ * `Validation` that will be used to validate additional properties.
+ *
+ * @param allow - A `boolean` or a `Validator` instance
+ */
+export declare const allowAdditionalProperties: typeof _allowAdditionalProperties & AdditionalProperties<Validator<any>>;
+
+/** Internal definition of `allowAdditionalProperties(...)` */
+declare function _allowAdditionalProperties(): AdditionalProperties<Validator<any>>;
+
+declare function _allowAdditionalProperties(allow: true): AdditionalProperties<Validator<any>>;
+
+declare function _allowAdditionalProperties(allow: false): AdditionalProperties<false>;
+
+declare function _allowAdditionalProperties<V extends Validation>(validation: V): AdditionalProperties<Validator<InferValidation<V>>>;
+
+/** The `Validator` validating _anything_. */
+export declare const any: AnyValidator;
+
+/** A `Validator` validating _anything_. */
+export declare class AnyValidator extends Validator<any> {
+    validate(value: unknown): any;
+}
+
+/** Validate `Array`s. */
+export declare const array: typeof _array & Iterable<TupleRestParameter<any[]>>;
+
+declare function _array(): Validator<any[]>;
+
+declare function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>;
+
+/** Constraints to validate an `Array` with. */
+declare interface ArrayConstraints<V extends Validation> {
+    /** The _maximum_ number of elements a valid `Array`: `value.length <= maxItems` */
+    maxItems?: number;
+    /** The _minimum_ number of elements a valid `Array`: `value.length >= minItems` */
+    minItems?: number;
+    /** A flag indicating whether an `Array`'s elements must be unique */
+    uniqueItems?: boolean;
+    /** A `Validator` validating each individual item in an `Array` */
+    items?: V;
+}
+
+/** Validate `Array`s containing only the specified elements. */
+export declare function arrayOf<V extends Validation>(validation: V): ArrayValidator<InferValidation<V>>;
+
+/**
+ * A validator for `Array` instances.
+ */
+export declare class ArrayValidator<T> extends Validator<T[]> {
+    readonly maxItems: number;
+    readonly minItems: number;
+    readonly uniqueItems: boolean;
+    readonly items: Validator<T>;
+    constructor(options?: ArrayConstraints<Validator<T>>);
+    validate(value: unknown, options: ValidationOptions): T[];
+}
+
+/**
+ * Simple assertion function throwing `TypeError`(s) to be used when
+ * constructing a `Validator` from a `Schema` or validation constraints.
+ */
+export declare function assertSchema(what: boolean | undefined, message: string): asserts what;
+
+/**
+ * Simple assertion function throwing `ValidationError`(s) with an empty path
+ */
+export declare function assertValidation(what: boolean | undefined, message: string): asserts what;
+
+/** The `Validator` for `boolean`s. */
+export declare const boolean: BooleanValidator;
+
+/** A `Validator` validating `boolean`s. */
+export declare class BooleanValidator extends Validator<boolean> {
+    validate(value: unknown): boolean;
+}
+
+/**
+ * Mark a `Schema` property as both _optional_ and _read only_.
+ */
+export declare interface CombinedModifier<V extends Validator = Validator> extends ReadonlyModifier<V>, OptionalModifier<V>, Modifier<V> {
+    optional: true;
+    readonly: true;
+}
+
+declare type CombineModifiers<M1 extends Modifier, M2 extends Modifier> = M1 extends ReadonlyModifier ? M2 extends ReadonlyModifier<infer V> ? ReadonlyModifier<V> : M2 extends OptionalModifier<infer V> ? CombinedModifier<V> : never : M1 extends OptionalModifier ? M2 extends ReadonlyModifier<infer V> ? CombinedModifier<V> : M2 extends OptionalModifier<infer V> ? OptionalModifier<V> : never : never;
+
+/** Validate _constants_. */
+export declare function constant<T extends string | number | boolean | null>(constant: T): Validator<T>;
+
+/** A `Validator` for _constants_. */
+export declare class ConstantValidator<T extends string | number | boolean | null> extends Validator<T> {
+    readonly constant: T;
+    constructor(constant: T);
+    validate(value: unknown): T;
+}
+
+/** Validate dates and convert them to `Date` instances. */
+export declare const date: typeof _date & Iterable<TupleRestParameter<Date>>;
+
+declare function _date(): DateValidator;
+
+declare function _date(constraints: DateConstraints): DateValidator;
+
+/** Constraints to validate a `Date` with. */
+declare interface DateConstraints {
+    /** The format for dates, an _ISO date_ (RFC 3339) or a numeric timestamp */
+    format?: 'iso' | 'timestamp';
+    /** The earliest value a date can have */
+    from?: Date;
+    /** The latest value a date can have */
+    until?: Date;
+}
+
+/** A `Validator` validating dates and converting them to `Date` instances. */
+export declare class DateValidator extends Validator<Date> {
+    readonly format?: 'iso' | 'timestamp';
+    readonly from?: Date;
+    readonly until?: Date;
+    constructor(constraints?: DateConstraints);
+    validate(value: unknown): Date;
+}
+
+/**
+ * Return the `Validator` for the given `Validation`.
+ *
+ * When `validation` is `undefined` it will return a `Validator<any>`,
+ */
+export declare function getValidator(validation?: Validation): Validator;
+
+declare type InferAllOfValidationType<A extends UnionArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends UnionArguments ? InferValidation<First> & InferOneOfValidationType<Rest> : InferValidation<First> : never : never;
+
+/** Infer the type of  _read only_ **and** _optional_ `Schema` properties  */
+declare type InferCombinedModifiers<S extends Schema> = {
+    readonly [key in keyof S as key extends string ? S[key] extends CombinedModifier ? key : never : never]?: S[key] extends CombinedModifier<infer V> ? InferValidation<V> : never;
+};
+
+/** Ensure that we properly type `never` properties */
+declare type InferNever<S extends Schema> = {
+    [key in keyof S as key extends string ? S[key] extends typeof never ? key : never : never]: never;
+};
+
+declare type InferOneOfValidationType<A extends UnionArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends UnionArguments ? InferValidation<First> | InferOneOfValidationType<Rest> : InferValidation<First> : never : never;
+
+/** Infer the type of _optional_ `Schema` properties  */
+declare type InferOptionalModifiers<S extends Schema> = {
+    [key in keyof S as key extends string ? S[key] extends ReadonlyModifier<Validator> ? never : S[key] extends OptionalModifier<Validator> ? key : never : never]?: S[key] extends OptionalModifier<infer V> ? InferValidation<V> : never;
+};
+
+/** Infer the type of _read only_ `Schema` properties  */
+declare type InferReadonlyModifiers<S extends Schema> = {
+    readonly [key in keyof S as key extends string ? S[key] extends OptionalModifier<Validator> ? never : S[key] extends ReadonlyModifier<Validator> ? key : never : never]: S[key] extends ReadonlyModifier<infer V> ? InferValidation<V> : never;
+};
+
+/** Infer the type of keys associated with `Validation`s */
+declare type InferRequired<S extends Schema> = {
+    [key in keyof S as key extends string ? S[key] extends Validation ? key : never : never]: S[key] extends Validation ? InferValidation<S[key]> : never;
+};
+
+/** Infer the type validated by a `Schema` */
+export declare type InferSchema<S extends Schema> = InferReadonlyModifiers<S> & InferOptionalModifiers<S> & InferCombinedModifiers<S> & (S extends AdditionalProperties<Validator<infer V>> ? Record<string, V> & InferNever<S> & InferRequired<S> : InferRequired<S>);
+
+/**
+ * Infer the type returned by a `TupleValidator` when validating an array.
+ */
+export declare type InferTuple<T> = T extends Tuple ? T extends readonly [] ? [] : T extends readonly [Validation, ...any[]] ? T extends readonly [infer V, ...infer Rest] ? [
+InferValidation<V>,
+...InferTuple<Rest>
+] : never : T extends readonly [...any[], Validation] ? T extends readonly [...infer Rest, infer V] ? [
+...InferTuple<Rest>,
+InferValidation<V>
+] : never : T extends readonly (infer V)[] ? [
+...InferValidationOrTupleRest<V>[]
+] : never : never;
+
+/**
+ * Infer the type returned by a `Validation` when validating.
+ */
+export declare type InferValidation<V> = V extends Validation ? V extends {
+    (...args: infer A0): Validator<infer R0>;
+    (...args: infer A1): Validator<infer R1>;
+    (...args: infer A2): Validator<infer R2>;
+    (...args: infer A3): Validator<infer R3>;
+    (...args: infer A4): Validator<infer R4>;
+    (...args: infer A5): Validator<infer R5>;
+    (...args: infer A6): Validator<infer R6>;
+    (...args: infer A7): Validator<infer R7>;
+    (...args: infer A8): Validator<infer R8>;
+    (...args: infer A9): Validator<infer R9>;
+} ? A0 extends [] ? R0 : A1 extends [] ? R1 : A2 extends [] ? R2 : A3 extends [] ? R3 : A4 extends [] ? R4 : A5 extends [] ? R5 : A6 extends [] ? R6 : A7 extends [] ? R7 : A8 extends [] ? R8 : A9 extends [] ? R9 : never : V extends Validator<infer T> ? T : V extends Tuple ? InferTuple<V> : V extends Schema ? InferSchema<V> : V extends boolean ? V : V extends number ? V : V extends string ? V : V extends null ? V : never : never;
+
+/** Infer the type validated by a `Validation` or `TupleRestParameter` */
+declare type InferValidationOrTupleRest<T> = T extends TupleRestParameter<infer X> ? X : T extends Validation ? InferValidation<T> : never;
+
+/** Type guard for `Modifier` instances */
+export declare function isModifier(what: any): what is Modifier<any>;
+
+/**
+ * A `Modifier` marks a `Schema` property either _read only_ and/or _optional_.
+ */
+export declare interface Modifier<V extends Validator = Validator> {
+    [modifierValidator]: V;
+    readonly?: true;
+    optional?: true;
+}
+
+/** A symbol indicating the `Validator` for a `Modifier`. */
+export declare const modifierValidator: unique symbol;
+
+/** A symbol indicating that a `Schema` property is _forbidden_. */
+export declare const never: unique symbol;
+
+/** Validate `number`s. */
+export declare const number: typeof _number & Iterable<TupleRestParameter<number>>;
+
+declare function _number(): Validator<number>;
+
+declare function _number<N extends number = number>(constraints?: NumberConstraints): NumberValidator<N>;
+
+/** Constraints to validate a `number` with. */
+declare interface NumberConstraints {
+    /** The value for which a `number` must be multiple of for it to be valid */
+    multipleOf?: number;
+    /** The _inclusive_ maximum value for a valid `number`: `value <= maximum` */
+    maximum?: number;
+    /** The _inclusive_ minimum value for a valid `number`: `value >= minimum` */
+    minimum?: number;
+    /** The _exclusive_ maximum value for a valid `number`: `value < exclusiveMaximum` */
+    exclusiveMaximum?: number;
+    /** The _exclusive_ minimum value for a valid `number`: `value > exclusiveMaximum` */
+    exclusiveMinimum?: number;
+    /** Whether to allow `NaN` or not (default: `false`) */
+    allowNaN?: boolean;
+}
+
+/** A `Validator` validating `number`s. */
+export declare class NumberValidator<N extends number = number> extends Validator<N> {
+    #private;
+    readonly allowNaN: boolean;
+    readonly exclusiveMaximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly maximum: number;
+    readonly minimum: number;
+    readonly multipleOf?: number;
+    constructor(constraints?: NumberConstraints);
+    validate(value: unknown): N;
+    static readonly PRECISION = 1000000;
+}
+
+/** Validate `object`s. */
+export declare const object: typeof _object & Iterable<TupleRestParameter<Record<string, any>>>;
+
+declare function _object(): Validator<Record<string, any>>;
+
+declare function _object<S extends Schema>(schema: S): S;
+
+/** A `Validator` validating `object`s according to a `Schema` */
+export declare class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>> {
+    #private;
+    readonly schema: Readonly<S>;
+    constructor(schema: S);
+    validate(value: unknown, options: ValidationOptions): InferSchema<S>;
+}
+
+/** Validate a value as _one of_ the specified arguments */
+export declare function oneOf<A extends UnionArguments>(...args: A): OneOfValidator<A>;
+
+/** A `Validator` validating a value as _one of_ the specified arguments. */
+export declare class OneOfValidator<A extends UnionArguments> extends Validator<InferOneOfValidationType<A>> {
+    readonly validators: readonly Validator[];
+    constructor(args: A);
+    validate(value: unknown, options: ValidationOptions): InferOneOfValidationType<A>;
+}
+
+/**
+ * Ensure that the property is marked as _optional_ in the `Schema`.
+ *
+ * @param validation - A `Validation` to be marked as _optional_.
+ */
+export declare function optional(): OptionalModifier<any>;
+
+export declare function optional<V extends Validation>(validation: V): OptionalModifier<Validator<InferValidation<V>>>;
+
+export declare function optional<M extends Modifier>(modifier: M): CombineModifiers<OptionalModifier, M>;
+
+/**
+ * Mark a `Schema` property as _optional_.
+ */
+export declare interface OptionalModifier<V extends Validator = Validator> extends Modifier<V> {
+    optional: true;
+}
+
+/**
+ * Ensure that the property is marked as _read only_ in the `Schema`.
+ *
+ * @param validation - A `Validation` to be marked as _read only_.
+ */
+export declare function readonly(): ReadonlyModifier<any>;
+
+export declare function readonly<V extends Validation>(validation: V): ReadonlyModifier<Validator<InferValidation<V>>>;
+
+export declare function readonly<M extends Modifier>(modifier: M): CombineModifiers<ReadonlyModifier, M>;
+
+/**
+ * Mark a `Schema` property as _read only_.
+ */
+export declare interface ReadonlyModifier<V extends Validator = Validator> extends Modifier<V> {
+    readonly: true;
+}
+
+/** A symbol indicating the `Validator` for a `Tuple`'s rest parameter. */
+export declare const restValidator: unique symbol;
+
+/**
+ * The `Schema` interface defines what properties are defined for objects and
+ * how they should be validated.
+ */
+export declare interface Schema {
+    [key: string]: Validation | Modifier | typeof never;
+    [additionalValidator]?: Validator | false;
+}
+
+/** A symbol indicating the `Validator` for a `Schema`. */
+export declare const schemaValidator: unique symbol;
+
+/** Validate `string`s. */
+export declare const string: typeof _string & Iterable<TupleRestParameter<string>>;
+
+declare function _string(): Validator<string>;
+
+declare function _string<S extends string = string>(constraints?: StringConstraints): StringValidator<S>;
+
+/** Constraints to validate a `string` with. */
+declare interface StringConstraints {
+    /** The _maximum_ length of a valid `string`: `value.length <= maxLength` */
+    maxLength?: number;
+    /** The _minimum_ length of a valid `string`: `value.length >= minLength` */
+    minLength?: number;
+    /** A `RegExp` enforcing a particular pattern for a valid `string`: `pattern.test(value)` */
+    pattern?: RegExp;
+}
+
+/** A `Validator` validating `string`s. */
+export declare class StringValidator<S extends string = string> extends Validator<S> {
+    readonly maxLength: number;
+    readonly minLength: number;
+    readonly pattern?: RegExp;
+    constructor(constraints?: StringConstraints);
+    validate(value: unknown): S;
+}
+
+/**
+ * A `Tuple` is defined to be an array of `Validation` or `TupleRest`
+ */
+export declare type Tuple = readonly (Validation | TupleRestParameter)[];
+
+/** Validate _tuples_. */
+export declare function tuple<T extends Tuple>(tuple: T): Validator<InferTuple<T>>;
+
+/**
+ * The `TupleRestParameter` defines a tuple member that can occur several
+ * times while validating an array.
+ *
+ * Every `Validator` is an `Iterable` of `TupleRestParameters` so that it can
+ * be used in tuples. For example, to indicate a tuple composed by a number,
+ * followed by zero or more non-empty strings we can write:
+ *
+ * ```
+ * const nonEmptyString = string({ minLength: 1 })
+ * const myTuple = tuple([ number, ...nonEmptyString ])
+ * ```
+ */
+export declare type TupleRestParameter<T = any> = {
+    [restValidator]: Validator<T>;
+};
+
+/** A `Validator` for _tuples_. */
+export declare class TupleValidator<T extends Tuple> extends Validator<InferTuple<T>> {
+    #private;
+    readonly tuple: T;
+    constructor(tuple: T);
+    validate(value: unknown, options: ValidationOptions): InferTuple<T>;
+}
+
+declare type UnionArguments = readonly [Validation, ...Validation[]];
+
+/** Validate a _value_ using the specified `Validation` */
+export declare function validate<V extends Validation>(validation: V, value: any, options?: ValidateOptions): InferValidation<V>;
+
+/** Options for `validate` */
+export declare type ValidateOptions = {
+    -readonly [key in keyof ValidationOptions]?: ValidationOptions[key] | undefined;
+};
+
+/**
+ * The `Validation` type indicates all potential types which could be used
+ * as _sources_ for validation.
+ *
+ * Those are:
+ *
+ * * A `Validator` instance or a _zero-arguments_ function returning one
+ * * A `Tuple` or a `Schema`, validated as arrays or object
+ * * Either `null`, a `boolean`, a `number` or a `string` for constants
+ */
+export declare type Validation = (() => Validator) | Validator | // Validator instances or their creators
+Tuple | Schema | // Tuples or schemas (arrays, objects)
+null | boolean | number | string;
+
+/**
+ * A `ValidationError` wraps one or more errors encountered during validation.
+ */
+export declare class ValidationError extends Error {
+    /** An `Array` of validation errors encountered while validating */
+    readonly errors: ValidationErrors;
+    /** Our stack, always present as we enforce it in the constructor */
+    readonly stack: string;
+    /**
+     * Create a new `ValidationError` instance from a `ValidationErrorBuilder`
+     * or with a `cause` (a string, or another error) and optional path.
+     *
+     * The `constructor` (optional last parameter) will restrict creation of
+     * this instance's stack up to the specified function.
+     */
+    constructor(builder: ValidationErrorBuilder);
+    constructor(cause: any, constructor?: Function);
+    constructor(cause: any, path: (string | number)[], constructor?: Function);
+}
+
+/**
+ * Helper class to build a `ValidationError` associated p
+ */
+export declare class ValidationErrorBuilder {
+    /** The current list of validation errors */
+    readonly errors: ValidationErrors;
+    /**
+     * Record a validation error associated with the specified key.
+     *
+     * @param error - The error (normally a `string` or a `ValidationError`)
+     *                to record and associate with the given key
+     * @param key - The key in an object, or index in an array where the
+     *              vaildation error was encountered
+     */
+    record(error: any, key?: string | number): this;
+    /**
+     * Assert there are no validation errors and return the specified value, or
+     * throw a `ValidationError` combining all errors
+     *
+     * @param value - The value to return if no errors have been recorded
+     */
+    assert<T>(value: T): T;
+}
+
+declare type ValidationErrors = {
+    path: (string | number)[];
+    message: string;
+}[];
+
+/**
+ * Options to be using while validating.
+ */
+export declare interface ValidationOptions {
+    /** Strip additional, undeclared properties from objects */
+    readonly stripAdditionalProperties: boolean;
+    /** Ignore and strip forbidden (`never`) properties from objects */
+    readonly stripForbiddenProperties: boolean;
+}
+
+/**
+ * A `Validator` is an object capable of validating a given _value_ and
+ * (possibly) converting it the required type `T`.
+ */
+export declare abstract class Validator<T = any> implements Iterable<TupleRestParameter<T>> {
+    /** Validate a _value_ and optionally convert it to the required `Type` */
+    abstract validate(value: unknown, options: ValidationOptions): T;
+    /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
+    [Symbol.iterator](): Generator<TupleRestParameter<T>>;
+}
+
+export { }