@fgv/ts-utils 1.2.0 → 1.3.1

package/validation/object.js

@@ -0,0 +1,143 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectValidator = void 0;
+const result_1 = require("../result");
+const validatorBase_1 = require("./validatorBase");
+const field_1 = require("./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
+ */
+class ObjectValidator extends validatorBase_1.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]) {
+                // istanbul 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 field_1.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) {
+        // istanbul ignore next
+        options = options !== null && options !== void 0 ? options : {};
+        return new ObjectValidator({
+            fields: this.fields,
+            options: {
+                ...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) {
+        if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {
+            return (0, result_1.fail)('source is not an object');
+        }
+        // eslint bug thinks key is used before defined
+        // eslint-disable-next-line no-use-before-define
+        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 : (0, result_1.fail)(errors.join('\n'));
+    }
+}
+exports.ObjectValidator = ObjectValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/validation/object.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2021 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Failure, fail } from '../result';\nimport { Validator, ValidatorOptions } from './validator';\nimport { ValidatorBase, ValidatorBaseConstructorParams } from './validatorBase';\n\nimport { FieldValidator } from './field';\n\n/**\n * Per-property {@link Validation.Validator | validators} for each of the properties in `<T>`.\n * @public\n */\nexport type FieldValidators<T, TC=unknown> = { [key in keyof T]: Validator<T[key], TC> };\n\n/**\n * Options for an {@link Validation.Classes.ObjectValidator | ObjectValidator}.\n * @public\n */\nexport interface ObjectValidatorOptions<T, TC> extends ValidatorOptions<TC> {\n    /**\n     * If present, lists optional fields. Missing non-optional fields cause an error.\n     */\n    optionalFields?: (keyof T)[];\n    /**\n     * If true, unrecognized fields yield an error.  If false or undefined (default),\n     * unrecognized fields are ignored.\n     */\n    strict?: boolean;\n}\n\n/**\n * Options for the {@link Validation.Classes.ObjectValidator | ObjectValidator} constructor.\n * @public\n */\nexport interface ObjectValidatorConstructorParams<T, TC> extends ValidatorBaseConstructorParams<T, TC> {\n    /**\n     * A {@link Validation.Classes.FieldValidators | FieldValidators} object specifying a\n     * {@link Validation.Validator | Validator} for each of the expected properties\n     * of a result object.\n     */\n    fields: FieldValidators<T>,\n    /**\n     * Optional additional {@link Validation.Classes.ObjectValidatorOptions | ValidatorOptions} to\n     * configure validation.\n     */\n    options?: ObjectValidatorOptions<T, TC>;\n}\n\n/**\n * In-place {@link Validation.Validator | Validator} for an object of type `<T>`.\n * @remarks\n * By default, succeeds if all of the required fields exist and are validate, and fails if\n * any required fields do not exist or are invalid.  See {@link Validation.Classes.ObjectValidatorOptions}\n * for other validation options.\n * @public\n */\nexport class ObjectValidator<T, TC=unknown> extends ValidatorBase<T, TC> {\n    /**\n     * A {@link Validation.Classes.FieldValidators | FieldValidators} object specifying a\n     * {@link Validation.Validator | Validator} for each of the expected properties\n     */\n    public readonly fields: FieldValidators<T>;\n    /**\n     * {@link Validation.Classes.ObjectValidatorOptions | Options} which apply to this\n     * validator.\n     */\n    public readonly options: ObjectValidatorOptions<T, TC>;\n    /**\n     * @internal\n     */\n    protected readonly _innerValidators: FieldValidators<T>;\n    /**\n     * @internal\n     */\n    protected readonly _allowedFields?: Set<keyof T>;\n\n    /**\n     * Constructs a new {@link Validation.Classes.ObjectValidator | ObjectValidator<T>}.\n     * @param fields - A {@link Validation.Classes.FieldValidators | FieldValidators<T>} containing\n     * a {@link Validation.Validator | Validator} for each field.\n     * @param options - An optional {@link Validation.Classes.ObjectValidatorOptions} to configure\n     * validation.\n     */\n    public constructor(params: ObjectValidatorConstructorParams<T, TC>) {\n        super(params);\n\n        this.fields = params.fields;\n        this.options = params.options ?? {};\n        this._innerValidators = ObjectValidator._resolveValidators(this.fields, this.options);\n        this._allowedFields = (this.options.strict === true)\n            ? new Set(Object.keys(this.fields) as (keyof T)[])\n            : undefined;\n    }\n\n    /**\n     * Creates the actual {@link Validation.Classes.FieldValidators | FieldValidators<T>} to be\n     * used by this converter by applying any options or traits defined in the options\n     * to the field converters passed to the constructor.\n     * @param fields - The base {@link Validation.Classes.FieldValidators | FieldValidators<T>} passed\n     * in to the constructor.\n     * @param options - The {@link Validation.Classes.ObjectValidatorOptions | object validator options}\n     * passed in to the constructor.\n     * @returns A new {@link Validation.Classes.FieldValidators | FieldValidators} with the fully-configured\n     * individual {@link Validation.Validator | field validators} to be applied.\n     * @internal\n     */\n    protected static _resolveValidators<T, TC>(\n        fields: FieldValidators<T, TC>,\n        options?: ObjectValidatorOptions<T, TC>,\n    ): FieldValidators<T, TC> {\n        const resolved: Partial<FieldValidators<T, TC>> = {};\n        for (const key in fields) {\n            if (fields[key]) {\n                // istanbul ignore next\n                const optional = fields[key].isOptional || options?.optionalFields?.includes(key);\n                resolved[key] = new FieldValidator(key, fields[key], { optional });\n            }\n        }\n        return resolved as FieldValidators<T, TC>;\n    }\n\n    /**\n     * Creates a new {@link Validation.Classes.ObjectValidator | ObjectValidator} derived from this one but with\n     * new optional properties as specified by a supplied\n     * {@link Validation.Classes.ObjectValidatorOptions | ObjectValidatorOptions<T>}.\n     * @param options - The {@link Validation.Classes.ObjectValidatorOptions | options} to be applied to the new\n     * {@link Validation.Classes.ObjectValidator | validator}.\n     * @returns A new {@link Validation.Classes.ObjectValidator | ObjectValidator} with the additional optional\n     * source properties.\n     */\n    public partial(options?: ObjectValidatorOptions<T, TC>): ObjectValidator<Partial<T>, TC> {\n        // istanbul ignore next\n        options = options ?? {};\n        return new ObjectValidator<Partial<T>, TC>({\n            fields: this.fields as FieldValidators<Partial<T>, TC>,\n            options: {\n                ...this.options,\n                ...options,\n            },\n            traits: this.traits,\n        });\n    }\n\n    /**\n     * Creates a new {@link Validation.Classes.ObjectValidator | ObjectValidator} derived from this one but with\n     * new optional properties as specified by a supplied array of `keyof T`.\n     * @param addOptionalProperties - The keys to be made optional.\n     * @returns A new {@link Validation.Classes.ObjectValidator | ObjectValidator} with the additional optional\n     * source properties.\n     */\n    public addPartial(addOptionalFields: (keyof T)[]): ObjectValidator<Partial<T>, TC> {\n        return this.partial({\n            optionalFields: [...(this.options.optionalFields ?? []), ...addOptionalFields],\n        });\n    }\n\n    /**\n     * {@inheritdoc Validation.ValidatorBase._validate}\n     * @internal\n     */\n    protected _validate(from: unknown, context?: TC): boolean | Failure<T> {\n        if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {\n            return fail('source is not an object');\n        }\n\n        // eslint bug thinks key is used before defined\n        // eslint-disable-next-line no-use-before-define\n        const converted = {} as { [key in keyof T]: T[key] };\n        const errors: string[] = [];\n        for (const key in this._innerValidators) {\n            if (this._innerValidators[key]) {\n                const result = this._innerValidators[key].validate(from, context);\n                if (result.success && (result.value !== undefined)) {\n                    converted[key] = result.value;\n                }\n                else if (result.isFailure()) {\n                    errors.push(result.message);\n                }\n            }\n        }\n\n        if (this._allowedFields) {\n            const invalid = Object.keys(from).filter((k) => !this._allowedFields!.has(k as keyof T));\n            invalid.forEach((key) => errors.push((`${key}: unexpected field in source object.`)));\n        }\n        return (errors.length === 0) ? true : fail(errors.join('\\n'));\n    }\n}\n"]}

package/validation/string.d.ts

@@ -0,0 +1,27 @@
+import { Failure } from '../result';
+import { GenericValidator, GenericValidatorConstructorParams } from './genericValidator';
+/**
+ * Parameters used to construct a {@link Validation.Classes.StringValidator | StringValidator}.
+ * @public
+ */
+export declare type StringValidatorConstructorParams<T extends string = string, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
+/**
+ * An in-place {@link Validation.Validator | Validator} for `string` values.
+ * @public
+ */
+export declare class StringValidator<T extends string = string, TC = unknown> extends GenericValidator<T, TC> {
+    /**
+     * 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?: StringValidatorConstructorParams<T, TC>);
+    /**
+     * 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<T extends string>(from: unknown): boolean | Failure<T>;
+}
+//# sourceMappingURL=string.d.ts.map

package/validation/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/validation/string.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,OAAO,EAAQ,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AAEzF;;;GAGG;AACH,oBAAY,gCAAgC,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,OAAO,IAAI,iCAAiC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAEjI;;;GAGG;AACH,qBAAa,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,OAAO,CAAE,SAAQ,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC;IACjG;;;;OAIG;gBACgB,MAAM,CAAC,EAAE,gCAAgC,CAAC,CAAC,EAAE,EAAE,CAAC;IAOnE;;;;;OAKG;WACW,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;CAMtF"}

package/validation/string.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringValidator = void 0;
+const result_1 = require("../result");
+const genericValidator_1 = require("./genericValidator");
+/**
+ * An in-place {@link Validation.Validator | Validator} for `string` values.
+ * @public
+ */
+class StringValidator extends genericValidator_1.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) {
+        super({
+            validator: StringValidator.validateString,
+            ...(params !== null && params !== void 0 ? 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 (0, result_1.fail)(`"${from}": not a string`);
+    }
+}
+exports.StringValidator = StringValidator;
+//# sourceMappingURL=data:application/json;base64,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

package/validation/traits.d.ts

@@ -0,0 +1,68 @@
+/**
+ * A {@link Validation.ConstraintTrait | ConstraintTrait} indicating that
+ * a {@link Validation.Constraint | Constraint<T>} function provides an
+ * additional constraint implementation.
+ * @public
+ */
+export interface FunctionConstraintTrait {
+    type: 'function';
+}
+/**
+ * Union of all supported constraint traits.
+ * @public
+ */
+export declare type ConstraintTrait = FunctionConstraintTrait;
+/**
+ * Interface describing the supported validator traits.
+ * @public
+ */
+export interface ValidatorTraitValues {
+    /**
+     * Indicates whether the validator accepts `undefined` as
+     * a valid value.
+     */
+    readonly isOptional: boolean;
+    /**
+     * If present, indicates that the result will be branded
+     * with the corresponding brand.
+     */
+    readonly brand?: string;
+    /**
+     * Zero or more additional {@link Validation.ConstraintTrait | ConstraintTrait}s
+     * describing additional constraints applied by this {@link Validation.Validator | Validator}.
+     */
+    readonly constraints: ConstraintTrait[];
+}
+/**
+ * Default {@link Validation.ValidatorTraitValues | validation traits}.
+ * @public
+ */
+export declare const defaultValidatorTraits: ValidatorTraitValues;
+/**
+ * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
+ * @public
+ */
+export declare class ValidatorTraits implements ValidatorTraitValues {
+    /**
+     * {@inheritdoc Validation.ValidatorTraitValues.isOptional}
+     */
+    readonly isOptional: boolean;
+    /**
+     * {@inheritdoc Validation.ValidatorTraitValues.brand}
+     */
+    readonly brand?: string;
+    /**
+     * {@inheritdoc Validation.ValidatorTraitValues.constraints}
+     */
+    readonly constraints: ConstraintTrait[];
+    /**
+     * 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?: Partial<ValidatorTraitValues>, base?: ValidatorTraitValues);
+}
+//# sourceMappingURL=traits.d.ts.map

package/validation/traits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traits.d.ts","sourceRoot":"","sources":["../../src/validation/traits.ts"],"names":[],"mappings":"AAsBA;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACpC,IAAI,EAAE,UAAU,CAAC;CACpB;AAED;;;GAGG;AACH,oBAAY,eAAe,GAAG,uBAAuB,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,eAAe,EAAE,CAAC;CAC3C;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,oBAGpC,CAAC;AAEF;;;GAGG;AACH,qBAAa,eAAgB,YAAW,oBAAoB;IACxD;;OAEG;IACH,SAAgB,UAAU,EAAE,OAAO,CAAC;IAEpC;;OAEG;IACH,SAAgB,KAAK,CAAC,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,SAAgB,WAAW,EAAE,eAAe,EAAE,CAAC;IAE/C;;;;;;;OAOG;gBAEC,IAAI,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACpC,IAAI,CAAC,EAAE,oBAAoB;CAUlC"}

package/validation/traits.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorTraits = exports.defaultValidatorTraits = void 0;
+/**
+ * Default {@link Validation.ValidatorTraitValues | validation traits}.
+ * @public
+ */
+exports.defaultValidatorTraits = {
+    isOptional: false,
+    constraints: [],
+};
+/**
+ * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
+ * @public
+ */
+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;
+        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 : exports.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 : exports.defaultValidatorTraits.brand;
+        this.constraints = [
+            ...exports.defaultValidatorTraits.constraints,
+            ...((_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 : []),
+        ];
+    }
+}
+exports.ValidatorTraits = ValidatorTraits;
+//# sourceMappingURL=data:application/json;base64,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

package/validation/validator.d.ts

@@ -0,0 +1,82 @@
+import { ConstraintTrait, ValidatorTraits } from './traits';
+import { Failure, Result } from '../result';
+import { Brand } from '../brand';
+/**
+ * Options that apply to any {@link Validation.Validator | Validator}.
+ * @public
+ */
+export interface ValidatorOptions<TC> {
+    defaultContext?: TC;
+}
+/**
+ * A {@link Validation.Constraint | Constraint<T>} function returns
+ * `true` if the supplied value meets the constraint. Can return
+ * {@link Failure} with an error message or simply return `false`
+ * for a default message.
+ * @public
+ */
+export declare type Constraint<T> = (val: T) => boolean | Failure<T>;
+/**
+ * In-place validation that a supplied unknown matches some
+ * required characteristics (type, values, etc).
+ * @public
+ */
+export interface Validator<T, TC = undefined> {
+    /**
+     * {@link Validation.ValidatorTraits | Traits} describing this validation.
+     */
+    readonly traits: ValidatorTraits;
+    /**
+     * Indicates whether this element is explicitly optional.
+     */
+    readonly isOptional: boolean;
+    /**
+     * The brand for a branded type.
+     */
+    readonly brand: string | undefined;
+    /**
+      * Tests to see if a supplied `unknown` value matches this
+      * validation.
+      * @param from - The `unknown` value to be tested.
+      * @param context - Optional validation context.
+      * @returns {@link Success} with the typed, validated value,
+      * or {@link Failure} with an error message if validation fails.
+      */
+    validate(from: unknown, context?: TC): Result<T>;
+    /**
+      * Tests to see if a supplied `unknown` value matches this
+      * validation.  Accepts `undefined`.
+      * @param from - The `unknown` value to be tested.
+      * @param context - Optional validation context.
+      * @returns {@link Success} with the typed, validated value,
+      * or {@link Failure} with an error message if validation fails.
+      */
+    validateOptional(from: unknown, context?: TC): Result<T | undefined>;
+    /**
+     * Non-throwing type guard
+     * @param from - The value to be tested.
+     * @param context - Optional validation context.
+     */
+    guard(from: unknown, context?: TC): from is T;
+    /**
+     * Creates an {@link Validation.Validator | in-place validator}
+     * which is derived from this one but which also matches `undefined`.
+     */
+    optional(): Validator<T | undefined, TC>;
+    /**
+     * Creates an {@link Validation.Validator | in-place validator}
+     * which is derived from this one but which applies additional constraints.
+     * @param constraint - the constraint to be applied
+     * @param trait - As optional {@link Validation.ConstraintTrait | ConstraintTrait}
+     * to be applied to the resulting {@link Validation.Validator | Validator}.
+     * @returns A new {@link Validation.Validator | Validator}.
+     */
+    withConstraint(constraint: Constraint<T>, trait?: ConstraintTrait): Validator<T, TC>;
+    /**
+     * Creates a new {@link Validation.Validator | in-place validator} which
+     * is derived from this one but which matches a branded result.
+     * @param brand - The brand to be applied.
+     */
+    withBrand<B extends string>(brand: B): Validator<Brand<T, B>, TC>;
+}
+//# sourceMappingURL=validator.d.ts.map

package/validation/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/validation/validator.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,EAAE;IAChC,cAAc,CAAC,EAAE,EAAE,CAAC;CACvB;AAED;;;;;;GAMG;AACH,oBAAY,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7D;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,EAAE,GAAC,SAAS;IAClC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IAEjC;;OAEG;IACF,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE9B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC;;;;;;;QAOI;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAElD;;;;;;;QAOI;IACJ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAErE;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC;IAE7C;;;OAGG;IACH,QAAQ,IAAI,SAAS,CAAC,CAAC,GAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAEvC;;;;;;;OAOG;IACH,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAErF;;;;OAIG;IACH,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;CAC1E"}

package/validation/validator.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/validation/validatorBase.d.ts

@@ -0,0 +1,25 @@
+import { GenericValidator, GenericValidatorConstructorParams } from './genericValidator';
+import { Failure } from '../result';
+export declare type ValidatorBaseConstructorParams<T, TC> = Omit<GenericValidatorConstructorParams<T, TC>, 'validator'>;
+/**
+ * Abstract base helper class for specific validator implementations
+ * @internal
+ */
+export declare abstract class ValidatorBase<T, TC = undefined> extends GenericValidator<T, TC> {
+    /**
+     * Inner constructor
+     * @param params - Initialization params.
+     * @internal
+     */
+    protected constructor(params: Partial<ValidatorBaseConstructorParams<T, TC>>);
+    /**
+     * Abstract validation method to me implemented by derived classes.
+     * @param from - Value to be converted.
+     * @param context - Optional validation context.
+     * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
+     * with an error message if `from` is invalid.
+     * @internal
+     */
+    protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+}
+//# sourceMappingURL=validatorBase.d.ts.map

package/validation/validatorBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validatorBase.d.ts","sourceRoot":"","sources":["../../src/validation/validatorBase.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,gBAAgB,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AAEzF,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,oBAAY,8BAA8B,CAAC,CAAC,EAAE,EAAE,IAAI,IAAI,CAAC,iCAAiC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;AAEhH;;;GAGG;AACH,8BAAsB,aAAa,CAAC,CAAC,EAAE,EAAE,GAAG,SAAS,CAAE,SAAQ,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC;IAClF;;;;OAIG;IACH,SAAS,aAAa,MAAM,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAO5E;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;CAClF"}

package/validation/validatorBase.js

@@ -0,0 +1,44 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorBase = void 0;
+const genericValidator_1 = require("./genericValidator");
+/**
+ * Abstract base helper class for specific validator implementations
+ * @internal
+ */
+class ValidatorBase extends genericValidator_1.GenericValidator {
+    /**
+     * Inner constructor
+     * @param params - Initialization params.
+     * @internal
+     */
+    constructor(params) {
+        super({
+            validator: (from, context) => this._validate(from, context),
+            ...params,
+        });
+    }
+}
+exports.ValidatorBase = ValidatorBase;
+//# sourceMappingURL=data:application/json;base64,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