@fgv/ts-utils 5.0.0-2 → 5.0.0-20

package/lib/packlets/validation/genericValidator.js

@@ -59,7 +59,7 @@ class GenericValidator {
      * {@inheritdoc Validation.Validator.validate}
      */
     validate(from, context) {
-        const result = this._validator(from, this._context(context));
+        const result = this._validator(from, this._context(context), this);
         if (typeof result === 'boolean') {
             return result ? (0, base_1.succeed)(from) : (0, base_1.fail)('Invalid value');
         }
@@ -69,7 +69,7 @@ class GenericValidator {
      * {@inheritdoc Validation.Validator.convert}
      */
     convert(from, context) {
-        const result = this._validator(from, this._context(context));
+        const result = this._validator(from, this._context(context), this);
         if (typeof result === 'boolean') {
             return result ? (0, base_1.succeed)(from) : (0, base_1.fail)('Invalid value');
         }
@@ -85,15 +85,15 @@ class GenericValidator {
      * {@inheritdoc Validation.Validator.guard}
      */
     guard(from, context) {
-        return this._validator(from, this._context(context)) === true;
+        return this._validator(from, this._context(context), this) === true;
     }
     /**
      * {@inheritdoc Validation.Validator.optional}
      */
     optional() {
         return new GenericValidator({
-            validator: (from, context) => {
-                return from === undefined || this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                return from === undefined || this._validator(from, this._context(context), this);
             },
             traits: { isOptional: true }
         });
@@ -104,8 +104,8 @@ class GenericValidator {
     withConstraint(constraint, trait) {
         trait = trait !== null && trait !== void 0 ? trait : { type: 'function' };
         return new GenericValidator({
-            validator: (from, context) => {
-                const result = this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                const result = this._validator(from, this._context(context), this);
                 if (result === true) {
                     const constraintResult = constraint(from);
                     if (typeof constraintResult === 'boolean') {
@@ -128,8 +128,8 @@ class GenericValidator {
             throw new Error(`Cannot replace existing brand "${this.brand}" with "${brand}".`);
         }
         return new GenericValidator({
-            validator: (from, context) => {
-                return this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                return this._validator(from, this._context(context), this);
             },
             traits: { brand }
         });
@@ -139,8 +139,8 @@ class GenericValidator {
      */
     withFormattedError(formatter) {
         return new GenericValidator({
-            validator: (from, context) => {
-                const result = this._validator(from, this._context(context));
+            validator: (from, context, self) => {
+                const result = this._validator(from, this._context(context), this);
                 if (result === true) {
                     return true;
                 }

package/lib/packlets/validation/object.d.ts

@@ -110,6 +110,6 @@ export declare class ObjectValidator<T, TC = unknown> extends ValidatorBase<T, T
      * {@inheritdoc Validation.ValidatorBase._validate}
      * @internal
      */
-    protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=object.d.ts.map

package/lib/packlets/validation/object.js

@@ -109,7 +109,7 @@ class ObjectValidator extends validatorBase_1.ValidatorBase {
      * {@inheritdoc Validation.ValidatorBase._validate}
      * @internal
      */
-    _validate(from, context) {
+    _validate(from, context, self) {
         if (typeof from !== 'object' || from === null || Array.isArray(from)) {
             return (0, base_1.fail)('source is not an object');
         }

package/lib/packlets/validation/oneOf.d.ts

@@ -31,9 +31,10 @@ export declare class OneOfValidator<T, TC = unknown> extends ValidatorBase<T, TC
      * 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.
      */
-    protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate<T>(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=oneOf.d.ts.map

package/lib/packlets/validation/oneOf.js

@@ -46,10 +46,11 @@ class OneOfValidator extends validatorBase_1.ValidatorBase {
      * 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) {
+    _validate(from, context, self) {
         const found = this._validators.some((v) => v.validate(from).success);
         if (found) {
             return true;

package/lib/packlets/validation/typeGuard.d.ts

@@ -1,7 +1,7 @@
 import { Failure } from '../base';
 import { ValidatorBase, ValidatorBaseConstructorParams } from './validatorBase';
 import { TypeGuardWithContext } from './common';
-import { ValidatorOptions } from './validator';
+import { Validator, ValidatorOptions } from './validator';
 /**
  * Parameters used to construct a {@link Validation.Classes.TypeGuardValidator}.
  * @public
@@ -34,10 +34,11 @@ export declare class TypeGuardValidator<T, TC = unknown> extends ValidatorBase<T
      * 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
      */
-    protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected _validate(from: unknown, context?: TC, self?: Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=typeGuard.d.ts.map

package/lib/packlets/validation/typeGuard.js

@@ -47,11 +47,12 @@ class TypeGuardValidator extends validatorBase_1.ValidatorBase {
      * 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) {
+    _validate(from, context, self) {
         if (this._guard(from, context)) {
             return true;
         }

package/lib/packlets/validation/validator.d.ts

@@ -1,5 +1,12 @@
 import { Brand, Failure, Result } from '../base';
 import { ConstraintTrait, ValidatorTraits } from './traits';
+/**
+ * Type for a validation function, which validates that a supplied `unknown`
+ * value is a valid value of type `<T>`, possibly as influenced by
+ * an optionally-supplied validation context of type `<TC>`.
+ * @public
+ */
+export type ValidatorFunc<T, TC> = (from: unknown, context?: TC, self?: Validator<T, TC>) => boolean | Failure<T>;
 /**
  * Options that apply to any {@link Validation.Validator | Validator}.
  * @public

package/lib/packlets/validation/validatorBase.d.ts

@@ -19,10 +19,11 @@ export declare abstract class ValidatorBase<T, TC = unknown> extends GenericVali
      * Abstract validation method to me implemented by derived classes.
      * @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
      */
-    protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+    protected abstract _validate(from: unknown, context?: TC, self?: import('./validator').Validator<T, TC>): boolean | Failure<T>;
 }
 //# sourceMappingURL=validatorBase.d.ts.map

package/lib/packlets/validation/validatorBase.js

@@ -34,7 +34,7 @@ class ValidatorBase extends genericValidator_1.GenericValidator {
      * @internal
      */
     constructor(params) {
-        super(Object.assign({ validator: (from, context) => this._validate(from, context) }, params));
+        super(Object.assign({ validator: (from, context, self) => this._validate(from, context, self) }, params));
     }
 }
 exports.ValidatorBase = ValidatorBase;

package/lib/packlets/validation/validators.d.ts

@@ -1,9 +1,9 @@
 import { ArrayValidator, ArrayValidatorConstructorParams } from './array';
 import { FieldValidators, ObjectValidator, ObjectValidatorConstructorParams } from './object';
 import { TypeGuardValidator, TypeGuardValidatorConstructorParams } from './typeGuard';
-import { TypeGuardWithContext, ValidatorFunc } from './common';
+import { TypeGuardWithContext } from './common';
 import { OneOfValidator, OneOfValidatorConstructorParams } from './oneOf';
-import { Validator } from './validator';
+import { Validator, ValidatorFunc } from './validator';
 /**
  * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
  * @public

package/lib/packlets/validation/validators.js

@@ -94,7 +94,7 @@ function arrayOf(validateElement, params) {
 function recordOf(validator, options) {
     const opts = Object.assign({ onError: 'fail' }, options);
     return new genericValidator_1.GenericValidator({
-        validator: (from, context) => {
+        validator: (from, context, self) => {
             if (typeof from !== 'object' || from === null || Array.isArray(from)) {
                 return (0, base_1.fail)(`Not a string-keyed object: ${JSON.stringify(from)}`);
             }
@@ -139,7 +139,7 @@ function recordOf(validator, options) {
  */
 function enumeratedValue(values) {
     return new genericValidator_1.GenericValidator({
-        validator: (from, context) => {
+        validator: (from, context, self) => {
             if (typeof from === 'string') {
                 const v = context !== null && context !== void 0 ? context : values;
                 const index = v.indexOf(from);
@@ -156,7 +156,7 @@ function enumeratedValue(values) {
  */
 function literal(value) {
     return new genericValidator_1.GenericValidator({
-        validator: (from) => {
+        validator: (from, context, self) => {
             return from === value
                 ? true
                 : (0, base_1.fail)(`Expected literal ${String(value)}, found "${JSON.stringify(from, undefined, 2)}`);

package/lib/test/helpers/jest/helpers/fsHelpers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @public
+ */
+export interface IMockFileConfig {
+    path: string;
+    backingFile?: string;
+    payload?: string;
+    writable?: boolean;
+}
+/**
+ * @public
+ */
+export declare class ReadWriteSpies {
+    readonly read: jest.SpyInstance;
+    readonly write: jest.SpyInstance;
+    constructor(read: jest.SpyInstance, write: jest.SpyInstance);
+    clear(): void;
+    restore(): void;
+}
+/**
+ * @public
+ */
+export interface IMockFileSystemOptions {
+    mockWriteOnly?: boolean;
+    allowUnknownMockWrite?: boolean;
+}
+/**
+ * @public
+ */
+type ReadFunc = (path: string | number | Buffer | URL, options?: {
+    encoding?: null;
+    flag?: string;
+} | null) => Buffer;
+/**
+ * @public
+ */
+export declare class MockFileSystem {
+    protected readonly _options?: IMockFileSystemOptions;
+    protected readonly _config: Map<string, IMockFileConfig>;
+    protected readonly _data: Map<string, string>;
+    protected readonly _realReadFileSync: ReadFunc;
+    protected readonly _extraWrites: string[];
+    constructor(configs: Iterable<IMockFileConfig>, options?: IMockFileSystemOptions);
+    readMockFileSync(wanted: string): string;
+    writeMockFileSync(wanted: string, body: string): void;
+    getExtraFilesWritten(): string[];
+    tryGetPayload(want: string): string | undefined;
+    reset(): void;
+    startSpies(): ReadWriteSpies;
+}
+export {};
+//# sourceMappingURL=fsHelpers.d.ts.map

package/lib/test/helpers/jest/helpers/fsHelpers.js

@@ -0,0 +1,180 @@
+"use strict";
+/*
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockFileSystem = exports.ReadWriteSpies = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * @public
+ */
+class ReadWriteSpies {
+    constructor(read, write) {
+        this.read = read;
+        this.write = write;
+    }
+    clear() {
+        this.read.mockClear();
+        this.write.mockClear();
+    }
+    restore() {
+        this.read.mockRestore();
+        this.write.mockRestore();
+    }
+}
+exports.ReadWriteSpies = ReadWriteSpies;
+/**
+ * @public
+ */
+class MockFileSystem {
+    constructor(configs, options) {
+        this._extraWrites = [];
+        this._config = new Map();
+        this._data = new Map();
+        this._options = options;
+        this._realReadFileSync = fs_1.default.readFileSync;
+        for (const config of configs) {
+            const fullPath = path.resolve(config.path);
+            this._config.set(fullPath, config);
+            if (config.backingFile) {
+                this.readMockFileSync(fullPath);
+            }
+            else if (config.payload) {
+                this._data.set(fullPath, config.payload);
+            }
+        }
+    }
+    readMockFileSync(wanted) {
+        var _a;
+        const fullPathWanted = path.resolve(wanted);
+        if (!this._data.has(fullPathWanted)) {
+            const config = this._config.get(fullPathWanted);
+            if ((config === null || config === void 0 ? void 0 : config.backingFile) === undefined) {
+                if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.mockWriteOnly) !== true) {
+                    throw new Error(`Mock file not found: ${wanted}`);
+                }
+                const body = this._realReadFileSync(fullPathWanted).toString();
+                this._data.set(fullPathWanted, body);
+            }
+            else {
+                const fullBackingPath = path.resolve(config.backingFile);
+                const body = this._realReadFileSync(fullBackingPath).toString();
+                this._data.set(fullPathWanted, body);
+            }
+        }
+        const payload = this._data.get(fullPathWanted);
+        // not actually reproducible right now
+        /* c8 ignore next 3 */
+        if (payload === undefined) {
+            throw new Error(`Mock file ${wanted} payload is undefined.`);
+        }
+        return payload;
+    }
+    writeMockFileSync(wanted, body) {
+        var _a;
+        const fullPathWanted = path.resolve(wanted);
+        const config = this._config.get(fullPathWanted);
+        if (config === undefined) {
+            if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.allowUnknownMockWrite) !== true) {
+                throw new Error(`Mock path not found: ${wanted}`);
+            }
+            this._extraWrites.push(fullPathWanted);
+        }
+        else if (config.writable !== true) {
+            throw new Error(`Mock permission denied: ${wanted}`);
+        }
+        this._data.set(fullPathWanted, body);
+    }
+    getExtraFilesWritten() {
+        return Array.from(this._extraWrites);
+    }
+    tryGetPayload(want) {
+        return this._data.get(path.resolve(want));
+    }
+    reset() {
+        const writable = Array.from(this._config.values()).filter((c) => c.writable === true);
+        for (const config of writable) {
+            this._data.delete(path.resolve(config.path));
+            if (config.backingFile) {
+                this.readMockFileSync(path.resolve(config.path));
+            }
+            else if (config.payload) {
+                this._data.set(path.resolve(config.path), config.payload);
+            }
+        }
+        for (const path of this._extraWrites) {
+            this._data.delete(path);
+        }
+        this._extraWrites.splice(0, this._extraWrites.length);
+    }
+    startSpies() {
+        return new ReadWriteSpies(jest.spyOn(fs_1.default, 'readFileSync').mockImplementation((wanted) => {
+            if (typeof wanted !== 'string') {
+                throw new Error('readFileSync mock supports only string parameters');
+            }
+            return this.readMockFileSync(wanted);
+        }), jest.spyOn(fs_1.default, 'writeFileSync').mockImplementation((wanted, payload) => {
+            if (typeof wanted !== 'string' || typeof payload !== 'string') {
+                throw new Error('writeFileSync mock supports only string parameters');
+            }
+            return this.writeMockFileSync(wanted, payload);
+        }));
+    }
+}
+exports.MockFileSystem = MockFileSystem;
+//# sourceMappingURL=fsHelpers.js.map

package/lib/test/helpers/jest/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fsHelpers';
+//# sourceMappingURL=index.d.ts.map

package/lib/test/helpers/jest/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fsHelpers"), exports);
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/index.d.ts

@@ -0,0 +1,3 @@
+import './types';
+export { IMockFileConfig as MockFileConfig, MockFileSystem } from './helpers';
+//# sourceMappingURL=index.d.ts.map

package/lib/test/helpers/jest/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockFileSystem = void 0;
+const matchers_1 = __importDefault(require("./matchers"));
+require("./types");
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "MockFileSystem", { enumerable: true, get: function () { return helpers_1.MockFileSystem; } });
+// eslint-disable-next-line no-undef
+function isJestGlobal(g) {
+    return g.hasOwnProperty('expect');
+}
+/* c8 ignore else */
+if (isJestGlobal(global)) {
+    global.expect.extend(matchers_1.default);
+}
+else {
+    /* eslint-disable no-console */
+    console.error([
+        "Unable to find Jest's global expect",
+        'Please check that you have added ts-utils-jest correctly to your jest configuration.'
+    ].join('\n'));
+    /* eslint-enable no-console */
+}
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/matchers/index.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    toSucceedWithDetail: <T extends import("../ts-utils").DetailedResult<unknown, unknown>>(received: T, expected: import("../ts-utils").ResultValueType<T> | RegExp, detail: import("../ts-utils").ResultDetailType<T> | undefined) => jest.CustomMatcherResult;
+    toSucceedWith: <T extends import("../ts-utils").Result<unknown>>(received: T, expected: import("../ts-utils").ResultValueType<T> | RegExp) => jest.CustomMatcherResult;
+    toSucceedAndSatisfy: <T>(this: jest.MatcherContext, received: import("../ts-utils").Result<T>, test: (value: T) => boolean | void) => jest.CustomMatcherResult;
+    toSucceedAndMatchSnapshot: <T>(this: jest.MatcherContext, received: import("../ts-utils").Result<T>) => jest.CustomMatcherResult;
+    toSucceedAndMatchInlineSnapshot: <T>(this: jest.MatcherContext, received: import("../ts-utils").Result<T>, snapshot: string | undefined) => jest.CustomMatcherResult;
+    toSucceed: <T>(received: import("../ts-utils").Result<T>) => jest.CustomMatcherResult;
+    toFailWithDetail: <T extends import("../ts-utils").DetailedResult<unknown, unknown>>(received: T, expectedMessage: string | RegExp | undefined, expectedDetail: import("../ts-utils").ResultDetailType<T>) => jest.CustomMatcherResult;
+    toFailWith: <T>(received: import("../ts-utils").Result<T>, expected: string | RegExp | undefined) => jest.CustomMatcherResult;
+    toFailTestWith: <T>(cb: () => void, expected: RegExp | string | string[]) => jest.CustomMatcherResult;
+    toFailTestAndMatchSnapshot: <T>(this: jest.MatcherContext, cb: () => void) => jest.CustomMatcherResult;
+    toFailTest: <T>(cb: () => void) => jest.CustomMatcherResult;
+    toFail: <T extends import("../ts-utils").Result<unknown>>(received: T) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/test/helpers/jest/matchers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toFail_1 = __importDefault(require("./toFail"));
+const toFailTest_1 = __importDefault(require("./toFailTest"));
+const toFailTestAndMatchSnapshot_1 = __importDefault(require("./toFailTestAndMatchSnapshot"));
+const toFailTestWith_1 = __importDefault(require("./toFailTestWith"));
+const toFailWith_1 = __importDefault(require("./toFailWith"));
+const toFailWithDetail_1 = __importDefault(require("./toFailWithDetail"));
+const toSucceed_1 = __importDefault(require("./toSucceed"));
+const toSucceedAndMatchInlineSnapshot_1 = __importDefault(require("./toSucceedAndMatchInlineSnapshot"));
+const toSucceedAndMatchSnapshot_1 = __importDefault(require("./toSucceedAndMatchSnapshot"));
+const toSucceedAndSatisfy_1 = __importDefault(require("./toSucceedAndSatisfy"));
+const toSucceedWith_1 = __importDefault(require("./toSucceedWith"));
+const toSucceedWithDetail_1 = __importDefault(require("./toSucceedWithDetail"));
+exports.default = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, toFail_1.default), toFailTest_1.default), toFailTestAndMatchSnapshot_1.default), toFailTestWith_1.default), toFailWith_1.default), toFailWithDetail_1.default), toSucceed_1.default), toSucceedAndMatchInlineSnapshot_1.default), toSucceedAndMatchSnapshot_1.default), toSucceedAndSatisfy_1.default), toSucceedWith_1.default), toSucceedWithDetail_1.default);
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/matchers/toFail/index.d.ts

@@ -0,0 +1,16 @@
+import { Result } from '../../../../../index';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toFail to verify that a Result<T> is a failure
+             */
+            toFail(): R;
+        }
+    }
+}
+declare const _default: {
+    toFail: <T extends Result<unknown>>(received: T) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/test/helpers/jest/matchers/toFail/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcherHelpers_1 = require("../../utils/matcherHelpers");
+const predicate_1 = require("./predicate");
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+function passMessage(received) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`.not.${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedResult)('failure', false),
+        (0, matcherHelpers_1.printReceivedResult)(received)
+    ].join('\n');
+}
+function failMessage(received) {
+    return () => [(0, jest_matcher_utils_1.matcherHint)(`${predicate_1.matcherName}`), (0, matcherHelpers_1.printExpectedResult)('failure', true), (0, matcherHelpers_1.printReceivedResult)(received)].join('\n');
+}
+exports.default = {
+    toFail: function (received) {
+        const pass = (0, predicate_1.predicate)(received);
+        if (pass) {
+            return { pass: true, message: passMessage(received) };
+        }
+        return { pass: false, message: failMessage(received) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/matchers/toFail/predicate.d.ts

@@ -0,0 +1,4 @@
+import { Result } from '../../../../../index';
+export declare const matcherName: string;
+export declare function predicate<T>(received: Result<T>): boolean;
+//# sourceMappingURL=predicate.d.ts.map

package/lib/test/helpers/jest/matchers/toFail/predicate.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matcherName = void 0;
+exports.predicate = predicate;
+exports.matcherName = 'toFail';
+function predicate(received) {
+    return received.isFailure();
+}
+//# sourceMappingURL=predicate.js.map

package/lib/test/helpers/jest/matchers/toFailTest/index.d.ts

@@ -0,0 +1,16 @@
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toFailTest to test a custom matcher by
+             * verifying that a test case fails.
+             */
+            toFailTest<T>(): R;
+        }
+    }
+}
+declare const _default: {
+    toFailTest: <T>(cb: () => void) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map