@fgv/ts-utils 5.0.1-9 → 5.0.1

package/dist/packlets/logging/logReporter.js

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2020 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 { NoOpLogger, stringifyLogValue } from './logger';
+/**
+ * Abstract base class which wraps an existing {@link Logging.ILogger | ILogger} to implement
+ * both {@link Logging.ILogger | ILogger} and {@link IResultReporter | IResultReporter}.
+ * @public
+ */
+export class LogReporter {
+    /**
+     * Creates a new {@link Logging.LogReporter | LogReporter}.
+     * @param params - The parameters for creating the {@link Logging.LogReporter | LogReporter}.
+     */
+    constructor(params) {
+        var _a, _b, _c;
+        /* c8 ignore next 1 */
+        params = params !== null && params !== void 0 ? params : {};
+        this.logger = (_a = params.logger) !== null && _a !== void 0 ? _a : new NoOpLogger();
+        this._valueFormatter = (_b = params.valueFormatter) !== null && _b !== void 0 ? _b : LogReporter.tryFormatObject;
+        this._messageFormatter = (_c = params.messageFormatter) !== null && _c !== void 0 ? _c : ((message, __detail) => message);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.logLevel}
+     */
+    get logLevel() {
+        return this.logger.logLevel;
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.detail}
+     */
+    detail(message, ...parameters) {
+        return this.logger.detail(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.info}
+     */
+    info(message, ...parameters) {
+        return this.logger.info(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.warn}
+     */
+    warn(message, ...parameters) {
+        return this.logger.warn(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.error}
+     */
+    error(message, ...parameters) {
+        return this.logger.error(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.log}
+     */
+    log(level, message, ...parameters) {
+        return this.logger.log(level, message, ...parameters);
+    }
+    /**
+     * {@inheritDoc IResultReporter.reportSuccess}
+     */
+    reportSuccess(level, value, detail, message) {
+        const formattedValue = this._valueFormatter(value, detail);
+        const formatted = message ? message(formattedValue, detail) : formattedValue;
+        this.log(level, formatted);
+    }
+    /**
+     * {@inheritDoc IResultReporter.reportFailure}
+     */
+    reportFailure(level, message, detail) {
+        const formatted = this._messageFormatter(message, detail);
+        this.log(level, formatted);
+    }
+    /**
+     * Creates a new {@link Logging.LogReporter | LogReporter} with the same logger but a different value formatter.
+     * @param valueFormatter - The value formatter to use.
+     * @returns A new {@link Logging.LogReporter | LogReporter} with the same logger but a different value formatter.
+     */
+    withValueFormatter(valueFormatter) {
+        return new LogReporter({
+            logger: this.logger,
+            valueFormatter,
+            messageFormatter: this._messageFormatter
+        });
+    }
+    /**
+     * Generic method to try to format an object for logging.
+     * @param value - The value to format.
+     * @param detail - The detail to format.
+     * @returns
+     */
+    static tryFormatObject(value, detail) {
+        return stringifyLogValue(value);
+    }
+}
+//# sourceMappingURL=logReporter.js.map

package/dist/packlets/logging/logger.js

@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2020 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 { captureResult, succeed } from '../base';
+/**
+ * Compares two log levels.
+ * @param message - The first log level.
+ * @param reporter - The second log level.
+ * @returns `true` if the message should be logged, `false` if it should be suppressed.
+ * @public
+ */
+export function shouldLog(message, reporter) {
+    if (reporter === 'all') {
+        return true; // 'all' logs everything, including 'quiet'
+    }
+    if (reporter === 'silent') {
+        return false; // 'silent' suppresses everything
+    }
+    if (message === 'quiet') {
+        return false; // 'quiet' messages only show when reporter is 'all'
+    }
+    switch (reporter) {
+        case 'error':
+            return message === 'error';
+        case 'warning':
+            return message === 'warning' || message === 'error';
+        case 'info':
+            return message !== 'detail';
+    }
+    return true;
+}
+/**
+ * Stringifies an arbitrary value for logging.
+ * @param value - The value to stringify.
+ * @returns The stringified value.
+ * @param maxLength - The maximum length of the stringified value.
+ * @public
+ */
+export function stringifyLogValue(value, maxLength) {
+    maxLength = maxLength !== null && maxLength !== void 0 ? maxLength : 40;
+    if (typeof value === 'string') {
+        return value;
+    }
+    const str = String(value);
+    if (str === '[object Object]') {
+        return captureResult(() => JSON.stringify(value))
+            .onSuccess((s) => {
+            return succeed(s.length < maxLength ? s : s.substring(0, maxLength - 3) + '...');
+        })
+            .orDefault(str);
+    }
+    return str;
+}
+/**
+ * Abstract base class which implements {@link Logging.ILogger | ILogger}.
+ * @public
+ */
+export class LoggerBase {
+    constructor(logLevel) {
+        /**
+         * {@inheritDoc Logging.ILogger.logLevel}
+         */
+        this.logLevel = 'info';
+        this.logLevel = logLevel !== null && logLevel !== void 0 ? logLevel : 'info';
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.detail}
+     */
+    detail(message, ...parameters) {
+        return this.log('detail', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.info}
+     */
+    info(message, ...parameters) {
+        return this.log('info', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.warn}
+     */
+    warn(message, ...parameters) {
+        return this.log('warning', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.error}
+     */
+    error(message, ...parameters) {
+        return this.log('error', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.log}
+     */
+    log(level, message, ...parameters) {
+        if (shouldLog(level, this.logLevel)) {
+            const formatted = this._format(message, ...parameters);
+            return this._log(formatted, level);
+        }
+        return this._suppressLog(level, message, ...parameters);
+    }
+    /**
+     * Formats a message and parameters into a string.
+     * @param message - The message to format.
+     * @param parameters - The parameters to format.
+     * @returns The formatted message.
+     * @public
+     */
+    _format(message, ...parameters) {
+        const raw = [message, ...parameters];
+        const filtered = raw.filter((m) => m !== undefined);
+        const strings = filtered.map((m) => stringifyLogValue(m));
+        const joined = strings.join('');
+        return joined;
+    }
+    /**
+     * Inner method called for suppressed log messages.
+     * @public
+     */
+    _suppressLog(__level, __message, ...__parameters) {
+        return succeed(undefined);
+    }
+}
+/**
+ * An in-memory logger that stores logged and suppressed messages.
+ * @public
+ */
+export class InMemoryLogger extends LoggerBase {
+    /**
+     * Creates a new in-memory logger.
+     * @param logLevel - The level of logging to be used.
+     */
+    constructor(logLevel) {
+        super(logLevel);
+        /**
+         * The messages that have been logged.
+         * @internal
+         */
+        this._logged = [];
+        /**
+         * The messages that have been suppressed.
+         * @internal
+         */
+        this._suppressed = [];
+    }
+    /**
+     * The messages that have been logged.
+     */
+    get logged() {
+        return this._logged;
+    }
+    /**
+     * The messages that have been suppressed.
+     */
+    get suppressed() {
+        return this._suppressed;
+    }
+    /**
+     * Clears the logged and suppressed messages.
+     */
+    clear() {
+        this._logged = [];
+        this._suppressed = [];
+    }
+    /**
+     * {@inheritDoc Logging.LoggerBase._log}
+     * @internal
+     */
+    _log(message, __level) {
+        this._logged.push(message);
+        return succeed(message);
+    }
+    /**
+     * {@inheritDoc Logging.LoggerBase._suppressLog}
+     * @param level - The level of the message.
+     * @param message - The message to suppress.
+     * @param parameters - The parameters to suppress.
+     * @returns `Success` with `undefined` if the message is suppressed.
+     * @internal
+     */
+    _suppressLog(level, message, ...parameters) {
+        const formatted = this._format(message, ...parameters);
+        this._suppressed.push(formatted);
+        return succeed(undefined);
+    }
+}
+/**
+ * A console logger that outputs messages to the console.
+ * @public
+ */
+export class ConsoleLogger extends LoggerBase {
+    /**
+     * Creates a new console logger.
+     * @param logLevel - The level of logging to be used.
+     */
+    constructor(logLevel) {
+        super(logLevel);
+    }
+    /**
+     * {@inheritDoc Logging.LoggerBase._log}
+     * @internal
+     */
+    _log(message, level) {
+        switch (level) {
+            case 'error':
+                console.error(message);
+                break;
+            case 'warning':
+                console.warn(message);
+                break;
+            case 'info':
+                console.info(message);
+                break;
+            default:
+                console.log(message);
+                break;
+        }
+        return succeed(message);
+    }
+}
+/**
+ * A no-op {@link Logging.LoggerBase | LoggerBase} that does not log anything.
+ * @public
+ */
+export class NoOpLogger extends LoggerBase {
+    /**
+     * Creates a new no-op logger.
+     * @param logLevel - The level of logging to be used.
+     */
+    constructor(logLevel) {
+        super(logLevel);
+    }
+    /**
+     * {@inheritDoc Logging.LoggerBase._log}
+     * @internal
+     */
+    _log(message, __level) {
+        // no-op
+        return succeed(message);
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/packlets/validation/array.js

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 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} for arrays of validated
+ * values or objects.
+ * @public
+ */
+export class ArrayValidator extends ValidatorBase {
+    /**
+     * Constructs a new {@link Validation.Classes.ArrayValidator | ArrayValidator}.
+     * @param params - Optional {@link Validation.Classes.ArrayValidatorConstructorParams | init params} for the
+     * new {@link Validation.Classes.ArrayValidator | ArrayValidator}.
+     */
+    constructor(params) {
+        var _a;
+        super(params);
+        this._validateElement = params.validateElement;
+        this.options = (_a = params.options) !== null && _a !== void 0 ? _a : {};
+    }
+    /**
+     * Static method which validates that a supplied `unknown` value is a `array`
+     * and that every element of the array can be validated by the supplied array
+     * validator.
+     * @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) {
+        if (Array.isArray(from)) {
+            for (const elem of from) {
+                const result = this._validateElement.validate(elem, context);
+                if (!result.isSuccess()) {
+                    return fail(result.message);
+                }
+            }
+            return true;
+        }
+        return fail(`"${from}": not an array`);
+    }
+}
+//# sourceMappingURL=array.js.map

package/dist/packlets/validation/boolean.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 `boolean` values.
+ * @public
+ */
+export class BooleanValidator extends GenericValidator {
+    /**
+     * Constructs a new {@link Validation.Classes.BooleanValidator | BooleanValidator}.
+     * @param params - Optional {@link Validation.Classes.BooleanValidatorConstructorParams | init params} for the
+     * new {@link Validation.Classes.BooleanValidator | BooleanValidator}.
+     */
+    constructor(params) {
+        /* c8 ignore next */
+        params = params !== null && params !== void 0 ? params : {};
+        super(Object.assign({ validator: BooleanValidator.validateBoolean }, params));
+    }
+    /**
+     * Static method which validates that a supplied `unknown` value is a `boolean`.
+     * @param from - The `unknown` value to be tested.
+     * @returns Returns `true` if `from` is a `boolean`, or {@link Failure} with an error
+     * message if not.
+     */
+    static validateBoolean(from) {
+        if (typeof from === 'boolean') {
+            return true;
+        }
+        return fail(`"${from}": not a boolean`);
+    }
+}
+//# sourceMappingURL=boolean.js.map

package/dist/packlets/validation/classes.js

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+/* c8 ignore start */
+export { ArrayValidator } from './array';
+export { BooleanValidator } from './boolean';
+export { NumberValidator } from './number';
+export { ObjectValidator } from './object';
+export { OneOfValidator } from './oneOf';
+export { StringValidator } from './string';
+export { TypeGuardValidator } from './typeGuard';
+/* c8 ignore stop */
+//# sourceMappingURL=classes.js.map

package/dist/packlets/validation/common.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 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=common.js.map

package/dist/packlets/validation/field.js

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 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, isKeyOf } from '../base';
+import { ValidatorBase } from './validatorBase';
+/**
+ * An in-place {@link Validation.Validator | Validator} for properties
+ * an an object.
+ * @public
+ */
+export class FieldValidator extends ValidatorBase {
+    /**
+     * Constructs a new {@link Validation.FieldValidator | FieldValidator.}.
+     * @param fieldName - The name of the property that this validator should validate.
+     * @param fieldValidator - The {@link Validation.Validator | Validator} to be applied
+     * against the named property.
+     * @param options - Additional {@link Validation.FieldValidatorOptions | options} to be
+     * applied to this validation.
+     */
+    constructor(fieldName, fieldValidator, options) {
+        super({ options });
+        this.fieldName = fieldName;
+        this.fieldValidator = fieldValidator;
+        /* c8 ignore next */
+        this._fieldOptions = options !== null && options !== void 0 ? options : {};
+    }
+    /**
+     * {@inheritdoc Validation.ValidatorBase._validate}
+     */
+    _validate(from, context, self) {
+        if (typeof from === 'object' && !Array.isArray(from) && from !== null) {
+            const optional = this._fieldOptions.optional === true;
+            if (isKeyOf(this.fieldName, from)) {
+                if (!optional || from[this.fieldName] !== undefined) {
+                    const result = this.fieldValidator
+                        .validate(from[this.fieldName], context)
+                        .onFailure((message) => {
+                        return fail(`${this.fieldName}: ${message}`);
+                    });
+                    return result.success ? true : result;
+                }
+            }
+            return optional ? true : fail(`"${this.fieldName}": Field not found in "${JSON.stringify(from)}`);
+        }
+        /* c8 ignore next 2 -- defense in depth */
+        return fail(`Cannot validate field '${this.fieldName}' from non-object "${JSON.stringify(from)}"`);
+    }
+}
+//# sourceMappingURL=field.js.map