@amazon/vinyl-validation 1.0.0

package/dist/types/current/validation/validators.d.ts

@@ -0,0 +1,127 @@
+import { type AnyRecord, type Fun, type Primitive, type ReadonlyRecord } from '@amazon/vinyl-util';
+import { ArraySchema } from './ArraySchema';
+import { FunctionSchema } from './FunctionSchema';
+import { SetSchema } from './SetSchema';
+import { ValueSchema } from './ValueSchema';
+import { NumberSchema } from './NumberSchema';
+import { type ExtendedPropertyValidators, ObjectSchema } from './ObjectSchema';
+import { RecordSchema } from './RecordSchema';
+import { StringSchema } from './StringSchema';
+import type { Validator } from './Validator';
+/**
+ * Creates a no-op validator. The value can be any type.
+ */
+export declare function any(): ValueSchema<any>;
+/**
+ * Creates a validator that asserts that the input is an array.
+ */
+export declare function array(): ArraySchema<unknown[]>;
+/**
+ * Creates a validator that asserts that the input is an array and every element passes the
+ * given validator.
+ *
+ * @param elementValidator
+ */
+export declare function array<U>(elementValidator: Validator<U>): ArraySchema<U[]>;
+/**
+ * Creates a validator that asserts that the input is a boolean.
+ */
+export declare function boolean(): ValueSchema<boolean>;
+/**
+ * Creates a validator that asserts that the input is a function.
+ */
+export declare function func(): FunctionSchema<Fun>;
+/**
+ * Validates that the input is an instanceof the given prototype.
+ * @param clazz
+ */
+export declare function instanceOf<const T>(clazz: new (...args: any[]) => T): ValueSchema<T>;
+/**
+ * Creates a validator that asserts that the input is nullish or one of the given possible values.
+ *
+ * @param possibleValues
+ */
+export declare function isOneOf<const U extends readonly Primitive[]>(...possibleValues: U): ValueSchema<U[number]>;
+/**
+ * Creates a validator that asserts that the input is one of the values of the given enum.
+ *
+ * @param enumObject The enum to validate against.
+ */
+export declare function enumOf<const T extends Record<string, Primitive>>(enumObject: T): ValueSchema<T[keyof T]>;
+/**
+ * Creates a validator that asserts that the input is null.
+ */
+export declare function exactlyNull(): Validator<null>;
+/**
+ * Creates a validator that asserts that the input is nullish.
+ */
+export declare function nullish(): Validator<null | undefined>;
+/**
+ * Creates a validator that asserts that the input is a number.
+ */
+export declare function number(): NumberSchema;
+/**
+ * Creates a validator that validates the input has properties that pass their respective
+ * validators.
+ */
+export declare function object<const U extends object>(propertyValidators: NoInfer<ExtendedPropertyValidators<AnyRecord, U>>): ObjectSchema<U>;
+/**
+ * Returns a validator that asserts that the object's own enumerable properties has keys and
+ * values that match their respective validators.
+ *
+ * Prototype members are not included.
+ * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+ * to the key validator as '0'.
+ *
+ * To assume string keys, use {@link recordValues}
+ *
+ * @param keyValidator Validates each key.
+ * @param valueValidator Validates each value.
+ */
+export declare function record<const K extends string | symbol, const V>(keyValidator: Validator<K>, valueValidator: Validator<V>): RecordSchema<ReadonlyRecord<K, V>>;
+/**
+ * Returns a validator that asserts that the input object's own enumerable properties has
+ * string keys and values that match the given validator.
+ *
+ * Prototype members are not included.
+ *
+ * @param valueValidator Validates each value.
+ */
+export declare function recordValues<const V>(valueValidator: Validator<V>): RecordSchema<Record<string, V>>;
+/**
+ * Returns a validator that asserts the input is a set with elements that match the given
+ * element validator.
+ * @param elementValidator
+ */
+export declare function set<const U>(elementValidator: Validator<U>): SetSchema<Set<U>>;
+/**
+ * Creates a validator that asserts that the input is type 'string'.
+ */
+export declare function string(): StringSchema;
+/**
+ * Creates a validator that asserts that the input array is a tuple whose elements match
+ * the given validators.
+ *
+ * @param validators
+ */
+export declare function tuple<U extends readonly any[]>(...validators: {
+    [Index in keyof U]: Validator<U[Index]>;
+}): ArraySchema<{
+    [Index in keyof U]: U[Index];
+}>;
+/**
+ * Creates a validator that asserts that the input is type 'symbol'.
+ */
+export declare function symbol(): ValueSchema<symbol>;
+/**
+ * Creates a validator that asserts that the input is strictly undefined.
+ */
+export declare function exactlyUndefined(): ValueSchema<undefined>;
+/**
+ * Returns a custom
+ * @param expectationMessage
+ * @param isValid
+ * @param inputStringify
+ */
+export declare function custom<T>(expectationMessage: string, isValid: (input: unknown) => boolean, inputStringify?: (input: unknown) => string): ValueSchema<T>;
+//# sourceMappingURL=validators.d.ts.map

package/dist/types/current/validation/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../src/validation/validators.ts"],"names":[],"mappings":"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"}

package/dist/types/current/validation/validators.js

@@ -0,0 +1,168 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { stringifyForPrint, substitute, } from '@amazon/vinyl-util';
+import { ArraySchema } from './ArraySchema';
+import { FunctionSchema } from './FunctionSchema';
+import { SetSchema } from './SetSchema';
+import { ValueSchema, valueValidators } from './ValueSchema';
+import { NumberSchema } from './NumberSchema';
+import { ObjectSchema } from './ObjectSchema';
+import { RecordSchema } from './RecordSchema';
+import { StringSchema } from './StringSchema';
+import { typeOfValidators } from './typeOfValidators';
+import { createValidator } from './Validator';
+/**
+ * @private
+ */
+const locale = {
+    isOneOf: 'one of: {value}',
+    instanceOf: 'instance of {value}',
+    oneOfSeparator: ' | ',
+};
+/**
+ * Creates a no-op validator. The value can be any type.
+ */
+export function any() {
+    return new ValueSchema(valueValidators.any());
+}
+export function array(elementValidator) {
+    if (!elementValidator)
+        return ArraySchema.base;
+    else
+        return ArraySchema.base.withElements(elementValidator);
+}
+/**
+ * Creates a validator that asserts that the input is a boolean.
+ */
+export function boolean() {
+    return new ValueSchema(typeOfValidators.boolean);
+}
+/**
+ * Creates a validator that asserts that the input is a function.
+ */
+export function func() {
+    return FunctionSchema.base;
+}
+/**
+ * Validates that the input is an instanceof the given prototype.
+ * @param clazz
+ */
+export function instanceOf(clazz) {
+    return new ValueSchema(createValidator(substitute(locale.instanceOf, { value: clazz.name }), (input) => input instanceof clazz));
+}
+/**
+ * Creates a validator that asserts that the input is nullish or one of the given possible values.
+ *
+ * @param possibleValues
+ */
+export function isOneOf(...possibleValues) {
+    return new ValueSchema(createValidator(substitute(locale.isOneOf, {
+        value: possibleValues.join(locale.oneOfSeparator),
+    }), (input) => possibleValues.includes(input)));
+}
+/**
+ * Creates a validator that asserts that the input is one of the values of the given enum.
+ *
+ * @param enumObject The enum to validate against.
+ */
+export function enumOf(enumObject) {
+    return isOneOf(...Object.values(enumObject));
+}
+/**
+ * Creates a validator that asserts that the input is null.
+ */
+export function exactlyNull() {
+    return valueValidators.null();
+}
+/**
+ * Creates a validator that asserts that the input is nullish.
+ */
+export function nullish() {
+    return valueValidators.nullish();
+}
+/**
+ * Creates a validator that asserts that the input is a number.
+ */
+export function number() {
+    return NumberSchema.base;
+}
+/**
+ * Creates a validator that validates the input has properties that pass their respective
+ * validators.
+ */
+export function object(propertyValidators) {
+    return ObjectSchema.base.extend(propertyValidators);
+}
+/**
+ * Returns a validator that asserts that the object's own enumerable properties has keys and
+ * values that match their respective validators.
+ *
+ * Prototype members are not included.
+ * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+ * to the key validator as '0'.
+ *
+ * To assume string keys, use {@link recordValues}
+ *
+ * @param keyValidator Validates each key.
+ * @param valueValidator Validates each value.
+ */
+export function record(keyValidator, valueValidator) {
+    return RecordSchema.base.record(keyValidator, valueValidator);
+}
+/**
+ * Returns a validator that asserts that the input object's own enumerable properties has
+ * string keys and values that match the given validator.
+ *
+ * Prototype members are not included.
+ *
+ * @param valueValidator Validates each value.
+ */
+export function recordValues(valueValidator) {
+    return RecordSchema.base.recordValues(valueValidator);
+}
+/**
+ * Returns a validator that asserts the input is a set with elements that match the given
+ * element validator.
+ * @param elementValidator
+ */
+export function set(elementValidator) {
+    return SetSchema.base.withElements(elementValidator);
+}
+/**
+ * Creates a validator that asserts that the input is type 'string'.
+ */
+export function string() {
+    return StringSchema.base;
+}
+/**
+ * Creates a validator that asserts that the input array is a tuple whose elements match
+ * the given validators.
+ *
+ * @param validators
+ */
+export function tuple(...validators) {
+    return ArraySchema.base.tuple(...validators);
+}
+/**
+ * Creates a validator that asserts that the input is type 'symbol'.
+ */
+export function symbol() {
+    return new ValueSchema(typeOfValidators.symbol);
+}
+/**
+ * Creates a validator that asserts that the input is strictly undefined.
+ */
+export function exactlyUndefined() {
+    return new ValueSchema(valueValidators.undefined());
+}
+/**
+ * Returns a custom
+ * @param expectationMessage
+ * @param isValid
+ * @param inputStringify
+ */
+export function custom(expectationMessage, isValid, inputStringify = (input) => stringifyForPrint(input, 500)) {
+    return new ValueSchema(createValidator(expectationMessage, isValid, inputStringify));
+}

package/dist/types/ts3.7/index.d.ts

@@ -0,0 +1,18 @@
+/** Auto-generated from build scripts */
+export * from './validation/validators';
+export * from './validation/typeOfValidators';
+export * from './validation/orValidators';
+export * from './validation/andValidators';
+export * from './validation/ValueSchema';
+export * from './validation/ValidatorWithPartial';
+export * from './validation/Validator';
+export * from './validation/StringSchema';
+export * from './validation/SetSchema';
+export * from './validation/SchemaBase';
+export * from './validation/RecordSchema';
+export * from './validation/PropertyValidator';
+export * from './validation/ObjectSchema';
+export * from './validation/NumberSchema';
+export * from './validation/FunctionSchema';
+export * from './validation/ArraySchema';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ts3.7/validation/ArraySchema.d.ts

@@ -0,0 +1,86 @@
+import { ElementType } from '@amazon/vinyl-util';
+import { ValueSchema } from './ValueSchema';
+import { Validator } from './Validator';
+export declare const arrayValidators: {
+    /**
+     * Creates a validator that asserts that the input is an array.
+     *
+     * Note: arrays can only be readonly by type system, there is no native readonly
+     * js array. This validator assumes mutability, use the ArraySchema readonly() method
+     * to cast to a readonly array.
+     */
+    readonly isArray: () => Validator<unknown[]>;
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    readonly withElements: <U>(elementValidator: Validator<U>) => Validator<U[], readonly unknown[]>;
+    /**
+     * Creates a validator that asserts that the input array is a tuple whose elements match
+     * the given validators.
+     *
+     * @param validators
+     */
+    readonly tuple: <U extends readonly any[]>(...validators: {
+        [Index in keyof U]: Validator<U[Index]>;
+    }) => Validator<{
+        [Index in keyof U]: U[Index];
+    }, readonly unknown[]>;
+    /**
+     * Creates a validator that validates the input array has the given minimum length.
+     * @param min The minimum number of elements (inclusive)
+     */
+    readonly minLength: (min: number) => Validator<readonly unknown[], readonly unknown[]>;
+    /**
+     *
+     * Creates a validator that validates the input array has the given maximum length.
+     * @param max The maximum number of elements (inclusive)
+     */
+    readonly maxLength: (max: number) => Validator<readonly unknown[], readonly unknown[]>;
+};
+export declare class ArraySchema<T extends readonly unknown[]> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base ArraySchema instance validating that the input is an Array.
+     */
+    static get base(): ArraySchema<unknown[]>;
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements<U>(elementValidator: Validator<U>): ArraySchema<(ElementType<T> & U)[]>;
+    /**
+     * Creates a validator that asserts that the input array is a tuple whose elements match
+     * the given validators.
+     *
+     * @param validators
+     */
+    tuple<U extends readonly any[]>(...validators: {
+        [Index in keyof U]: Validator<U[Index]>;
+    }): ArraySchema<{
+        [Index in keyof U]: U[Index];
+    }>;
+    /**
+     * Creates a validator that validates the input array has the given minimum length.
+     * @param min The minimum number of elements (inclusive)
+     */
+    minLength(min: number): ArraySchema<T>;
+    /**
+     *
+     * Creates a validator that validates the input array has the given maximum length.
+     * @param max The maximum number of elements (inclusive)
+     */
+    maxLength(max: number): ArraySchema<T>;
+    /**
+     * Casts to a readonly array.
+     * This is a shallow cast, elements of the array will not be changed.
+     */
+    readonly(): ArraySchema<Readonly<T>>;
+    /**
+     * Casts the type parameter.
+     */
+    cast<T extends readonly unknown[]>(): ArraySchema<T>;
+}
+//# sourceMappingURL=ArraySchema.d.ts.map

package/dist/types/ts3.7/validation/FunctionSchema.d.ts

@@ -0,0 +1,21 @@
+import { Fun } from '@amazon/vinyl-util';
+import { ValueSchema } from './ValueSchema';
+import { Validator } from './Validator';
+export declare const functionValidators: {
+    readonly length: (max: number) => Validator<Fun, Fun>;
+};
+export declare class FunctionSchema<T extends Fun> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base Function validator validating that the input is a function.
+     */
+    static get base(): FunctionSchema<Fun>;
+    length(max: number): FunctionSchema<T>;
+    /**
+     * Casts the function signature.
+     * Function signatures, except for their required number of parameters, cannot be
+     * meaningfully validated.
+     */
+    cast<T extends Fun>(): FunctionSchema<T>;
+}
+//# sourceMappingURL=FunctionSchema.d.ts.map

package/dist/types/ts3.7/validation/NumberSchema.d.ts

@@ -0,0 +1,100 @@
+import { ValueSchema } from './ValueSchema';
+import { Validator } from './Validator';
+export declare const numberValidators: {
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    readonly gte: (min: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    readonly gt: (min: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    readonly lte: (max: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    readonly lt: (max: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    readonly within: (min: number, max: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    readonly finite: () => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    readonly safeInteger: () => Validator<number, number>;
+};
+export declare class NumberSchema extends ValueSchema<number> {
+    private static _base;
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base(): NumberSchema;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    gte(min: number): this;
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    gt(min: number): this;
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    lte(max: number): this;
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    lt(max: number): this;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    within(min: number, max: number): this;
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    finite(): this;
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    safeInteger(): this;
+}
+//# sourceMappingURL=NumberSchema.d.ts.map

package/dist/types/ts3.7/validation/ObjectSchema.d.ts

@@ -0,0 +1,56 @@
+import { AnyRecord, IsPropertyOptional, PartialDeep } from '@amazon/vinyl-util';
+import { ValidatorWithPartial } from './ValidatorWithPartial';
+import { ValueSchema } from './ValueSchema';
+import { PropertyValidator } from '../validation/PropertyValidator';
+import { Equal } from '@amazon/vinyl-util/browserTestUtil';
+export declare const objectValidators: {
+    /**
+     * Creates a validator that validates the input has properties that pass their respective
+     * validators.
+     *
+     * @param propertyValidators
+     */
+    readonly properties: <U extends object>(propertyValidators: {
+        readonly [P in keyof U]-?: PropertyValidator<Required<U>[P], {
+            optional: IsPropertyOptional<U, P>;
+        }>;
+    }) => ValidatorWithPartial<U, object>;
+};
+/**
+ * Chainable object validators.
+ */
+export declare class ObjectSchema<T extends object> extends ValueSchema<T> implements ValidatorWithPartial<T, unknown> {
+    private static _base;
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base(): ObjectSchema<AnyRecord>;
+    /**
+     * Creates a validator that validates the input has properties that pass their respective
+     * validators.
+     *
+     * @param propertyValidators
+     */
+    extend<U extends object>(propertyValidators: ExtendedPropertyValidators<T, U>): ObjectSchema<U>;
+    /**
+     * Allows all properties to be undefined.
+     */
+    partial(): ObjectSchema<Partial<T>>;
+    /**
+     * Allows all recursive properties to be undefined.
+     */
+    partialDeep(): ObjectSchema<PartialDeep<T>>;
+    /**
+     * Casts the type parameter.
+     */
+    cast<T extends object>(): ObjectSchema<T>;
+}
+export type ExtendedPropertyValidators<T extends object, U extends object> = {
+    [K in keyof U as K extends keyof T ? Equal<U[K], T[K]> extends true ? never : K : K]-?: ExtendedPropertyValidator<U & T, K>;
+} & {
+    [K in keyof U as K extends keyof T ? Equal<U[K], T[K]> extends true ? K : never : never]?: ExtendedPropertyValidator<U & T, K>;
+};
+export type ExtendedPropertyValidator<U extends object, P extends keyof U> = PropertyValidator<Required<U>[P], {
+    optional: IsPropertyOptional<U, P>;
+}>;
+//# sourceMappingURL=ObjectSchema.d.ts.map

package/dist/types/ts3.7/validation/PropertyValidator.d.ts

@@ -0,0 +1,23 @@
+import { Validator } from '../validation/Validator';
+import { Merge } from '@amazon/vinyl-util';
+export interface PropertyValidatorOptions {
+    /**
+     * If true, when the property is omitted, the object schema should not fail validation.
+     */
+    readonly optional: boolean;
+}
+/**
+ * A utility type for overriding the options type on a validator.
+ * This will strip the types of the overridden options and set to the new types.
+ */
+export type PropertyValidatorWithOptions<ValidatorType extends PropertyValidator<any, any>, T, Options extends PropertyValidatorOptions> = Omit<ValidatorType, keyof PropertyValidator<any, any>> & PropertyValidator<T, Merge<ValidatorType['options'], Options>>;
+export interface PropertyValidator<T, PropertyOptionsType extends PropertyValidatorOptions> extends Validator<T> {
+    readonly options: PropertyOptionsType;
+    optional(): PropertyValidatorWithOptions<this, T, {
+        readonly optional: true;
+    }>;
+    required(): PropertyValidatorWithOptions<this, T, {
+        readonly optional: false;
+    }>;
+}
+//# sourceMappingURL=PropertyValidator.d.ts.map

package/dist/types/ts3.7/validation/RecordSchema.d.ts

@@ -0,0 +1,58 @@
+import { ReadonlyRecord } from '@amazon/vinyl-util';
+import { ValueSchema } from './ValueSchema';
+import { Validator } from './Validator';
+export declare const recordValidators: {
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has keys and
+     * values that match their respective validators.
+     *
+     * Prototype members are not included.
+     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+     * to the key validator as '0'.
+     *
+     * @param keyValidator Validates each key.
+     * @param valueValidator Validates each value.
+     */
+    readonly record: <K extends string | symbol, V>(keyValidator: Validator<K>, valueValidator: Validator<V>) => Validator<Record<K, V>, object>;
+};
+/**
+ * Chainable object validators for the Record type.
+ */
+export declare class RecordSchema<T extends ReadonlyRecord<keyof any, any>> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base(): RecordSchema<Record<keyof any, unknown>>;
+    private static get defaultKeyValidator();
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has keys and
+     * values that match their respective validators.
+     *
+     * Prototype members are not included.
+     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+     * to the key validator as '0'.
+     *
+     * @param keyValidator Validates each key.
+     * @param valueValidator Validates each value.
+     */
+    record<K extends string | symbol, V>(keyValidator: Validator<K>, valueValidator: Validator<V>): RecordSchema<ReadonlyRecord<K, V>>;
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has
+     * string keys and values that match the given validator.
+     *
+     * Prototype members are not included.
+     *
+     * @param valueValidator Validates each value.
+     */
+    recordValues<V>(valueValidator: Validator<V>): RecordSchema<Record<string, V>>;
+    /**
+     * Casts to a ReadonlyRecord
+     */
+    readonly(): RecordSchema<T extends Record<infer K, infer V> ? ReadonlyRecord<K, V> : never>;
+    /**
+     * Casts the type parameter.
+     */
+    cast<T extends ReadonlyRecord<keyof any, unknown>>(): RecordSchema<T>;
+}
+//# sourceMappingURL=RecordSchema.d.ts.map