@fgv/ts-utils 5.0.0-12 → 5.0.0-15

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars,no-unused-vars */
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+const jest_snapshot_1 = require("jest-snapshot");
+const matcherHelpers_1 = require("../../utils/matcherHelpers");
+const matcherName = 'toSucceedAndMatchSnapshot';
+exports.default = {
+    toSucceedAndMatchSnapshot: function (received) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        (0, jest_matcher_utils_1.matcherHint)(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        (0, matcherHelpers_1.printReceivedResult)(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return jest_snapshot_1.toMatchSnapshot.call(context, received.value, 'toSucceedAndMatchSnapshot');
+    }
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,19 @@
+import { Result, ResultValueType } from '../../ts-utils';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toSucceedAndSatisfy to verify that a Result<T> is a success
+             * and that the supplied test function returns true (or void)
+             * for the resulting value
+             * @param test -
+             */
+            toSucceedAndSatisfy(test: (value: ResultValueType<T>) => boolean | void): R;
+        }
+    }
+}
+declare const _default: {
+    toSucceedAndSatisfy: <T>(this: jest.MatcherContext, received: Result<T>, test: (value: T) => boolean | void) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,55 @@
+"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) {
+    const expected = 'successful callback';
+    const got = [(0, matcherHelpers_1.printReceivedResult)(received)];
+    got.push('  Callback returned true');
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`.not.${predicate_1.matcherName}`, 'result', 'callback'),
+        (0, matcherHelpers_1.printExpectedResult)('success', false, expected),
+        ...got
+    ].join('\n');
+}
+function failMessage(received, cbResult) {
+    const expected = 'successful callback';
+    const got = [(0, matcherHelpers_1.printReceivedResult)(received)];
+    /* c8 ignore else */
+    if (cbResult.isFailure()) {
+        got.push(cbResult.message);
+    }
+    else if (cbResult.value === false) {
+        got.push('  Callback returned false');
+    }
+    else if (cbResult.value === undefined) {
+        /* c8 ignore else */
+        got.push('  Callback was not invoked');
+    }
+    else {
+        /* c8 ignore next */
+        throw new Error('Internal error: toSucceedAndSatisfy.failMessage passed success with true');
+    }
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`${predicate_1.matcherName}`, 'result', 'callback'),
+        (0, matcherHelpers_1.printExpectedResult)('success', true, expected),
+        ...got
+    ].join('\n');
+}
+exports.default = {
+    toSucceedAndSatisfy: function (received, test) {
+        // For the normal (not '.not') case, we do not want to capture exceptions
+        // so that the IDE can display exactly the line on which the failure case.
+        // For the .not case, we want to swallow exceptions or expect failures since
+        // we're just testing failure and not the reason.
+        const capture = this.isNot;
+        const cbResult = (0, predicate_1.predicate)(received, test, !!capture);
+        const pass = cbResult.isSuccess() && cbResult.value === true;
+        if (pass) {
+            return { pass: true, message: passMessage(received) };
+        }
+        return { pass: false, message: failMessage(received, cbResult) };
+    }
+};
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matcherName = void 0;
+exports.predicate = predicate;
+const ts_utils_1 = require("../../ts-utils");
+exports.matcherName = 'toSucceedAndSatisfy';
+// If the result is successful and callback does not throw, returns Success with the callback return value, or
+//    true if the callback returns undefined
+// If the result is successful but the callback throws, returns Failure with the thrown error
+// If the result is failure, returns Success with undefined
+function predicate(received, cb, capture) {
+    if (received.isSuccess()) {
+        const cbResult = capture ? (0, ts_utils_1.captureResult)(() => cb(received.value)) : (0, ts_utils_1.succeed)(cb(received.value));
+        if (cbResult.isSuccess()) {
+            return (0, ts_utils_1.succeed)(cbResult.value === true || cbResult.value === undefined);
+        }
+        return (0, ts_utils_1.fail)(`  Callback failed with:\n    ${cbResult.message}`);
+    }
+    return (0, ts_utils_1.succeed)(undefined);
+}
+//# sourceMappingURL=predicate.js.map

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

@@ -0,0 +1,18 @@
+import { Result, ResultValueType } from '../../../../../index';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toSucceedWith to verify that a Result\<T\> is a success
+             * and that the result value matches the supplied value
+             * @param expected -
+             */
+            toSucceedWith(expected: ResultValueType<T> | RegExp): R;
+        }
+    }
+}
+declare const _default: {
+    toSucceedWith: <T extends Result<unknown>>(received: T, expected: ResultValueType<T> | RegExp) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+"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, expected) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`.not.${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedResult)('success', false, expected),
+        (0, matcherHelpers_1.printReceivedResult)(received)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedResult)('success', true, expected),
+        (0, matcherHelpers_1.printReceivedResult)(received)
+    ].join('\n');
+}
+exports.default = {
+    toSucceedWith: function (received, expected) {
+        const pass = (0, predicate_1.predicate)(received, expected);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matcherName = void 0;
+exports.predicate = predicate;
+const expect_utils_1 = require("@jest/expect-utils");
+exports.matcherName = 'toSucceedWith';
+function predicate(received, expected) {
+    if (received.isSuccess()) {
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            return expected.test(received.value);
+        }
+        return (0, expect_utils_1.equals)(received.value, expected);
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

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

@@ -0,0 +1,18 @@
+import { DetailedResult, ResultDetailType, ResultValueType } from '../../ts-utils';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toSucceedWithDetail to verify that a DetailedResult\<T, TD\> is
+             * a success and that the result value and detail matches the supplied
+             * values
+             */
+            toSucceedWithDetail(expected: ResultValueType<T> | RegExp, detail: ResultDetailType<T> | undefined): R;
+        }
+    }
+}
+declare const _default: {
+    toSucceedWithDetail: <T extends DetailedResult<unknown, unknown>>(received: T, expected: ResultValueType<T> | RegExp, detail: ResultDetailType<T> | undefined) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+"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, expected, expectedDetail) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`.not.${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedDetailedResult)('success', false, expected, expectedDetail),
+        (0, matcherHelpers_1.printReceivedDetailedResult)(received)
+    ].join('\n');
+}
+function failMessage(received, expected, expectedDetail) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedDetailedResult)('success', true, expected, expectedDetail),
+        (0, matcherHelpers_1.printReceivedDetailedResult)(received)
+    ].join('\n');
+}
+exports.default = {
+    toSucceedWithDetail: function (received, expected, detail) {
+        const pass = (0, predicate_1.predicate)(received, expected, detail);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected, detail) };
+        }
+        return { pass: false, message: failMessage(received, expected, detail) };
+    }
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,4 @@
+import { DetailedResult } from '../../ts-utils';
+export declare const matcherName: string;
+export declare function predicate<T, TD>(received: DetailedResult<T, TD>, expected: unknown, detail: TD | undefined): boolean;
+//# sourceMappingURL=predicate.d.ts.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matcherName = void 0;
+exports.predicate = predicate;
+const expect_utils_1 = require("@jest/expect-utils");
+exports.matcherName = 'toSucceedWithDetail';
+function predicate(received, expected, detail) {
+    if (received.isSuccess()) {
+        let pass = false;
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            pass = expected.test(received.value);
+        }
+        else {
+            pass = (0, expect_utils_1.equals)(received.value, expected);
+        }
+        pass = pass && (0, expect_utils_1.equals)(received.detail, detail);
+        return pass;
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/lib/test/helpers/jest/resolvers/cli.d.ts

@@ -0,0 +1,5 @@
+export declare const CLI_SNAPSHOT_FOLDER: string;
+export declare function resolveSnapshotPath(testPath: string, ext: string): string;
+export declare function resolveTestPath(snapshotPath: string, ext: string): string;
+export declare const testPathForConsistencyCheck: string;
+//# sourceMappingURL=cli.d.ts.map

package/lib/test/helpers/jest/resolvers/cli.js

@@ -0,0 +1,48 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPathForConsistencyCheck = exports.CLI_SNAPSHOT_FOLDER = void 0;
+exports.resolveSnapshotPath = resolveSnapshotPath;
+exports.resolveTestPath = resolveTestPath;
+const Resolver = __importStar(require("../utils/snapshotResolver"));
+exports.CLI_SNAPSHOT_FOLDER = '__cli__';
+function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, exports.CLI_SNAPSHOT_FOLDER);
+}
+function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+exports.testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=cli.js.map

package/lib/test/helpers/jest/resolvers/ide.d.ts

@@ -0,0 +1,5 @@
+export declare const CLI_SNAPSHOT_FOLDER: string;
+export declare function resolveSnapshotPath(testPath: string, ext: string): string;
+export declare function resolveTestPath(snapshotPath: string, ext: string): string;
+export declare const testPathForConsistencyCheck: string;
+//# sourceMappingURL=ide.d.ts.map

package/lib/test/helpers/jest/resolvers/ide.js

@@ -0,0 +1,48 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPathForConsistencyCheck = exports.CLI_SNAPSHOT_FOLDER = void 0;
+exports.resolveSnapshotPath = resolveSnapshotPath;
+exports.resolveTestPath = resolveTestPath;
+const Resolver = __importStar(require("../utils/snapshotResolver"));
+exports.CLI_SNAPSHOT_FOLDER = '__ide__';
+function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, exports.CLI_SNAPSHOT_FOLDER);
+}
+function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+exports.testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=ide.js.map

package/lib/test/helpers/jest/ts-utils.d.ts

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

package/lib/test/helpers/jest/ts-utils.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("../../../index"), exports);
+//# sourceMappingURL=ts-utils.js.map

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

@@ -0,0 +1,79 @@
+import { ResultDetailType, ResultValueType } from '../ts-utils';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toSucceed to verify that a Result\<T\> is a success
+             */
+            toSucceed(): R;
+            /**
+             * Use .toSucceedWith to verify that a Result\<T\> is a success
+             * and that the result value matches the supplied value
+             * @param expected -
+             */
+            toSucceedWith(expected: ResultValueType<T> | RegExp): R;
+            /**
+             * Use .toSucceedWithDetail to verify that a DetailedResult\<T, TD\> is
+             * a success and that the result value and detail matches the supplied
+             * values
+             * @param expected -
+             * @param detail -
+             */
+            toSucceedWithDetail(expected: ResultValueType<T>, detail: ResultDetailType<T> | undefined): R;
+            /**
+             * Use .toSucceedAndSatisfy to verify that a Result\<T\> is a success
+             * and that the supplied test function returns true (or void)
+             * for the resulting value
+             * @param test -
+             */
+            toSucceedAndSatisfy(test: (value: ResultValueType<T>) => boolean | void): R;
+            /**
+             * Use .toSucceedAndMatchInlineSnapshot to verify that a Result\<T\> is a success
+             * and that the result value matches an inline snapshot
+             */
+            toSucceedAndMatchInlineSnapshot(snapshot: string | undefined): R;
+            /**
+             * Use .toSucceedAndMatchSnapshot to verify that a Result\<T\> is a success
+             * and that the result value matches a stored snapshot
+             */
+            toSucceedAndMatchSnapshot(): R;
+            /**
+             * Use .toFail to verify that a Result\<T\> is a failure
+             */
+            toFail(): R;
+            /**
+             * Use .toFailWith to verify that a Result\<T\> is a failure
+             * that matches a supplied string, RegExp or undefined value
+             * @param message -
+             */
+            toFailWith(expected: string | RegExp | undefined): R;
+            /**
+             * Use .toFailWithDetail to verify that a DetailedResult\<T\> is
+             * a failure that matches both a supplied expected failure value
+             * (string, RegExp or undefined) and a supplied failure detail.
+             * @param message -
+             * @param detail -
+             */
+            toFailWithDetail(message: string | RegExp | undefined, detail: ResultDetailType<T>): R;
+            /**
+             * Use .toFailTest to test a custom matcher by
+             * verifying that a test case fails.
+             */
+            toFailTest(): R;
+            /**
+             * Use .toFailTestWith to test a custom matcher by
+             * verifying that a test case fails as expected and
+             * reports an error matching a stored snapshot.
+             */
+            toFailTestAndMatchSnapshot(): R;
+            /**
+             * Use .toFailTestWith to test a custom matcher by
+             * verifying that a test case fails as expected and
+             * reports an error matching a supplied value.
+             * @param expected -
+             */
+            toFailTestWith(expected: string | string[] | RegExp): R;
+        }
+    }
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+"use strict";
+/// <reference types="jest"/>
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/utils/matcherHelpers.d.ts

@@ -0,0 +1,6 @@
+import { DetailedResult, Result } from '../ts-utils';
+export declare function printExpectedResult<T>(expect: 'success' | 'failure', isNot: boolean, expected?: T): string;
+export declare function printExpectedDetailedResult<T, TD>(expect: 'success' | 'failure', isNot: boolean, expectedMessage?: T, expectedDetail?: TD): string;
+export declare function printReceivedResult<T>(received: Result<T>): string;
+export declare function printReceivedDetailedResult<T, TD>(received: DetailedResult<T, TD>): string;
+//# sourceMappingURL=matcherHelpers.d.ts.map

package/lib/test/helpers/jest/utils/matcherHelpers.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printExpectedResult = printExpectedResult;
+exports.printExpectedDetailedResult = printExpectedDetailedResult;
+exports.printReceivedResult = printReceivedResult;
+exports.printReceivedDetailedResult = printReceivedDetailedResult;
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+function printExpectedValue(outcome, expected) {
+    return expected !== undefined ? `  ${outcome} with ${(0, jest_matcher_utils_1.printExpected)(expected)}` : `  ${outcome}`;
+}
+function printExpectedResult(expect, isNot, expected) {
+    return [
+        'Expected:',
+        isNot
+            ? expect === 'success'
+                ? printExpectedValue('Success', expected)
+                : printExpectedValue('Failure', expected)
+            : expect === 'success'
+                ? printExpectedValue('Not success', expected)
+                : printExpectedValue('Not failure', expected)
+    ].join('\n');
+}
+function printExpectedDetailedResult(expect, isNot, expectedMessage, expectedDetail) {
+    /* c8 ignore next */
+    return [
+        'Expected:',
+        isNot
+            ? expect === 'success'
+                ? printExpectedValue('Success', expectedMessage)
+                : printExpectedValue('Failure', expectedMessage)
+            : expect === 'success'
+                ? printExpectedValue('Not success', expectedMessage)
+                : printExpectedValue('Not failure', expectedMessage),
+        `  Detail: "${(0, jest_matcher_utils_1.printExpected)(expectedDetail)}"`
+    ].join('\n');
+}
+function printReceivedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with ${(0, jest_matcher_utils_1.printReceived)(received.value)}`
+            : `  Failure with "${received.message}"`
+    ].join('\n');
+}
+function printReceivedDetailedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with "${(0, jest_matcher_utils_1.printReceived)(received.value)}"\n  Detail: "${(0, jest_matcher_utils_1.printReceived)(received.detail)}"`
+            : `  Failure with "${received.message}"\n  Detail: "${(0, jest_matcher_utils_1.printReceived)(received.detail)}"`
+    ].join('\n');
+}
+//# sourceMappingURL=matcherHelpers.js.map

package/lib/test/helpers/jest/utils/snapshotResolver.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveSnapshotPath(testPath: string, snapshotExtension: string, snapshotFolderName: string): string;
+export declare function resolveTestPath(snapshotFilePath: string, snapshotExtension: string): string;
+export declare const testPathForConsistencyCheck: string;
+//# sourceMappingURL=snapshotResolver.d.ts.map

package/lib/test/helpers/jest/utils/snapshotResolver.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 });
+exports.testPathForConsistencyCheck = void 0;
+exports.resolveSnapshotPath = resolveSnapshotPath;
+exports.resolveTestPath = resolveTestPath;
+const path_1 = __importDefault(require("path"));
+function resolveSnapshotPath(testPath, snapshotExtension, snapshotFolderName) {
+    const snapshotPath = path_1.default.join(path_1.default.join(path_1.default.dirname(testPath), '__snapshots__', snapshotFolderName), path_1.default.basename(testPath) + snapshotExtension);
+    return snapshotPath;
+}
+function resolveTestPath(snapshotFilePath, snapshotExtension) {
+    const testPath = path_1.default.join(path_1.default.dirname(path_1.default.dirname(path_1.default.dirname(snapshotFilePath))), path_1.default.basename(snapshotFilePath, snapshotExtension));
+    return testPath;
+}
+exports.testPathForConsistencyCheck = path_1.default.posix.join('consistency_check', '__tests__', 'subdir', 'example.test.js');
+//# sourceMappingURL=snapshotResolver.js.map

package/lib/test/unit/collections/collectible.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=collectible.test.d.ts.map

package/lib/test/unit/collections/collector.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=collector.test.d.ts.map

package/lib/test/unit/collections/collectors.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=collectors.test.d.ts.map

package/lib/test/unit/collections/convertingCollector.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=convertingCollector.test.d.ts.map