@fgv/ts-utils 5.0.1-9 → 5.0.1

package/dist/packlets/validation/validators.js

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2023 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail, isKeyOf, MessageAggregator } from '../base';
+import { ArrayValidator } from './array';
+import { ObjectValidator } from './object';
+import { TypeGuardValidator } from './typeGuard';
+import { BooleanValidator } from './boolean';
+import { GenericValidator } from './genericValidator';
+import { NumberValidator } from './number';
+import { OneOfValidator } from './oneOf';
+import { StringValidator } from './string';
+/**
+ * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
+ * @public
+ */
+export const string = new StringValidator();
+/**
+ * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
+ * @public
+ */
+export const number = new NumberValidator();
+/**
+ * A {@link Validation.Classes.BooleanValidator | BooleanValidator} which validates a boolean in place.
+ * @public
+ */
+export const boolean = new BooleanValidator();
+/**
+ * Helper function to create a {@link Validation.Classes.ObjectValidator | ObjectValidator} which validates
+ * an object in place.
+ * @param fields - A {@link Validation.Classes.FieldValidators | field validator definition}
+ * describing the validations to be applied.
+ * @param params - Optional {@link Validation.Classes.ObjectValidatorConstructorParams | parameters}
+ * to refine the behavior of the resulting {@link Validation.Validator | validator}.
+ * @returns A new {@link Validation.Validator | Validator} which validates the desired
+ * object in place.
+ * @public
+ */
+export function object(fields, params) {
+    return new ObjectValidator(Object.assign({ fields }, (params !== null && params !== void 0 ? params : {})));
+}
+/**
+ * Helper function to create a {@link Validation.Classes.ArrayValidator | ArrayValidator} which
+ * validates an array in place.
+ * @param validateElement - A {@link Validation.Validator | validator} which validates each element.
+ * @returns A new {@link Validation.Classes.ArrayValidator | ArrayValidator } which validates the desired
+ * array in place.
+ * @public
+ */
+export function arrayOf(validateElement, params) {
+    return new ArrayValidator(Object.assign({ validateElement }, (params !== null && params !== void 0 ? params : {})));
+}
+/**
+ * A helper function to create a {@link Validation.Validator | Validator} which validates the `string`-keyed properties
+ * using a supplied {@link Validation.Validator | Validator<T, TC>} to produce a `Record<TK, T>`.
+ * @remarks
+ * If present, the supplied {@link Validators.IRecordOfValidatorOptions | options} can provide a strongly-typed
+ * validator for keys and/or control the handling of elements that fail validation.
+ * @param validator - {@link Validation.Validator | Validator} used for each item in the source object.
+ * @param options - Optional {@link Validators.IRecordOfValidatorOptions | IRecordOfValidatorOptions<TK, TC>} which
+ * supplies a key validator and/or error-handling options.
+ * @returns A {@link Validation.Validator | Validator} which validates `Record<TK, T>`.
+ * @public
+ */
+export function recordOf(validator, options) {
+    const opts = Object.assign({ onError: 'fail' }, options);
+    return new GenericValidator({
+        validator: (from, context, self) => {
+            if (typeof from !== 'object' || from === null || Array.isArray(from)) {
+                return fail(`Not a string-keyed object: ${JSON.stringify(from)}`);
+            }
+            const errors = new MessageAggregator();
+            for (const key in from) {
+                if (isKeyOf(key, from)) {
+                    // Validate key if keyValidator is provided
+                    if (opts.keyValidator) {
+                        const keyResult = opts.keyValidator.validate(key, context);
+                        if (!keyResult.isSuccess()) {
+                            if (opts.onError === 'ignore') {
+                                continue;
+                            }
+                            errors.addMessage(`Key "${key}": ${keyResult.message}`);
+                            if (opts.onError === 'fail') {
+                                return fail(keyResult.message);
+                            }
+                        }
+                    }
+                    // Validate value
+                    const valueResult = validator.validate(from[key], context);
+                    if (!valueResult.isSuccess()) {
+                        if (opts.onError === 'ignore') {
+                            continue;
+                        }
+                        errors.addMessage(`Property "${key}": ${valueResult.message}`);
+                        if (opts.onError === 'fail') {
+                            return fail(valueResult.message);
+                        }
+                    }
+                }
+            }
+            /* c8 ignore next 1 - defense in depth */
+            return errors.hasMessages ? fail(errors.toString()) : true;
+        }
+    });
+}
+/**
+ * Helper function to create a {@link Validation.Validator} which validates an enumerated
+ * value in place.
+ * @public
+ */
+export function enumeratedValue(values) {
+    return new GenericValidator({
+        validator: (from, context, self) => {
+            if (typeof from === 'string') {
+                const v = context !== null && context !== void 0 ? context : values;
+                const index = v.indexOf(from);
+                return index >= 0 ? true : fail(`Invalid enumerated value "${from}"  - expected: (${v.join(', ')})`);
+            }
+            return fail(`Not a string: "${JSON.stringify(from, undefined, 2)}`);
+        }
+    });
+}
+/**
+ * Helper function to create a {@link Validation.Validator} which validates a literal value.
+ * @param value - the literal value to be validated
+ * @public
+ */
+export function literal(value) {
+    return new GenericValidator({
+        validator: (from, context, self) => {
+            return from === value
+                ? true
+                : fail(`Expected literal ${String(value)}, found "${JSON.stringify(from, undefined, 2)}`);
+        }
+    });
+}
+/**
+ * Helper function to create a {@link Validation.Validator | Validator} which validates one
+ * of several possible validated values.
+ * @param validators - the {@link Validation.Validator | validators} to be considered.
+ * @param params - Optional {@link Validation.Classes.OneOfValidatorConstructorParams | params} used to construct the validator.
+ * @returns A new {@link Validator | Validator} which validates values that match any of
+ * the supplied validators.
+ * @public
+ */
+export function oneOf(validators, params) {
+    return new OneOfValidator(Object.assign(Object.assign({}, (params !== null && params !== void 0 ? params : {})), { validators }));
+}
+/**
+ * Helper function to create a {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator} which
+ * validates a value or object in place.
+ * @param description - a description of the thing to be validated for use in error messages
+ * @param guard - a {@link Validation.TypeGuardWithContext} which performs the validation.
+ * @returns A new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator } which validates
+ * the values using the supplied type guard.
+ * @public
+ */
+export function isA(description, guard, params) {
+    return new TypeGuardValidator(Object.assign({ description, guard }, (params !== null && params !== void 0 ? params : {})));
+}
+/**
+ * Helper function to create a {@link Validation.Validator | Validator} using a
+ * supplied {@link Validation.ValidatorFunc | validator function}.
+ * @param validator - A {@link Validation.ValidatorFunc | validator function} that a
+ * supplied unknown value matches some condition.
+ * @returns A new {@link Validation.Validator | Validator} which validates the desired
+ * value using the supplied function.
+ * @public
+ */
+export function generic(validator) {
+    return new GenericValidator({ validator });
+}
+//# sourceMappingURL=validators.js.map

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

@@ -0,0 +1,139 @@
+/*
+ * 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 * as 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() {
+        return new ReadWriteSpies(jest.spyOn(fs, 'readFileSync').mockImplementation((wanted) => {
+            if (typeof wanted !== 'string') {
+                throw new Error('readFileSync mock supports only string parameters');
+            }
+            return this.readMockFileSync(wanted);
+        }), jest.spyOn(fs, '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/test/helpers/jest/helpers/index.js

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

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

@@ -0,0 +1,17 @@
+import matchers from './matchers';
+import './types';
+export { MockFileSystem } from './helpers';
+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/test/helpers/jest/matchers/index.js

@@ -0,0 +1,14 @@
+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 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({}, ToFail), ToFailTest), ToFailTestAndMatchSnapshot), ToFailTestWith), ToFailWith), ToFailWithDetail), ToSucceed), ToSucceedAndMatchInlineSnapshot), ToSucceedAndMatchSnapshot), ToSucceedAndSatisfy), ToSucceedWith), toSucceedWithDetail);
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/matchers/toFailTestAndMatchSnapshot/index.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchSnapshot } from 'jest-snapshot';
+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, cbResult.value, 'toFailTestAndMatchSnapshot');
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/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/test/helpers/jest/matchers/toSucceed/predicate.js

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