@fgv/ts-utils-jest 5.0.1-9 → 5.0.2-0

package/dist/helpers/fsHelpers.js

@@ -0,0 +1,141 @@
+/*
+ * 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 fs from 'fs';
+import path from 'path';
+/**
+ * @public
+ */
+export 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();
+    }
+}
+/**
+ * @public
+ */
+export class MockFileSystem {
+    constructor(configs, options) {
+        this._extraWrites = [];
+        this._config = new Map();
+        this._data = new Map();
+        this._options = options;
+        this._realReadFileSync = fs.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(fsModule) {
+        // Dynamic import of fs at runtime to avoid babel instrumentation timing issues
+        const fsToMock = fsModule || require('fs');
+        return new ReadWriteSpies(jest.spyOn(fsToMock, 'readFileSync').mockImplementation((wanted) => {
+            if (typeof wanted !== 'string') {
+                throw new Error('readFileSync mock supports only string parameters');
+            }
+            return this.readMockFileSync(wanted);
+        }), jest.spyOn(fsToMock, '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);
+        }));
+    }
+}
+//# sourceMappingURL=fsHelpers.js.map

package/dist/helpers/index.js

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

package/dist/index.js

@@ -0,0 +1,18 @@
+import matchers from './matchers';
+import './types';
+import * as MockFs from './helpers/fsHelpers';
+export { MockFs };
+function isJestGlobal(g) {
+    return g.hasOwnProperty('expect');
+}
+/* c8 ignore else */
+if (isJestGlobal(global)) {
+    global.expect.extend(matchers);
+}
+else {
+    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'));
+}
+//# sourceMappingURL=index.js.map

package/dist/matchers/index.js

@@ -0,0 +1,15 @@
+import ToFail from './toFail';
+import ToFailTest from './toFailTest';
+import ToFailTestAndMatchSnapshot from './toFailTestAndMatchSnapshot';
+import ToFailTestWith from './toFailTestWith';
+import ToFailWith from './toFailWith';
+import ToFailWithDetail from './toFailWithDetail';
+import ToHaveBeenCalledWithArgumentsMatching from './toHaveBeenCalledWithArgumentsMatching';
+import ToSucceed from './toSucceed';
+import ToSucceedAndMatchInlineSnapshot from './toSucceedAndMatchInlineSnapshot';
+import ToSucceedAndMatchSnapshot from './toSucceedAndMatchSnapshot';
+import ToSucceedAndSatisfy from './toSucceedAndSatisfy';
+import ToSucceedWith from './toSucceedWith';
+import toSucceedWithDetail from './toSucceedWithDetail';
+export 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(Object.assign({}, ToFail), ToFailTest), ToFailTestAndMatchSnapshot), ToFailTestWith), ToFailWith), ToFailWithDetail), ToHaveBeenCalledWithArgumentsMatching), ToSucceed), ToSucceedAndMatchInlineSnapshot), ToSucceedAndMatchSnapshot), ToSucceedAndSatisfy), ToSucceedWith), toSucceedWithDetail);
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFail/index.js

@@ -0,0 +1,23 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedResult('failure', false),
+        printReceivedResult(received)
+    ].join('\n');
+}
+function failMessage(received) {
+    return () => [matcherHint(`${matcherName}`), printExpectedResult('failure', true), printReceivedResult(received)].join('\n');
+}
+export default {
+    toFail: function (received) {
+        const pass = predicate(received);
+        if (pass) {
+            return { pass: true, message: passMessage(received) };
+        }
+        return { pass: false, message: failMessage(received) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFail/predicate.js

@@ -0,0 +1,5 @@
+export const matcherName = 'toFail';
+export function predicate(received) {
+    return received.isFailure();
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toFailTest/index.js

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+import { printExpectedResult } from '../../utils/matcherHelpers';
+function passMessage() {
+    return () => [
+        matcherHint(`.not.${matcherName}`, 'callback'),
+        printExpectedResult('failure', false),
+        '  Received: Test failed'
+    ].join('\n');
+}
+function failMessage() {
+    return () => [
+        matcherHint(`${matcherName}`, 'callback'),
+        printExpectedResult('failure', true),
+        '  Received: Test passed'
+    ].join('\n');
+}
+export default {
+    toFailTest: function (cb) {
+        const pass = predicate(cb);
+        if (pass) {
+            return { pass: true, message: passMessage() };
+        }
+        return { pass: false, message: failMessage() };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFailTest/predicate.js

@@ -0,0 +1,8 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { captureResult } from '../../ts-utils';
+export const matcherName = 'toFailTest';
+export function predicate(cb) {
+    const cbResult = captureResult(() => cb());
+    return cbResult.isFailure();
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toFailTestAndMatchSnapshot/index.js

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { toMatchSnapshot } from 'jest-snapshot';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+import { stripAnsiColors } from '../../utils/colorHelpers';
+export default {
+    toFailTestAndMatchSnapshot: function (cb) {
+        const context = this;
+        const cbResult = predicate(cb);
+        if (cbResult.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        '  Expected: Callback to fail with an error that matches snapshot',
+                        '  Received: Callback succeeded'
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchSnapshot.call(context, stripAnsiColors(cbResult.value), 'toFailTestAndMatchSnapshot');
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFailTestAndMatchSnapshot/predicate.js

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { captureResult, fail, succeed } from '../../ts-utils';
+export const matcherName = 'toFailTestAndMatchSnapshot';
+export function predicate(cb) {
+    const cbResult = captureResult(() => cb());
+    if (cbResult.isFailure()) {
+        return succeed(cbResult.message);
+    }
+    return fail('Callback did not fail');
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toFailTestWith/index.js

@@ -0,0 +1,29 @@
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+import { printExpectedResult } from '../../utils/matcherHelpers';
+function passMessage(cbResult, expected) {
+    return () => [
+        matcherHint(`.not.${matcherName}`, 'callback', 'expectedMessage'),
+        printExpectedResult('failure', false, expected),
+        `  Received: Callback failed with:\n>>>>\n${cbResult.value}\n<<<<`
+    ].join('\n');
+}
+function failMessage(cbResult, expected) {
+    return () => [
+        matcherHint(`${matcherName}`, 'callback', 'expectedMessage'),
+        printExpectedResult('failure', true, expected),
+        cbResult.message === ''
+            ? '  Received: Callback succeeded'
+            : `  Received: Callback failed with:\n>>>>\n${cbResult.message}\n<<<<`
+    ].join('\n');
+}
+export default {
+    toFailTestWith: function (cb, expected) {
+        const cbResult = predicate(cb, expected);
+        if (cbResult.isSuccess()) {
+            return { pass: true, message: passMessage(cbResult, expected) };
+        }
+        return { pass: false, message: failMessage(cbResult, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFailTestWith/predicate.js

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { equals } from '@jest/expect-utils';
+import { stringify } from 'jest-matcher-utils';
+import { captureResult, fail, succeed } from '../../ts-utils';
+export const matcherName = 'toFailTestWith';
+export function predicate(cb, expected) {
+    const cbResult = captureResult(() => cb());
+    if (cbResult.isFailure()) {
+        let success = false;
+        if (expected instanceof RegExp) {
+            success = cbResult.message.match(expected) !== null;
+        }
+        else if (typeof expected === 'string') {
+            success = cbResult.message === expected;
+        }
+        else if (Array.isArray(expected)) {
+            success = equals(cbResult.message.split('\n'), expected);
+        }
+        else {
+            return fail(`Unsupported expected value "${stringify(expected)}" for toFailTestWith`);
+        }
+        return success ? succeed(cbResult.message) : fail(cbResult.message);
+    }
+    return fail('');
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toFailWith/index.js

@@ -0,0 +1,27 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedResult('failure', false, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedResult('failure', true, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+export default {
+    toFailWith: function (received, expected) {
+        const pass = predicate(received, expected);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFailWith/predicate.js

@@ -0,0 +1,16 @@
+export const matcherName = 'toFailWith';
+export function predicate(received, expected) {
+    if (received.isFailure()) {
+        if (expected === undefined) {
+            return received.message === undefined;
+        }
+        else if (expected instanceof RegExp) {
+            return received.message.match(expected) !== null;
+        }
+        else {
+            return received.message === expected;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toFailWithDetail/index.js

@@ -0,0 +1,27 @@
+import { printExpectedDetailedResult, printReceivedDetailedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expectedMessage, expectedDetail) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedDetailedResult('failure', false, expectedMessage, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expectedMessage, expectedDetail) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedDetailedResult('failure', true, expectedMessage, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+export default {
+    toFailWithDetail: function (received, expectedMessage, expectedDetail) {
+        const pass = predicate(received, expectedMessage, expectedDetail);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expectedMessage, expectedDetail) };
+        }
+        return { pass: false, message: failMessage(received, expectedMessage, expectedDetail) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toFailWithDetail/predicate.js

@@ -0,0 +1,22 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toFailWith';
+export function predicate(received, expectedResult, expectedDetail) {
+    if (received.isFailure()) {
+        if (expectedResult === undefined) {
+            if (received.message !== undefined) {
+                return false;
+            }
+        }
+        else if (expectedResult instanceof RegExp) {
+            if (received.message.match(expectedResult) === null) {
+                return false;
+            }
+        }
+        else if (received.message !== expectedResult) {
+            return false;
+        }
+        return equals(received.detail, expectedDetail);
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toHaveBeenCalledWithArgumentsMatching/index.js

@@ -0,0 +1,69 @@
+import { getTypeOfProperty, getValueOfPropertyOrDefault } from '@fgv/ts-utils';
+import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
+import { matcherName, predicate } from './predicate';
+function getRange(length, cursor) {
+    // less than 3 return everything
+    if (length < 3) {
+        return { start: 0, end: length };
+    }
+    if (cursor === 0) {
+        return { start: 0, end: 3 };
+    }
+    else if (cursor >= length - 1) {
+        return { start: length - 3, end: length };
+    }
+    return { start: cursor - 1, end: cursor + 2 };
+}
+function formatOneCall(index, received, cursor) {
+    const indexString = index.toLocaleString([], { maximumFractionDigits: 0, minimumIntegerDigits: 3 });
+    const cursorString = cursor ? '*' : ' ';
+    return `${cursorString}${indexString}: ${printReceived(received)}`;
+}
+function formatArgsMessage(received, cursor) {
+    const calls = received.mock.calls;
+    if (calls.length > 0) {
+        // if there's no cursor, show the last 3
+        const { start, end } = getRange(calls.length, cursor !== undefined ? cursor : calls.length - 1);
+        const callsToShow = calls.slice(start, end);
+        return callsToShow.map((c, i) => formatOneCall(start + i, c, start + i === cursor));
+    }
+    return [];
+}
+function passMessage(received, expected, matched) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        'Expected no call with arguments matching:',
+        `      ${printExpected(expected)}`,
+        `Received (${received.mock.calls.length} total):`,
+        ...formatArgsMessage(received, matched.index)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        'Expected call with arguments matching:',
+        `      ${printExpected(expected)}`,
+        `Received (${received.mock.calls.length} total):`,
+        ...formatArgsMessage(received)
+    ].join('\n');
+}
+function isMock(received) {
+    if (received !== null && !Array.isArray(received)) {
+        return (getValueOfPropertyOrDefault('_isMockFunction', received) === true &&
+            getTypeOfProperty('mock', received) === 'object');
+    }
+    return false;
+}
+export default {
+    toHaveBeenCalledWithArgumentsMatching: function (received, expected) {
+        if (!isMock(received)) {
+            throw new Error('Test error: toHaveBeenCalledWithArgumentsMatching called with other than jest.Mock');
+        }
+        const matched = predicate(received, expected);
+        if (matched !== undefined) {
+            return { pass: true, message: passMessage(received, expected, matched) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toHaveBeenCalledWithArgumentsMatching/predicate.js

@@ -0,0 +1,12 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toHaveBeenCalledWithArgumentsMatching';
+export function predicate(received, expected) {
+    for (let i = 0; i < received.mock.calls.length; i++) {
+        const args = received.mock.calls[i];
+        if (equals(args, expected)) {
+            return { index: i, arguments: args };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toSucceed/index.js

@@ -0,0 +1,23 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedResult('success', false),
+        printReceivedResult(received)
+    ].join('\n');
+}
+function failMessage(received) {
+    return () => [matcherHint(`${matcherName}`), printExpectedResult('success', true), printReceivedResult(received)].join('\n');
+}
+export default {
+    toSucceed: function (received) {
+        const pass = predicate(received);
+        if (pass) {
+            return { pass: true, message: passMessage(received) };
+        }
+        return { pass: false, message: failMessage(received) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toSucceed/predicate.js

@@ -0,0 +1,5 @@
+export const matcherName = 'toSucceed';
+export function predicate(received) {
+    return received.isSuccess();
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toSucceedAndMatchInlineSnapshot/index.js

@@ -0,0 +1,23 @@
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchInlineSnapshot } from 'jest-snapshot';
+import { printReceivedResult } from '../../utils/matcherHelpers';
+const matcherName = 'toSucceedAndMatchInlineSnapshot';
+export default {
+    toSucceedAndMatchInlineSnapshot: function (received, snapshot) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        printReceivedResult(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchInlineSnapshot.call(context, received.value, {}, snapshot);
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toSucceedAndMatchSnapshot/index.js

@@ -0,0 +1,23 @@
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchSnapshot } from 'jest-snapshot';
+import { printReceivedResult } from '../../utils/matcherHelpers';
+const matcherName = 'toSucceedAndMatchSnapshot';
+export default {
+    toSucceedAndMatchSnapshot: function (received) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        printReceivedResult(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchSnapshot.call(context, received.value, 'toSucceedAndMatchSnapshot');
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toSucceedAndSatisfy/index.js

@@ -0,0 +1,51 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received) {
+    const expected = 'successful callback';
+    const got = [printReceivedResult(received)];
+    got.push('  Callback returned true');
+    return () => [
+        matcherHint(`.not.${matcherName}`, 'result', 'callback'),
+        printExpectedResult('success', false, expected),
+        ...got
+    ].join('\n');
+}
+function failMessage(received, cbResult) {
+    const expected = 'successful callback';
+    const got = [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) {
+        got.push('  Callback was not invoked');
+    }
+    else {
+        throw new Error('Internal error: toSucceedAndSatisfy.failMessage passed success with true');
+    }
+    return () => [
+        matcherHint(`${matcherName}`, 'result', 'callback'),
+        printExpectedResult('success', true, expected),
+        ...got
+    ].join('\n');
+}
+export 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 = 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/dist/matchers/toSucceedAndSatisfy/predicate.js

@@ -0,0 +1,17 @@
+import { captureResult, fail, succeed } from '../../ts-utils';
+export const 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
+export function predicate(received, cb, capture) {
+    if (received.isSuccess()) {
+        const cbResult = capture ? captureResult(() => cb(received.value)) : succeed(cb(received.value));
+        if (cbResult.isSuccess()) {
+            return succeed(cbResult.value === true || cbResult.value === undefined);
+        }
+        return fail(`  Callback failed with:\n    ${cbResult.message}`);
+    }
+    return succeed(undefined);
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toSucceedWith/index.js

@@ -0,0 +1,27 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedResult('success', false, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedResult('success', true, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+export default {
+    toSucceedWith: function (received, expected) {
+        const pass = predicate(received, expected);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/matchers/toSucceedWith/predicate.js

@@ -0,0 +1,12 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toSucceedWith';
+export function predicate(received, expected) {
+    if (received.isSuccess()) {
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            return expected.test(received.value);
+        }
+        return equals(received.value, expected);
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/matchers/toSucceedWithDetail/index.js

@@ -0,0 +1,27 @@
+import { printExpectedDetailedResult, printReceivedDetailedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected, expectedDetail) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedDetailedResult('success', false, expected, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected, expectedDetail) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedDetailedResult('success', true, expected, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+export default {
+    toSucceedWithDetail: function (received, expected, detail) {
+        const pass = 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/dist/matchers/toSucceedWithDetail/predicate.js

@@ -0,0 +1,17 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toSucceedWithDetail';
+export 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 = equals(received.value, expected);
+        }
+        pass = pass && equals(received.detail, detail);
+        return pass;
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/resolvers/cli.js

@@ -0,0 +1,16 @@
+import * as Resolver from '../utils/snapshotResolver';
+const CLI_SNAPSHOT_FOLDER = '__cli__';
+function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, CLI_SNAPSHOT_FOLDER);
+}
+function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+const testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+module.exports = {
+    resolveSnapshotPath,
+    resolveTestPath,
+    testPathForConsistencyCheck
+};
+export default module.exports;
+//# sourceMappingURL=cli.js.map

package/dist/resolvers/ide.js

@@ -0,0 +1,16 @@
+import * as Resolver from '../utils/snapshotResolver';
+const CLI_SNAPSHOT_FOLDER = '__ide__';
+function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, CLI_SNAPSHOT_FOLDER);
+}
+function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+const testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+module.exports = {
+    resolveSnapshotPath,
+    resolveTestPath,
+    testPathForConsistencyCheck
+};
+export default module.exports;
+//# sourceMappingURL=ide.js.map

package/dist/ts-utils.js

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

package/dist/types/index.js

@@ -0,0 +1,3 @@
+/// <reference types="jest"/>
+export {};
+//# sourceMappingURL=index.js.map

package/dist/utils/colorHelpers.js

@@ -0,0 +1,80 @@
+/**
+ * Utility functions for handling ANSI color codes in test output.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Regular expression to match ANSI color/style escape sequences.
+ *
+ * This matches:
+ * - ESC character (ASCII 27) followed by `[`
+ * - `[0-9;]*` - Zero or more digits and semicolons (parameters)
+ * - `[a-zA-Z]` - Single letter command (m for SGR, K for erase, etc.)
+ *
+ * Examples of what this matches:
+ * - `\u001b[31m` - Red foreground
+ * - `\u001b[39m` - Default foreground
+ * - `\u001b[2m` - Dim/faint
+ * - `\u001b[22m` - Normal intensity
+ *
+ * Using a pre-compiled regex literal to satisfy ESLint security requirements.
+ * We use the unicode escape sequence \\u001b instead of \\x1b to avoid control-regex warnings.
+ */
+// eslint-disable-next-line no-control-regex
+const ANSI_COLOR_REGEX = /\u001b\[[0-9;]*[a-zA-Z]/g;
+/**
+ * Strips ANSI color/style escape sequences from a string.
+ *
+ * This function removes all ANSI escape sequences commonly used for
+ * terminal colors and text styling, making the output suitable for
+ * color-agnostic snapshot testing.
+ *
+ * @param text - The text that may contain ANSI escape sequences
+ * @returns The text with all ANSI escape sequences removed
+ *
+ * @example
+ * ```typescript
+ * const coloredText = '\u001b[31mError:\u001b[39m Something failed';
+ * const plainText = stripAnsiColors(coloredText);
+ * console.log(plainText); // "Error: Something failed"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Common usage in Jest matchers
+ * const formattedOutput = matcherUtils.printReceived(value);
+ * const cleanOutput = stripAnsiColors(formattedOutput);
+ * expect(cleanOutput).toMatchSnapshot();
+ * ```
+ *
+ * @public
+ */
+export function stripAnsiColors(text) {
+    return text.replace(ANSI_COLOR_REGEX, '');
+}
+/**
+ * Creates a wrapper function that strips ANSI colors from any string-returning function.
+ *
+ * This is useful for wrapping Jest matcher utility functions to make them
+ * color-agnostic for snapshot testing.
+ *
+ * @param fn - A function that returns a string (potentially with ANSI colors)
+ * @returns A wrapped function that returns the same string with colors stripped
+ *
+ * @example
+ * ```typescript
+ * import { printReceived } from 'jest-matcher-utils';
+ *
+ * const printReceivedClean = createColorStripWrapper(printReceived);
+ * const output = printReceivedClean(someValue); // No colors
+ * ```
+ *
+ * @public
+ */
+export function createColorStripWrapper(fn) {
+    return ((...args) => {
+        const result = fn(...args);
+        return stripAnsiColors(result);
+    });
+}
+//# sourceMappingURL=colorHelpers.js.map

package/dist/utils/matcherHelpers.js

@@ -0,0 +1,51 @@
+import { printExpected, printReceived } from 'jest-matcher-utils';
+import { createColorStripWrapper } from './colorHelpers';
+// Create color-stripped versions of Jest matcher utilities
+const printExpectedClean = createColorStripWrapper(printExpected);
+const printReceivedClean = createColorStripWrapper(printReceived);
+function printExpectedValue(outcome, expected) {
+    return expected !== undefined ? `  ${outcome} with ${printExpectedClean(expected)}` : `  ${outcome}`;
+}
+export 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');
+}
+export 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: "${printExpectedClean(expectedDetail)}"`
+    ].join('\n');
+}
+export function printReceivedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with ${printReceivedClean(received.value)}`
+            : `  Failure with "${received.message}"`
+    ].join('\n');
+}
+export function printReceivedDetailedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with "${printReceivedClean(received.value)}"\n  Detail: "${printReceivedClean(received.detail)}"`
+            : `  Failure with "${received.message}"\n  Detail: "${printReceivedClean(received.detail)}"`
+    ].join('\n');
+}
+//# sourceMappingURL=matcherHelpers.js.map

package/dist/utils/snapshotResolver.js

@@ -0,0 +1,11 @@
+import path from 'path';
+export function resolveSnapshotPath(testPath, snapshotExtension, snapshotFolderName) {
+    const snapshotPath = path.join(path.join(path.dirname(testPath), '__snapshots__', snapshotFolderName), path.basename(testPath) + snapshotExtension);
+    return snapshotPath;
+}
+export function resolveTestPath(snapshotFilePath, snapshotExtension) {
+    const testPath = path.join(path.dirname(path.dirname(path.dirname(snapshotFilePath))), path.basename(snapshotFilePath, snapshotExtension));
+    return testPath;
+}
+export const testPathForConsistencyCheck = path.posix.join('consistency_check', '__tests__', 'subdir', 'example.test.js');
+//# sourceMappingURL=snapshotResolver.js.map

package/lib/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.53.3"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@fgv/ts-utils-jest",
-  "version": "5.0.1-9",
+  "version": "5.0.2-0",
   "description": "Custom matchers for ts-utils result class",
   "main": "lib/index.js",
+  "module": "dist/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
   "keywords": [
     "typescript",
     "ts-utils",
@@ -42,10 +52,16 @@
     "@types/heft-jest": "1.0.6",
     "eslint-plugin-n": "^17.23.1",
     "eslint-plugin-tsdoc": "~0.4.0",
-    "@fgv/ts-utils": "5.0.1-9"
+    "@microsoft/api-extractor": "^7.53.3",
+    "@fgv/ts-utils": "5.0.2-0",
+    "@fgv/heft-dual-rig": "0.1.0"
   },
   "peerDependencies": {
-    "@fgv/ts-utils": "5.0.1-9"
+    "@fgv/ts-utils": "5.0.2-0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ErikFortune/fgv.git"
   },
   "scripts": {
     "build": "heft build --clean",