@fgv/ts-utils 5.0.1-9 → 5.0.1

package/dist/packlets/validation/genericValidator.js

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail, succeed } from '../base';
+import { ValidatorTraits } from './traits';
+/**
+ * Generic base implementation for an in-place {@link Validation.Validator | Validator}.
+ * @public
+ */
+export class GenericValidator {
+    /**
+     * Constructs a new {@link Validation.Base.GenericValidator | GenericValidator<T>}.
+     * @param params - The {@link Validation.Base.GenericValidatorConstructorParams | constructor params}
+     * used to configure validation.
+     */
+    constructor(params) {
+        var _a;
+        if (!params.validator) {
+            throw new Error('No validator function supplied');
+        }
+        this._validator = params.validator;
+        this._options = (_a = params.options) !== null && _a !== void 0 ? _a : {};
+        this.traits = new ValidatorTraits(params.traits);
+    }
+    /**
+     * {@inheritdoc Validation.Validator.isOptional}
+     */
+    get isOptional() {
+        return this.traits.isOptional;
+    }
+    /**
+     * {@inheritdoc Validation.Validator.brand}
+     */
+    get brand() {
+        return this.traits.brand;
+    }
+    /**
+     * {@inheritdoc Validation.Validator.validate}
+     */
+    validate(from, context) {
+        const result = this._validator(from, this._context(context), this);
+        if (typeof result === 'boolean') {
+            return result ? succeed(from) : fail('Invalid value');
+        }
+        return result;
+    }
+    /**
+     * {@inheritdoc Validation.Validator.convert}
+     */
+    convert(from, context) {
+        const result = this._validator(from, this._context(context), this);
+        if (typeof result === 'boolean') {
+            return result ? succeed(from) : fail('Invalid value');
+        }
+        return result;
+    }
+    /**
+     * {@inheritdoc Validation.Validator.validateOptional}
+     */
+    validateOptional(from, context) {
+        return from === undefined ? succeed(undefined) : this.validate(from, context);
+    }
+    /**
+     * {@inheritdoc Validation.Validator.guard}
+     */
+    guard(from, context) {
+        return this._validator(from, this._context(context), this) === true;
+    }
+    /**
+     * {@inheritdoc Validation.Validator.optional}
+     */
+    optional() {
+        return new GenericValidator({
+            validator: (from, context, self) => {
+                return from === undefined || this._validator(from, this._context(context), this);
+            },
+            traits: { isOptional: true }
+        });
+    }
+    /**
+     * {@inheritdoc Validation.Validator.withConstraint}
+     */
+    withConstraint(constraint, trait) {
+        trait = trait !== null && trait !== void 0 ? trait : { type: 'function' };
+        return new GenericValidator({
+            validator: (from, context, self) => {
+                const result = this._validator(from, this._context(context), this);
+                if (result === true) {
+                    const constraintResult = constraint(from);
+                    if (typeof constraintResult === 'boolean') {
+                        return constraintResult
+                            ? true
+                            : fail(`Invalid value "${JSON.stringify(from)}":  does not meet constraint.`);
+                    }
+                    return constraintResult;
+                }
+                return result;
+            },
+            traits: { constraints: [trait] }
+        });
+    }
+    /**
+     * {@inheritdoc Validation.Validator.brand}
+     */
+    withBrand(brand) {
+        if (this.brand) {
+            throw new Error(`Cannot replace existing brand "${this.brand}" with "${brand}".`);
+        }
+        return new GenericValidator({
+            validator: (from, context, self) => {
+                return this._validator(from, this._context(context), this);
+            },
+            traits: { brand }
+        });
+    }
+    /**
+     * {@inheritdoc Validation.Validator.withFormattedError}
+     */
+    withFormattedError(formatter) {
+        return new GenericValidator({
+            validator: (from, context, self) => {
+                const result = this._validator(from, this._context(context), this);
+                if (result === true) {
+                    return true;
+                }
+                /* c8 ignore next - defense in depth */
+                const message = result === false ? undefined : result.message;
+                return fail(formatter(from, message, this._context(context)));
+            }
+        });
+    }
+    /**
+     * Gets a default or explicit context.
+     * @param explicitContext - Optional explicit context.
+     * @returns The appropriate context to use.
+     * @internal
+     */
+    _context(explicitContext) {
+        return explicitContext !== null && explicitContext !== void 0 ? explicitContext : this._options.defaultContext;
+    }
+}
+//# sourceMappingURL=genericValidator.js.map

package/dist/packlets/validation/index.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export * from './common';
+export * from './traits';
+export * from './validator';
+import * as Classes from './classes';
+import * as Base from './genericValidator';
+import * as Validators from './validators';
+export { Base, Classes, Validators };
+//# sourceMappingURL=index.js.map

package/dist/packlets/validation/number.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail } from '../base';
+import { GenericValidator } from './genericValidator';
+/**
+ * An in-place {@link Validation.Validator | Validator} for `number` values.
+ * @public
+ */
+export class NumberValidator extends GenericValidator {
+    /**
+     * Constructs a new {@link Validation.Classes.NumberValidator | NumberValidator}.
+     * @param params - Optional {@link Validation.Classes.NumberValidatorConstructorParams | init params} for the
+     * new {@link Validation.Classes.NumberValidator | NumberValidator}.
+     */
+    constructor(params) {
+        /* c8 ignore next 1 */
+        params = params !== null && params !== void 0 ? params : {};
+        super(Object.assign({ validator: NumberValidator.validateNumber }, params));
+    }
+    /**
+     * Static method which validates that a supplied `unknown` value is a `number`.
+     * @param from - The `unknown` value to be tested.
+     * @returns Returns `true` if `from` is a `number`, or {@link Failure} with an error
+     * message if not.
+     */
+    static validateNumber(from) {
+        if (typeof from === 'number') {
+            return true;
+        }
+        return fail(`"${from}": not a number`);
+    }
+}
+//# sourceMappingURL=number.js.map

package/dist/packlets/validation/object.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail } from '../base';
+import { ValidatorBase } from './validatorBase';
+import { FieldValidator } from './field';
+/**
+ * In-place {@link Validation.Validator | Validator} for an object of type `<T>`.
+ * @remarks
+ * By default, succeeds if all of the required fields exist and are validate, and fails if
+ * any required fields do not exist or are invalid.  See {@link Validation.Classes.ObjectValidatorOptions}
+ * for other validation options.
+ * @public
+ */
+export class ObjectValidator extends ValidatorBase {
+    /**
+     * Constructs a new {@link Validation.Classes.ObjectValidator | ObjectValidator<T>}.
+     * @param fields - A {@link Validation.Classes.FieldValidators | FieldValidators<T>} containing
+     * a {@link Validation.Validator | Validator} for each field.
+     * @param options - An optional {@link Validation.Classes.ObjectValidatorOptions} to configure
+     * validation.
+     */
+    constructor(params) {
+        var _a;
+        super(params);
+        this.fields = params.fields;
+        this.options = (_a = params.options) !== null && _a !== void 0 ? _a : {};
+        this._innerValidators = ObjectValidator._resolveValidators(this.fields, this.options);
+        this._allowedFields =
+            this.options.strict === true ? new Set(Object.keys(this.fields)) : undefined;
+    }
+    /**
+     * Creates the actual {@link Validation.Classes.FieldValidators | FieldValidators<T>} to be
+     * used by this converter by applying any options or traits defined in the options
+     * to the field converters passed to the constructor.
+     * @param fields - The base {@link Validation.Classes.FieldValidators | FieldValidators<T>} passed
+     * in to the constructor.
+     * @param options - The {@link Validation.Classes.ObjectValidatorOptions | object validator options}
+     * passed in to the constructor.
+     * @returns A new {@link Validation.Classes.FieldValidators | FieldValidators} with the fully-configured
+     * individual {@link Validation.Validator | field validators} to be applied.
+     * @internal
+     */
+    static _resolveValidators(fields, options) {
+        var _a;
+        const resolved = {};
+        for (const key in fields) {
+            if (fields[key]) {
+                /* c8 ignore next */
+                const optional = fields[key].isOptional || ((_a = options === null || options === void 0 ? void 0 : options.optionalFields) === null || _a === void 0 ? void 0 : _a.includes(key));
+                resolved[key] = new FieldValidator(key, fields[key], { optional });
+            }
+        }
+        return resolved;
+    }
+    /**
+     * Creates a new {@link Validation.Classes.ObjectValidator | ObjectValidator} derived from this one but with
+     * new optional properties as specified by a supplied
+     * {@link Validation.Classes.ObjectValidatorOptions | ObjectValidatorOptions<T>}.
+     * @param options - The {@link Validation.Classes.ObjectValidatorOptions | options} to be applied to the new
+     * {@link Validation.Classes.ObjectValidator | validator}.
+     * @returns A new {@link Validation.Classes.ObjectValidator | ObjectValidator} with the additional optional
+     * source properties.
+     */
+    partial(options) {
+        /* c8 ignore next */
+        options = options !== null && options !== void 0 ? options : {};
+        return new ObjectValidator({
+            fields: this.fields,
+            options: Object.assign(Object.assign({}, this.options), options),
+            traits: this.traits
+        });
+    }
+    /**
+     * Creates a new {@link Validation.Classes.ObjectValidator | ObjectValidator} derived from this one but with
+     * new optional properties as specified by a supplied array of `keyof T`.
+     * @param addOptionalProperties - The keys to be made optional.
+     * @returns A new {@link Validation.Classes.ObjectValidator | ObjectValidator} with the additional optional
+     * source properties.
+     */
+    addPartial(addOptionalFields) {
+        var _a;
+        return this.partial({
+            optionalFields: [...((_a = this.options.optionalFields) !== null && _a !== void 0 ? _a : []), ...addOptionalFields]
+        });
+    }
+    /**
+     * {@inheritdoc Validation.ValidatorBase._validate}
+     * @internal
+     */
+    _validate(from, context, self) {
+        if (typeof from !== 'object' || from === null || Array.isArray(from)) {
+            return fail('source is not an object');
+        }
+        // eslint bug thinks key is used before defined
+        const converted = {};
+        const errors = [];
+        for (const key in this._innerValidators) {
+            if (this._innerValidators[key]) {
+                const result = this._innerValidators[key].validate(from, context);
+                if (result.success && result.value !== undefined) {
+                    converted[key] = result.value;
+                }
+                else if (result.isFailure()) {
+                    errors.push(result.message);
+                }
+            }
+        }
+        if (this._allowedFields) {
+            const invalid = Object.keys(from).filter((k) => !this._allowedFields.has(k));
+            invalid.forEach((key) => errors.push(`${key}: unexpected field in source object.`));
+        }
+        return errors.length === 0 ? true : fail(errors.join('\n'));
+    }
+}
+//# sourceMappingURL=object.js.map

package/dist/packlets/validation/oneOf.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2024 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail } from '../base';
+import { ValidatorBase } from './validatorBase';
+/**
+ * An in-place {@link Validator | Validator} which validates that a supplied
+ * value matches one of several other validators.
+ * @public
+ */
+export class OneOfValidator extends ValidatorBase {
+    /**
+     * Constructs a new {@link Validation.Classes.OneOfValidator | OneOfValidator}.
+     * @param params - Optional {@link Validation.Classes.OneOfValidatorConstructorParams | init params} for the
+     * new {@link Validation.Classes.OneOfValidator | OneOfValidator}.
+     */
+    constructor(params) {
+        var _a;
+        super(params);
+        this._validators = params.validators;
+        this.options = (_a = params.options) !== null && _a !== void 0 ? _a : {};
+    }
+    /**
+     * Static method which validates that a supplied `unknown` value matches at least one
+     * of the configured validators.
+     * @param from - The `unknown` value to be tested.
+     * @param context - Optional validation context will be propagated to element validator.
+     * @param self - Optional self-reference for recursive validation.
+     * @returns Returns `true` if `from` is an `array` of valid elements, or
+     * {@link Failure} with an error message if not.
+     */
+    _validate(from, context, self) {
+        const found = this._validators.some((v) => v.validate(from).success);
+        if (found) {
+            return true;
+        }
+        return fail(`value "${from}" does not match any validator.`);
+    }
+}
+//# sourceMappingURL=oneOf.js.map

package/dist/packlets/validation/string.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail } from '../base';
+import { GenericValidator } from './genericValidator';
+/**
+ * An in-place {@link Validation.Validator | Validator} for `string` values.
+ * @public
+ */
+export class StringValidator extends GenericValidator {
+    /**
+     * Constructs a new {@link Validation.Classes.StringValidator | StringValidator}.
+     * @param params - Optional {@link Validation.Classes.StringValidatorConstructorParams | init params}
+     * for the new {@link Validation.Classes.StringValidator | StringValidator}.
+     */
+    constructor(params) {
+        /* c8 ignore next */
+        params = params !== null && params !== void 0 ? params : {};
+        super(Object.assign({ validator: StringValidator.validateString }, params));
+    }
+    /**
+     * Static method which validates that a supplied `unknown` value is a `string`.
+     * @param from - The `unknown` value to be tested.
+     * @returns Returns `true` if `from` is a `string`, or {@link Failure} with an error
+     * message if not.
+     */
+    static validateString(from) {
+        if (typeof from === 'string') {
+            return true;
+        }
+        return fail(`"${from}": not a string`);
+    }
+}
+//# sourceMappingURL=string.js.map

package/dist/packlets/validation/traits.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Default {@link Validation.ValidatorTraitValues | validation traits}.
+ * @public
+ */
+export const defaultValidatorTraits = {
+    isOptional: false,
+    constraints: []
+};
+/**
+ * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
+ * @public
+ */
+export class ValidatorTraits {
+    /**
+     * Constructs a new {@link Validation.ValidatorTraits | ValidatorTraits} optionally
+     * initialized with the supplied base and initial values.
+     * @remarks
+     * Initial values take priority over base values, which fall back to the global default values.
+     * @param init - Partial initial values to be set in the resulting {@link Validation.Validator | Validator}.
+     * @param base - Base values to be used when no initial values are present.
+     */
+    constructor(init, base) {
+        var _a, _b, _c, _d, _e, _f;
+        /* c8 ignore next 2 */
+        this.isOptional = (_b = (_a = init === null || init === void 0 ? void 0 : init.isOptional) !== null && _a !== void 0 ? _a : base === null || base === void 0 ? void 0 : base.isOptional) !== null && _b !== void 0 ? _b : defaultValidatorTraits.isOptional;
+        this.brand = (_d = (_c = init === null || init === void 0 ? void 0 : init.brand) !== null && _c !== void 0 ? _c : base === null || base === void 0 ? void 0 : base.brand) !== null && _d !== void 0 ? _d : defaultValidatorTraits.brand;
+        this.constraints = [
+            ...defaultValidatorTraits.constraints,
+            /* c8 ignore next 1 */
+            ...((_e = base === null || base === void 0 ? void 0 : base.constraints) !== null && _e !== void 0 ? _e : []),
+            ...((_f = init === null || init === void 0 ? void 0 : init.constraints) !== null && _f !== void 0 ? _f : [])
+        ];
+    }
+}
+//# sourceMappingURL=traits.js.map

package/dist/packlets/validation/typeGuard.js

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail } from '../base';
+import { ValidatorBase } from './validatorBase';
+/**
+ * An in-place {@link Validation.Validator | Validator} that can be instantiated using a type guard
+ * function.
+ * @public
+ */
+export class TypeGuardValidator extends ValidatorBase {
+    /**
+     * Constructs a new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator}.
+     * @param params - Optional {@link Validation.Classes.TypeGuardValidatorConstructorParams | init params} for the
+     * new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator}.
+     */
+    constructor(params) {
+        var _a;
+        super(params);
+        this.description = params.description;
+        this._guard = params.guard;
+        this.options = (_a = params.options) !== null && _a !== void 0 ? _a : {};
+    }
+    /**
+     * Static method which validates that a supplied `unknown` value matches the supplied
+     * type guard, returning a `Failure<T>` containing more information about a failure.
+     * @param from - Value to be converted.
+     * @param context - Optional validation context.
+     * @param self - Optional self-reference for recursive validation.
+     * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
+     * with an error message if `from` is invalid.
+     * @internal
+     */
+    _validate(from, context, self) {
+        if (this._guard(from, context)) {
+            return true;
+        }
+        return fail(`invalid ${this.description} (${JSON.stringify(from)})`);
+    }
+}
+//# sourceMappingURL=typeGuard.js.map

package/dist/packlets/validation/validator.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export {};
+//# sourceMappingURL=validator.js.map

package/dist/packlets/validation/validatorBase.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { GenericValidator } from './genericValidator';
+/**
+ * Abstract base helper class for specific validator implementations
+ * @internal
+ */
+export class ValidatorBase extends GenericValidator {
+    /**
+     * Inner constructor
+     * @param params - Initialization params.
+     * @internal
+     */
+    constructor(params) {
+        super(Object.assign({ validator: (from, context, self) => this._validate(from, context, self) }, params));
+    }
+}
+//# sourceMappingURL=validatorBase.js.map