@amazon/vinyl-validation 1.0.0

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

@@ -0,0 +1,88 @@
+import { type Invariant } from '@amazon/vinyl-util';
+/**
+ * Represents a validation failure.
+ */
+export interface ValidationErrorMessage {
+    readonly message: string;
+    readonly path: readonly string[];
+}
+export interface ValidationOptions {
+    /**
+     * If true, collect all validation errors.
+     * Default: false
+     */
+    readonly all?: boolean;
+}
+/**
+ * A Validator can assert that an input matches this validator's schema.
+ */
+export interface Validator<Output extends Input, in Input = unknown> {
+    /**
+     * Enforces T is in an invariant position.
+     * This prevents a validator with more strict rules is assigned to a less strict type, which
+     * can cause unexpected validation errors.
+     */
+    __type?: Invariant<Output>;
+    /**
+     * A short description of the validator.
+     */
+    readonly description: string;
+    /**
+     * Returns true if the input is valid according to this validator.
+     *
+     * @param input
+     */
+    readonly isValid: (input: Input) => input is Output;
+    /**
+     * Validates the provided input, returning a list of error messages, or an empty array if the
+     * input passes this validator.
+     *
+     * @param input The input to validate.
+     * @param options Validation options.
+     * @param path The current field path to this validator.
+     * @return Returns an array of validation failures. If `options.all` is not true, only the
+     * first error will be returned.
+     */
+    readonly validate: (input: Input, options?: ValidationOptions, path?: readonly string[]) => readonly ValidationErrorMessage[];
+    /**
+     * Validates the given input, asserting that the input is type `T`.
+     * If the input is not valid, a {@link ValidationError} will be thrown.
+     *
+     * @param input The input to validate.
+     * @param origin The error origin. `ErrorOrigin.API` by default.
+     * @param path The current field path to this validator.
+     * @return Returns the input, cast as the validated type T
+     */
+    readonly assert: (input: Input, origin?: string, path?: readonly string[]) => asserts input is Output;
+}
+/**
+ * Creates a message string for a ValidationErrorMessage based on the input and its expectation.
+ *
+ * @param expectationMessage
+ * @param input
+ * @param path
+ * @param inputStringify
+ */
+export declare function createValidationExpectationMessage<Input>(expectationMessage: string, input: Input, path: readonly string[], inputStringify?: (input: Input) => string): string;
+/**
+ * Creates a new basic validator.
+ *
+ * For a deep validator which has sub-fields, use {@link createDeepValidator}.
+ *
+ * @param expectationMessage The message to use to describe what is expected. This will be used in
+ * the error message template.
+ * @param isValid Returns true if the given input is valid.
+ * @param inputStringify Stringifies the input for use as the actual `{actual}` token in the validation
+ * expectation template. Default is `stringifyForPrint` with a 500 character max length.
+ */
+export declare function createValidator<Output extends Input, Input = unknown>(expectationMessage: string, isValid: (input: Input) => boolean, inputStringify?: (input: Input) => string): Validator<Output, Input>;
+/**
+ * Creates a new deep validator.
+ *
+ * For a shallow validator which validates one value, use {@link createValidator}.
+ *
+ * @param description Describes the validator.
+ * @param validate Returns an array of validation failures.
+ */
+export declare function createDeepValidator<Output extends Input, Input = unknown>(description: string, validate: (input: Input, options: ValidationOptions, path: readonly string[]) => readonly ValidationErrorMessage[]): Validator<Output, Input>;
+//# sourceMappingURL=Validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../../../src/validation/Validator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,oBAAoB,CAAA;AAGpE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACnC;AAED,MAAM,WAAW,iBAAiB;IAC9B;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,MAAM,SAAS,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,OAAO;IAC/D;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,IAAI,MAAM,CAAA;IAEnD;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,EAAE,CACf,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,iBAAiB,EAC3B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,KACvB,SAAS,sBAAsB,EAAE,CAAA;IAEtC;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,EAAE,CACb,KAAK,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,KACvB,OAAO,CAAC,KAAK,IAAI,MAAM,CAAA;CAC/B;AAgBD;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAAC,KAAK,EACpD,kBAAkB,EAAE,MAAM,EAC1B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,cAAc,GAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MACD,GAClC,MAAM,CAMR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,MAAM,SAAS,KAAK,EAAE,KAAK,GAAG,OAAO,EACjE,kBAAkB,EAAE,MAAM,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,EAClC,cAAc,GAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MACD,GAClC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAgD1B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,KAAK,EAAE,KAAK,GAAG,OAAO,EACrE,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,CACN,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,SAAS,MAAM,EAAE,KACtB,SAAS,sBAAsB,EAAE,GACvC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CA4B1B"}

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

@@ -0,0 +1,95 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ValidationError } from '@amazon/vinyl-util';
+import { stringifyForPrint, substitute } from '@amazon/vinyl-util';
+/**
+ * @private
+ */
+const validatorLocale = {
+    /**
+     * The expectation template string with the following replacement tokens:
+     *
+     * `{expected}` - The expected description.
+     * `{actual}` - The actual value.
+     * `{path}` - The path, dot separated.
+     */
+    template: 'Expected: {expected}, but was: {actual}. At: {path}',
+};
+/**
+ * Creates a message string for a ValidationErrorMessage based on the input and its expectation.
+ *
+ * @param expectationMessage
+ * @param input
+ * @param path
+ * @param inputStringify
+ */
+export function createValidationExpectationMessage(expectationMessage, input, path, inputStringify = (input) => stringifyForPrint(input, 500)) {
+    return substitute(validatorLocale.template, {
+        expected: expectationMessage,
+        actual: inputStringify(input),
+        path: path.join('.'),
+    });
+}
+/**
+ * Creates a new basic validator.
+ *
+ * For a deep validator which has sub-fields, use {@link createDeepValidator}.
+ *
+ * @param expectationMessage The message to use to describe what is expected. This will be used in
+ * the error message template.
+ * @param isValid Returns true if the given input is valid.
+ * @param inputStringify Stringifies the input for use as the actual `{actual}` token in the validation
+ * expectation template. Default is `stringifyForPrint` with a 500 character max length.
+ */
+export function createValidator(expectationMessage, isValid, inputStringify = (input) => stringifyForPrint(input, 500)) {
+    return {
+        description: expectationMessage,
+        isValid(input) {
+            return isValid(input);
+        },
+        validate(input, _, path = []) {
+            if (!isValid(input)) {
+                return [
+                    {
+                        message: createValidationExpectationMessage(expectationMessage, input, path, inputStringify),
+                        path,
+                    },
+                ];
+            }
+            return [];
+        },
+        assert: (input, origin, path = []) => {
+            if (!isValid(input)) {
+                throw new ValidationError(createValidationExpectationMessage(expectationMessage, input, path, inputStringify), origin, path);
+            }
+        },
+    };
+}
+/**
+ * Creates a new deep validator.
+ *
+ * For a shallow validator which validates one value, use {@link createValidator}.
+ *
+ * @param description Describes the validator.
+ * @param validate Returns an array of validation failures.
+ */
+export function createDeepValidator(description, validate) {
+    return {
+        description,
+        isValid(input) {
+            return validate(input, { all: false }, []).length === 0;
+        },
+        validate(input, options, path = []) {
+            return validate(input, options ?? { all: false }, path);
+        },
+        assert: (input, origin, path = []) => {
+            const errors = validate(input, { all: false }, path);
+            if (errors.length) {
+                const error = errors[0];
+                throw new ValidationError(error.message, origin, error.path);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { PartialDeep } from '@amazon/vinyl-util';
+import type { Validator } from './Validator';
+export interface ValidatorWithPartial<Output extends Input, Input> extends Validator<Output, Input> {
+    partial(): ValidatorWithPartial<Partial<Output> & Input, Input>;
+    partialDeep(): ValidatorWithPartial<PartialDeep<Output> & Input, Input>;
+}
+/**
+ * Returns true if the given validator is an object validator.
+ * @param validator
+ */
+export declare function isValidatorWithPartial<Output extends Input, Input>(validator: Validator<Output, Input>): validator is ValidatorWithPartial<Output, Input>;
+/**
+ * If the given validator is an object validator, it will be cloned to a deep partial validator,
+ * otherwise returns the validator as is.
+ *
+ * @param validator
+ */
+export declare function maybeToDeepPartial(validator: Validator<any>): Validator<any>;
+/**
+ * If the given validator is an object validator, it will be cloned to a partial validator,
+ * otherwise returns the validator as is.
+ *
+ * @param validator
+ */
+export declare function maybeToPartial(validator: Validator<any>): Validator<any>;
+//# sourceMappingURL=ValidatorWithPartial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValidatorWithPartial.d.ts","sourceRoot":"","sources":["../../../../src/validation/ValidatorWithPartial.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,MAAM,WAAW,oBAAoB,CACjC,MAAM,SAAS,KAAK,EACpB,KAAK,CACP,SAAQ,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;IAC9B,OAAO,IAAI,oBAAoB,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,CAAA;IAC/D,WAAW,IAAI,oBAAoB,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,CAAA;CAC1E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,SAAS,KAAK,EAAE,KAAK,EAC9D,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,GACpC,SAAS,IAAI,oBAAoB,CAAC,MAAM,EAAE,KAAK,CAAC,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAI5E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAExE"}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns true if the given validator is an object validator.
+ * @param validator
+ */
+export function isValidatorWithPartial(validator) {
+    return 'partial' in validator && 'partialDeep' in validator;
+}
+/**
+ * If the given validator is an object validator, it will be cloned to a deep partial validator,
+ * otherwise returns the validator as is.
+ *
+ * @param validator
+ */
+export function maybeToDeepPartial(validator) {
+    return isValidatorWithPartial(validator)
+        ? validator.partialDeep()
+        : validator;
+}
+/**
+ * If the given validator is an object validator, it will be cloned to a partial validator,
+ * otherwise returns the validator as is.
+ *
+ * @param validator
+ */
+export function maybeToPartial(validator) {
+    return isValidatorWithPartial(validator) ? validator.partial() : validator;
+}

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

@@ -0,0 +1,52 @@
+import { SchemaBase } from './SchemaBase';
+import type { Validator } from './Validator';
+export declare const valueValidators: {
+    readonly any: () => Validator<any>;
+    /**
+     * Creates a validator that asserts that the input is nullish.
+     */
+    readonly nullish: () => Validator<null | undefined>;
+    /**
+     * Creates a validator that asserts that the input is strictly null.
+     */
+    readonly null: () => Validator<null>;
+    /**
+     * Creates a validator that asserts that the input is strictly undefined.
+     */
+    readonly undefined: () => Validator<undefined>;
+};
+export declare class ValueSchema<T> extends SchemaBase<T> {
+    /**
+     * Prepends this validator allowing for null or undefined.
+     */
+    maybe(): ValueSchema<T | undefined | null>;
+    /**
+     * Prepends this validator allowing for null.
+     */
+    orNull(): ValueSchema<T | null>;
+    /**
+     * Prepends this validator allowing for undefined.
+     */
+    orUndefined(): ValueSchema<T | undefined>;
+    /**
+     * Returns a validator that asserts if this validator and the next passes.
+     *
+     * @see andValidators
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema intersecting this validator and the next.
+     */
+    and<U>(nextValidator: Validator<U>): ValueSchema<T & U>;
+    /**
+     * Returns a validator that asserts if this validator or the next passes.
+     *
+     * Implementation note:
+     * subclasses should not change the schema instance returned unless all chainable validators
+     * accept input type 'unknown'.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema providing the union of this validator and the next.
+     */
+    or<U>(nextValidator: Validator<U, any>): ValueSchema<T | U>;
+}
+//# sourceMappingURL=ValueSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSchema.d.ts","sourceRoot":"","sources":["../../../../src/validation/ValueSchema.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAS5C,eAAO,MAAM,eAAe;wBACjB,SAAS,CAAC,GAAG,CAAC;IAKrB;;OAEG;4BACQ,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC;IAItC;;OAEG;yBACK,SAAS,CAAC,IAAI,CAAC;IAIvB;;OAEG;8BACU,SAAS,CAAC,SAAS,CAAC;CAG3B,CAAA;AAEV,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IAC7C;;OAEG;IACH,KAAK,IAAI,WAAW,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;IAI1C;;OAEG;IACH,MAAM,IAAI,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC;IAI/B;;OAEG;IACH,WAAW,IAAI,WAAW,CAAC,CAAC,GAAG,SAAS,CAAC;IAIzC;;;;;;;OAOG;IACH,GAAG,CAAC,CAAC,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;IAIvD;;;;;;;;;OASG;IACH,EAAE,CAAC,CAAC,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;CAG9D"}

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { andValidators } from './andValidators';
+import { orValidators } from './orValidators';
+import { SchemaBase } from './SchemaBase';
+import { createValidator } from './Validator';
+const locale = {
+    null: 'null',
+    nullish: 'nullish',
+    undefined: 'undefined',
+};
+export const valueValidators = {
+    any() {
+        // no need for localization, validator cannot fail.
+        return createValidator('', () => true);
+    },
+    /**
+     * Creates a validator that asserts that the input is nullish.
+     */
+    nullish() {
+        return createValidator(locale.nullish, (input) => input == null);
+    },
+    /**
+     * Creates a validator that asserts that the input is strictly null.
+     */
+    null() {
+        return createValidator(locale.null, (input) => input === null);
+    },
+    /**
+     * Creates a validator that asserts that the input is strictly undefined.
+     */
+    undefined() {
+        return createValidator(locale.undefined, (input) => input === undefined);
+    },
+};
+export class ValueSchema extends SchemaBase {
+    /**
+     * Prepends this validator allowing for null or undefined.
+     */
+    maybe() {
+        return this.or(valueValidators.nullish());
+    }
+    /**
+     * Prepends this validator allowing for null.
+     */
+    orNull() {
+        return this.or(valueValidators.null());
+    }
+    /**
+     * Prepends this validator allowing for undefined.
+     */
+    orUndefined() {
+        return this.or(valueValidators.undefined());
+    }
+    /**
+     * Returns a validator that asserts if this validator and the next passes.
+     *
+     * @see andValidators
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema intersecting this validator and the next.
+     */
+    and(nextValidator) {
+        return new ValueSchema(nextValidator, this, andValidators);
+    }
+    /**
+     * Returns a validator that asserts if this validator or the next passes.
+     *
+     * Implementation note:
+     * subclasses should not change the schema instance returned unless all chainable validators
+     * accept input type 'unknown'.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema providing the union of this validator and the next.
+     */
+    or(nextValidator) {
+        return new ValueSchema(nextValidator, this, orValidators);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Validator } from './Validator';
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>): Validator<A & B, Input>;
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, C, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>, validatorC: Validator<C, any>): Validator<A & B & C, Input>;
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, C, D, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>): Validator<A & B & C & D, any>;
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, C, D, E, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>, validatorE: Validator<E, any>): Validator<A & B & C & D & E, any>;
+export declare function andValidators(...validators: Validator<any, any>[]): Validator<any, any>;
+//# sourceMappingURL=andValidators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"andValidators.d.ts","sourceRoot":"","sources":["../../../../src/validation/andValidators.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAoC5C;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,KAAK,EACnD,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,EAC/B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAA;AAE1B;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EACtD,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,EAC/B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAA;AAE9B;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EACzD,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,EAC/B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAEhC;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAC5D,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,EAC/B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAEpC,wBAAgB,aAAa,CACzB,GAAG,UAAU,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GACrC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA"}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { substitute } from '@amazon/vinyl-util';
+import { createDeepValidator } from './Validator';
+/*
+ * @brief
+ * andValidators will intersect an arbitrary number of validators.
+ *
+ * While in most cases validating that an input passes two validators, the asserted output is the
+ * intersection of those two validator outputs, this is not always the case.
+ * For example, take two validators with outputs `A[]` and `B[]`, their combined validated output
+ * type would be `(A & B)[]`, not `A[] & B[]`. Use casting when necessary.
+ *
+ * Also note that there is no contravariance safety with the chained validator inputs. That is,
+ * there's no compile-time checking that validatorB accepts an input that is the super of
+ *  validatorA's output.
+ */
+/**
+ * @private
+ */
+const locale = {
+    /**
+     * {value} The child validators' descriptions, joined with `separator`.
+     *
+     * groupings of and validators is unimportant,
+     * and(and(a, b), c) is the same as and(a, and(b, c)), so `a & b & c` is an accurate
+     * representation for either.
+     */
+    template: '{value}',
+    /**
+     * The separator with which to join child validator descriptions.
+     */
+    separator: ' & ',
+};
+export function andValidators(...validators) {
+    return createDeepValidator(substitute(locale.template, {
+        value: validators.map((v) => v.description).join(locale.separator),
+    }), (input, options, path) => {
+        for (const validator of validators) {
+            const errors = validator.validate(input, options, path);
+            if (errors.length)
+                return errors;
+        }
+        return [];
+    });
+}

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

@@ -0,0 +1,19 @@
+import type { Validator } from './Validator';
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B>(validatorA: Validator<A, any>, validatorB: Validator<B, any>): Validator<A | B, any>;
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B, C>(validatorA: Validator<A, any>, validatorB: Validator<B, any>, validatorC: Validator<C, any>): Validator<A | B | C, any>;
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B, C, D>(validatorA: Validator<A, any>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>): Validator<A | B | C | D, any>;
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B, C, D, E>(validatorA: Validator<A, any>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>, validatorE: Validator<E, any>): Validator<A | B | C | D | E, any>;
+export declare function orValidators(...validators: Validator<any, any>[]): Validator<any, any>;
+//# sourceMappingURL=orValidators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orValidators.d.ts","sourceRoot":"","sources":["../../../../src/validation/orValidators.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAA0B,SAAS,EAAE,MAAM,aAAa,CAAA;AA+BpE;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAExB;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAE5B;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAEhC;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACtC,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAC7B,UAAU,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAC9B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAEpC,wBAAgB,YAAY,CACxB,GAAG,UAAU,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GACrC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA"}

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { substitute } from '@amazon/vinyl-util';
+import { createDeepValidator, createValidationExpectationMessage, } from './Validator';
+/*
+ * @brief
+ * orValidators will union an arbitrary number of validators.
+ * input type is always type any; it's not strictly necessary for all validators to accept the same
+ * input type. For example, if validatorA asserts that a value is not null, validatorB can safely
+ * assume its input is not null.
+ * output type will be the union of the validator outputs up to 5 validators, 6 or more will be
+ * type any.
+ */
+/**
+ * @private
+ */
+const locale = {
+    /**
+     * {value} - The child validators' descriptions, joined with `separator`.
+     */
+    template: '({value})',
+    /**
+     * The separator with which to join child validator descriptions.
+     */
+    separator: ' | ',
+};
+/**
+ * Validates that one of the given validators pass.
+ *
+ * If all validators fail, the validator that produced an error at the deepest path will have its
+ * error message bubbled. If all validators failed at the current depth, a concatenation of
+ * validator descriptions will be used.
+ *
+ * For example:
+ * `orValidators(number(), string()).validate(false)` will produce the message:
+ * 'Expected (number | string), but was false, At: '
+ *
+ * And:
+ * `orValidators(number(), object({ childProp: number() })).validate({ childProp: 'not-a-number' })`
+ * will produce:
+ * 'Expected number, but was "not-a-number", At: childProp'
+ *
+ * @param validators The validators to test.
+ */
+export function orValidators(...validators) {
+    const description = substitute(locale.template, {
+        value: validators.map((v) => v.description).join(locale.separator),
+    });
+    return createDeepValidator(description, (input, options, path) => {
+        let longestErrors = [];
+        let longestPath = 0;
+        for (const validator of validators) {
+            const errors = validator.validate(input, options, path);
+            if (!errors.length)
+                return errors;
+            // Take the deepest error to bubble.
+            const pathLength = errors.reduce((max, m) => Math.max(m.path.length, max), 0);
+            if (pathLength >= longestPath) {
+                longestErrors = errors;
+                longestPath = pathLength;
+            }
+        }
+        return longestPath > path.length
+            ? longestErrors
+            : [
+                {
+                    message: createValidationExpectationMessage(description, input, path),
+                    path,
+                },
+            ];
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { Validator } from './Validator';
+/**
+ * Validators asserting typeof input matches the expected value.
+ *
+ * Note: bigint is omitted; not all supported platforms can use BigInt.
+ */
+export declare const typeOfValidators: {
+    readonly boolean: Validator<boolean, unknown>;
+    readonly func: Validator<import("@amazon/vinyl-util").Fun, unknown>;
+    readonly number: Validator<number, unknown>;
+    readonly object: Validator<object, unknown>;
+    readonly string: Validator<string, unknown>;
+    readonly symbol: Validator<symbol, unknown>;
+};
+//# sourceMappingURL=typeOfValidators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeOfValidators.d.ts","sourceRoot":"","sources":["../../../../src/validation/typeOfValidators.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAyC5C;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;CAmBnB,CAAA"}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { substitute } from '@amazon/vinyl-util';
+import { createValidator } from './Validator';
+/**
+ * @private
+ */
+const locale = {
+    template: 'type {value}',
+};
+/**
+ * Creates a validator that validates that the input is not nullish and its `typeof` matches the
+ * expected value.
+ *
+ * Note: while `typeof null === 'object'`, `typeOfValidator('object')` will assert that its
+ * input is not nullish.
+ *
+ * @param expected
+ */
+function typeOfValidator(expected) {
+    return createValidator(substitute(locale.template, { value: expected }), (input) => {
+        return input != null && typeof input === expected;
+    });
+}
+const typeOfValidatorCache = {};
+function cachedTypeOfValidator(type) {
+    if (!(type in typeOfValidatorCache)) {
+        typeOfValidatorCache[type] = typeOfValidator(type);
+    }
+    return typeOfValidatorCache[type];
+}
+/**
+ * Validators asserting typeof input matches the expected value.
+ *
+ * Note: bigint is omitted; not all supported platforms can use BigInt.
+ */
+export const typeOfValidators = {
+    get boolean() {
+        return cachedTypeOfValidator('boolean');
+    },
+    get func() {
+        return cachedTypeOfValidator('function');
+    },
+    get number() {
+        return cachedTypeOfValidator('number');
+    },
+    get object() {
+        return cachedTypeOfValidator('object');
+    },
+    get string() {
+        return cachedTypeOfValidator('string');
+    },
+    get symbol() {
+        return cachedTypeOfValidator('symbol');
+    },
+};