strong-mock 9.0.0-beta.1 → 9.0.0-beta.3

package/dist/index.js

@@ -16,7 +16,6 @@ const MATCHER_SYMBOL = Symbol('matcher');
 /**
  * Used to test if an expectation is an argument is a custom matcher.
  */
-
 function isMatcher(f) {
   return !!(f && f[MATCHER_SYMBOL]);
 }
@@ -51,10 +50,8 @@ const getMatcherDiffs = (matchers, args) => {
  * fn(2) === 42
  * fn(-1) // throws
  */
-
 const matches = (predicate, options) => {
   var _options$toString, _options$getDiff;
-
   // We can't use destructuring with default values because `options` is optional,
   // so it needs a default value of `{}`, which will come with a native `toString`.
   const toString = (_options$toString = options == null ? void 0 : options.toString) != null ? _options$toString : () => `Matcher(${predicate.toString()})`;
@@ -73,7 +70,6 @@ const matches = (predicate, options) => {
           expected: actual
         };
       }
-
       return getDiff(actual);
     }
   };
@@ -84,11 +80,9 @@ const printProperty = property => {
   if (property === ApplyProp) {
     return '';
   }
-
   if (typeof property === 'symbol') {
     return `[${property.toString()}]`;
   }
-
   return `.${property}`;
 };
 const printValue = arg => {
@@ -96,20 +90,15 @@ const printValue = arg => {
   if (isMatcher(arg)) {
     return arg.toString();
   }
-
   return jestMatcherUtils.stringify(arg);
 };
-
 const printArgs = args => args.map(arg => printValue(arg)).join(', ');
-
 const printCall = (property, args) => {
   const prettyProperty = printProperty(property);
-
   if (args) {
     const prettyArgs = printArgs(args);
     return `mock${jestMatcherUtils.RECEIVED_COLOR(`${prettyProperty}(${prettyArgs})`)}`;
   }
-
   return `mock${jestMatcherUtils.RECEIVED_COLOR(`${prettyProperty}`)}`;
 };
 const printReturns = ({
@@ -118,7 +107,6 @@ const printReturns = ({
   value
 }, min, max) => {
   let thenPrefix = '';
-
   if (isPromise) {
     if (isError) {
       thenPrefix += 'thenReject';
@@ -130,16 +118,13 @@ const printReturns = ({
   } else {
     thenPrefix += 'thenReturn';
   }
-
   return `.${thenPrefix}(${jestMatcherUtils.RECEIVED_COLOR(printValue(value))}).between(${min}, ${max})`;
 };
 const printWhen = (property, args) => {
   const prettyProperty = printProperty(property);
-
   if (args) {
     return `when(() => mock${jestMatcherUtils.EXPECTED_COLOR(`${prettyProperty}(${printArgs(args)})`)})`;
   }
-
   return `when(() => mock${jestMatcherUtils.EXPECTED_COLOR(`${printProperty(property)}`)})`;
 };
 const printExpectation = (property, args, returnValue, min, max) => `${printWhen(property, args)}${printReturns(returnValue, min, max)}`;
@@ -155,7 +140,6 @@ set an expectation for it.
 
 ${printRemainingExpectations(expectations)}`));
   }
-
 }
 
 const printArgsDiff = (expected, actual) => {
@@ -163,14 +147,12 @@ const printArgsDiff = (expected, actual) => {
     omitAnnotationLines: true
   });
   /* istanbul ignore next this is not expected in practice */
-
   if (!diff) {
     return '';
   }
-
   const ansilessDiffLines = stripAnsi__default["default"](diff).split('\n');
-  let relevantDiffLines; // Strip Array [ ... ] surroundings.
-
+  let relevantDiffLines;
+  // Strip Array [ ... ] surroundings.
   if (!expected.length) {
     // - Array []
     // + Array [
@@ -188,20 +170,16 @@ const printArgsDiff = (expected, actual) => {
     //   ...
     // ]
     relevantDiffLines = ansilessDiffLines.slice(1, -1);
-  } // Strip the trailing comma.
-
-
+  }
+  // Strip the trailing comma.
   const lastLine = relevantDiffLines[relevantDiffLines.length - 1].slice(0, -1);
   const coloredDiffLines = [...relevantDiffLines.slice(0, -1), lastLine].map(line => {
     const first = line.charAt(0);
-
     switch (first) {
       case '-':
         return jestMatcherUtils.EXPECTED_COLOR(line);
-
       case '+':
         return jestMatcherUtils.RECEIVED_COLOR(line);
-
       default:
         return line;
     }
@@ -210,11 +188,9 @@ const printArgsDiff = (expected, actual) => {
 };
 const printExpectationDiff = (e, args) => {
   var _e$args;
-
   if (!((_e$args = e.args) != null && _e$args.length)) {
     return '';
   }
-
   const {
     actual,
     expected
@@ -223,7 +199,6 @@ const printExpectationDiff = (e, args) => {
 };
 const printDiffForAllExpectations = (expectations, actual) => expectations.map(e => {
   const diff = printExpectationDiff(e, actual);
-
   if (diff) {
     return `${e.toString()}
 ${jestMatcherUtils.EXPECTED_COLOR('- Expected')}
@@ -231,7 +206,6 @@ ${jestMatcherUtils.RECEIVED_COLOR('+ Received')}
 
 ${diff}`;
   }
-
   return undefined;
 }).filter(x => x).join('\n\n');
 
@@ -239,18 +213,15 @@ class UnexpectedCall extends Error {
   constructor(property, args, expectations) {
     const header = `Didn't expect ${printCall(property, args)} to be called.`;
     const propertyExpectations = expectations.filter(e => e.property === property);
-
     if (propertyExpectations.length) {
       var _propertyExpectations;
-
       super(jestMatcherUtils.DIM_COLOR(`${header}
 
 Remaining expectations:
-${printDiffForAllExpectations(propertyExpectations, args)}`)); // If we have a single expectation we can attach the actual/expected args
+${printDiffForAllExpectations(propertyExpectations, args)}`));
+      // If we have a single expectation we can attach the actual/expected args
       // to the error instance, so that an IDE may show its own diff for them.
-
       this.matcherResult = void 0;
-
       if (propertyExpectations.length === 1 && (_propertyExpectations = propertyExpectations[0].args) != null && _propertyExpectations.length) {
         const {
           actual,
@@ -268,11 +239,9 @@ No remaining expectations.`));
       this.matcherResult = void 0;
     }
   }
-
 }
 
 exports.UnexpectedProperty = void 0;
-
 (function (UnexpectedProperty) {
   /**
    * Throw an error immediately.
@@ -307,7 +276,6 @@ exports.UnexpectedProperty = void 0;
    * // Will throw "Didn't expect foo(42) to be called".
    * foo(42);
    */
-
   UnexpectedProperty[UnexpectedProperty["CALL_THROW"] = 1] = "CALL_THROW";
 })(exports.UnexpectedProperty || (exports.UnexpectedProperty = {}));
 
@@ -328,21 +296,16 @@ const unboxReturnValue = ({
       if (isPromise) {
         return Promise.reject(value);
       }
-
       throw value;
     }
-
     if (isPromise) {
       return Promise.reject(new Error(value));
     }
-
     throw new Error(value);
   }
-
   if (isPromise) {
     return Promise.resolve(value);
   }
-
   return value;
 };
 
@@ -350,16 +313,13 @@ const unboxReturnValue = ({
  * An expectation repository with a configurable behavior for
  * unexpected property access.
  */
-
 class FlexibleRepository {
   constructor(unexpectedProperty = exports.UnexpectedProperty.THROW) {
     this.unexpectedProperty = void 0;
     this.expectations = new Map();
     this.expectedCallStats = new Map();
     this.unexpectedCallStats = new Map();
-
     this.apply = args => this.get(ApplyProp)(...args);
-
     this.handlePropertyWithMatchingExpectations = (property, expectations) => {
       // Avoid recording call stats for function calls, since the property is an
       // internal detail.
@@ -368,63 +328,49 @@ class FlexibleRepository {
         // function that will not match the given args.
         this.recordExpected(property, undefined);
       }
-
       const propertyExpectation = expectations.find(e => e.expectation.matches(undefined));
-
       if (propertyExpectation) {
         this.countAndConsume(propertyExpectation);
         return unboxReturnValue(propertyExpectation.expectation.returnValue);
       }
-
       return (...args) => {
         const callExpectation = expectations.find(e => e.expectation.matches(args));
-
         if (callExpectation) {
           this.recordExpected(property, args);
           this.countAndConsume(callExpectation);
           return unboxReturnValue(callExpectation.expectation.returnValue);
         }
-
         return this.getValueForUnexpectedCall(property, args);
       };
     };
-
     this.handlePropertyWithNoExpectations = property => {
       switch (property) {
         case 'toString':
           return () => 'mock';
-
         case '@@toStringTag':
         case Symbol.toStringTag:
         case 'name':
           return 'mock';
         // Promise.resolve() tries to see if it's a "thenable".
         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#thenables
-
         case 'then':
           return undefined;
         // pretty-format
-
         case '$$typeof':
         case 'constructor':
         case '@@__IMMUTABLE_ITERABLE__@@':
         case '@@__IMMUTABLE_RECORD__@@':
           return null;
-
         case MATCHER_SYMBOL:
           return false;
-
         case ApplyProp:
           return (...args) => this.getValueForUnexpectedCall(property, args);
-
         default:
           return this.getValueForUnexpectedAccess(property);
       }
     };
-
     this.unexpectedProperty = unexpectedProperty;
   }
-
   add(expectation) {
     const {
       property
@@ -435,89 +381,73 @@ class FlexibleRepository {
       matchCount: 0
     }]);
   }
-
   clear() {
     this.expectations.clear();
     this.expectedCallStats.clear();
     this.unexpectedCallStats.clear();
   }
-
   // TODO: this returns any, but the interface returns unknown
   //   unknown causes errors in apply tests, and any causes bugs in bootstrapped SM
   get(property) {
     const expectations = this.expectations.get(property);
-
     if (expectations && expectations.length) {
       return this.handlePropertyWithMatchingExpectations(property, expectations);
     }
-
     return this.handlePropertyWithNoExpectations(property);
   }
-
   getAllProperties() {
     return Array.from(this.expectations.keys());
   }
-
   getCallStats() {
     return {
       expected: this.expectedCallStats,
       unexpected: this.unexpectedCallStats
     };
   }
-
   getUnmet() {
     return [].concat(...Array.from(this.expectations.values()).map(expectations => expectations.filter(e => e.expectation.min > e.matchCount).map(e => e.expectation)));
   }
-
   recordExpected(property, args) {
     const calls = this.expectedCallStats.get(property) || [];
     this.expectedCallStats.set(property, [...calls, {
       arguments: args
     }]);
   }
-
   recordUnexpected(property, args) {
     const calls = this.unexpectedCallStats.get(property) || [];
     this.unexpectedCallStats.set(property, [...calls, {
       arguments: args
     }]);
   }
-
   countAndConsume(expectation) {
     // eslint-disable-next-line no-param-reassign
     expectation.matchCount++;
     this.consumeExpectation(expectation);
   }
-
   consumeExpectation(expectation) {
     const {
       property,
       max
     } = expectation.expectation;
     const expectations = this.expectations.get(property);
-
     if (expectation.matchCount === max) {
       this.expectations.set(property, expectations.filter(e => e !== expectation));
     }
   }
-
   getValueForUnexpectedCall(property, args) {
     this.recordUnexpected(property, args);
     throw new UnexpectedCall(property, args, this.getUnmet());
   }
-
   getValueForUnexpectedAccess(property) {
     if (this.unexpectedProperty === exports.UnexpectedProperty.THROW) {
       this.recordUnexpected(property, undefined);
       throw new UnexpectedAccess(property, this.getUnmet());
     }
-
     return (...args) => {
       this.recordUnexpected(property, args);
       throw new UnexpectedCall(property, args, this.getUnmet());
     };
   }
-
 }
 
 /**
@@ -531,7 +461,6 @@ class FlexibleRepository {
  *   23
  * ).matches('bar', [1, 2, 3]) === true;
  */
-
 class StrongExpectation {
   constructor(property, args, returnValue, exactParams = false) {
     this.property = void 0;
@@ -546,47 +475,37 @@ class StrongExpectation {
     this.returnValue = returnValue;
     this.exactParams = exactParams;
   }
-
   setInvocationCount(min, max = 1) {
     this.min = min;
     this.max = max;
   }
-
   matches(args) {
     if (!this.matchesArgs(args)) {
       return false;
     }
-
     this.matched++;
     return this.max === 0 || this.matched <= this.max;
   }
-
   isUnmet() {
     return this.matched < this.min;
   }
-
   matchesArgs(received) {
     if (this.args === undefined) {
       return !received;
     }
-
     if (!received) {
       return false;
     }
-
     if (this.exactParams) {
       if (this.args.length !== received.length) {
         return false;
       }
     }
-
     return this.args.every((arg, i) => arg.matches(received[i]));
   }
-
   toString() {
     return printExpectation(this.property, this.args, this.returnValue, this.min, this.max);
   }
-
 }
 
 class UnfinishedExpectation extends Error {
@@ -598,7 +517,6 @@ ${printWhen(property, args)}
 Please finish it by setting a return value even if the value
 is undefined.`);
   }
-
 }
 class MissingWhen extends Error {
   constructor() {
@@ -606,7 +524,6 @@ class MissingWhen extends Error {
 
 Every call to set a return value must be preceded by an expectation.`);
   }
-
 }
 class NotAMock extends Error {
   constructor() {
@@ -614,7 +531,6 @@ class NotAMock extends Error {
 
 Make sure you're passing in an actual mock.`);
   }
-
 }
 class NestedWhen extends Error {
   constructor(parentProp, childProp) {
@@ -631,7 +547,6 @@ You can return an object directly when the first property is accessed,
 or you can even return a separate mock:
 ${snippet}`);
   }
-
 }
 
 class ExpectationBuilderWithFactory {
@@ -645,59 +560,33 @@ class ExpectationBuilderWithFactory {
     this.concreteMatcher = concreteMatcher;
     this.exactParams = exactParams;
   }
-
   setProperty(value) {
     if (this.property) {
       throw new UnfinishedExpectation(this.property, this.args);
     }
-
     this.property = value;
   }
-
   setArgs(value) {
     this.args = value;
   }
-
   finish(returnValue) {
     if (!this.property) {
       throw new MissingWhen();
     }
-
     const expectation = this.createExpectation(this.property, this.args, returnValue, this.concreteMatcher, this.exactParams);
     this.property = undefined;
     this.args = undefined;
     return expectation;
   }
-
-}
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
 }
 
 const removeUndefined = object => {
   if (Array.isArray(object)) {
     return object.map(x => removeUndefined(x));
   }
-
   if (!lodash.isObjectLike(object)) {
     return object;
   }
-
   return lodash.omitBy(object, lodash.isUndefined);
 };
 /**
@@ -709,18 +598,15 @@ const removeUndefined = object => {
  *   non `Object` instances with different constructors as not equal. Setting
  *   this to `false` will consider the objects in both cases as equal.
  *
- * @see {@link It.isPartial} or {@link It.isArray} if you want to nest matchers.
+ * @see {@link It.containsObject} or {@link It.isArray} if you want to nest matchers.
  * @see {@link It.is} if you want to use strict equality.
  */
-
-
 const deepEquals = (expected, {
   strict = true
 } = {}) => matches(actual => {
   if (strict) {
     return lodash.isEqual(actual, expected);
   }
-
   return lodash.isEqual(removeUndefined(actual), removeUndefined(expected));
 }, {
   toString: () => printValue(expected),
@@ -743,9 +629,11 @@ let currentDefaults = defaults;
  *   calls don't stack e.g. calling this with `{}` will clear any previously
  *   applied defaults.
  */
-
 const setDefaults = newDefaults => {
-  currentDefaults = _extends({}, defaults, newDefaults);
+  currentDefaults = {
+    ...defaults,
+    ...newDefaults
+  };
 };
 
 /**
@@ -763,7 +651,6 @@ const setDefaults = newDefaults => {
  * For that reason we can't just store the currently active mock, but also
  * whether we finished the expectation or not.
  */
-
 let activeMock;
 const setActiveMock = mock => {
   activeMock = mock;
@@ -775,13 +662,11 @@ const getActiveMock = () => activeMock;
  * This is needed because we can't reliably pass the state between `when`
  * and `thenReturn`.
  */
-
 const mockMap = new Map();
 const getMockState = mock => {
   if (mockMap.has(mock)) {
     return mockMap.get(mock);
   }
-
   throw new NotAMock();
 };
 const setMockState = (mock, state) => {
@@ -789,43 +674,35 @@ const setMockState = (mock, state) => {
 };
 const getAllMocks = () => Array.from(mockMap.entries());
 
-const createProxy = traps => // The Proxy target MUST be a function, otherwise we can't use the `apply` trap:
+const createProxy = traps =>
+// The Proxy target MUST be a function, otherwise we can't use the `apply` trap:
 // https://262.ecma-international.org/6.0/#sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist
 // eslint-disable-next-line no-empty-function,@typescript-eslint/no-empty-function
-new Proxy(
-/* istanbul ignore next */
-() => {}, {
+new Proxy( /* istanbul ignore next */() => {}, {
   get: (target, prop) => {
     if (prop === 'bind') {
       return (thisArg, ...args) => (...moreArgs) => traps.apply([...args, ...moreArgs]);
     }
-
     if (prop === 'apply') {
       return (thisArg, args) => traps.apply(args || []);
     }
-
     if (prop === 'call') {
       return (thisArg, ...args) => traps.apply(args);
     }
-
     return traps.property(prop);
   },
   apply: (target, thisArg, args) => traps.apply(args),
   ownKeys: () => traps.ownKeys(),
-
   getOwnPropertyDescriptor(target, prop) {
     const keys = traps.ownKeys();
-
     if (keys.includes(prop)) {
       return {
         configurable: true,
         enumerable: true
       };
     }
-
     return undefined;
   }
-
 });
 
 const createStub = (repo, builder, getCurrentMode) => {
@@ -834,7 +711,6 @@ const createStub = (repo, builder, getCurrentMode) => {
       if (getCurrentMode() === Mode.CALL) {
         return repo.get(property);
       }
-
       setActiveMock(stub);
       builder.setProperty(property);
       return createProxy({
@@ -853,7 +729,6 @@ const createStub = (repo, builder, getCurrentMode) => {
       if (getCurrentMode() === Mode.CALL) {
         return repo.apply(args);
       }
-
       setActiveMock(stub);
       builder.setProperty(ApplyProp);
       builder.setArgs(args);
@@ -863,7 +738,6 @@ const createStub = (repo, builder, getCurrentMode) => {
       if (getCurrentMode() === Mode.CALL) {
         return repo.getAllProperties();
       }
-
       throw new Error('Spreading during an expectation is not supported.');
     }
   });
@@ -872,19 +746,15 @@ const createStub = (repo, builder, getCurrentMode) => {
 
 const strongExpectationFactory = (property, args, returnValue, concreteMatcher, exactParams) => new StrongExpectation(property, // Wrap every non-matcher in the default matcher.
 args == null ? void 0 : args.map(arg => isMatcher(arg) ? arg : concreteMatcher(arg)), returnValue, exactParams);
-
 var Mode;
-
 (function (Mode) {
   Mode[Mode["EXPECT"] = 0] = "EXPECT";
   Mode[Mode["CALL"] = 1] = "CALL";
 })(Mode || (Mode = {}));
-
 let currentMode = Mode.CALL;
 const setMode = mode => {
   currentMode = mode;
 };
-
 const getMode = () => currentMode;
 /**
  * Create a type safe mock.
@@ -907,8 +777,6 @@ const getMode = () => currentMode;
  *
  * fn() === 23;
  */
-
-
 const mock = ({
   unexpectedProperty,
   concreteMatcher,
@@ -934,39 +802,31 @@ const createInvocationCount = expectation => ({
   between(min, max) {
     expectation.setInvocationCount(min, max);
   },
-
   /* istanbul ignore next */
   times(exact) {
     expectation.setInvocationCount(exact, exact);
   },
-
   /* istanbul ignore next */
   anyTimes() {
     expectation.setInvocationCount(0, 0);
   },
-
   /* istanbul ignore next */
   atLeast(min) {
     expectation.setInvocationCount(min, Infinity);
   },
-
   /* istanbul ignore next */
   atMost(max) {
     expectation.setInvocationCount(0, max);
   },
-
   /* istanbul ignore next */
   once() {
     expectation.setInvocationCount(1, 1);
   },
-
   /* istanbul ignore next */
   twice() {
     expectation.setInvocationCount(2, 2);
   }
   /* eslint-enable no-param-reassign, no-multi-assign */
-
-
 });
 
 const finishExpectation = (returnValue, builder, repo) => {
@@ -974,21 +834,18 @@ const finishExpectation = (returnValue, builder, repo) => {
   repo.add(finishedExpectation);
   return createInvocationCount(finishedExpectation);
 };
-
 const getError = errorOrMessage => {
   if (typeof errorOrMessage === 'string') {
     return new Error(errorOrMessage);
   }
-
   if (errorOrMessage instanceof Error) {
     return errorOrMessage;
   }
-
   return new Error();
 };
-
 const createReturns = (builder, repository) => ({
-  thenReturn: returnValue => finishExpectation( // This will handle both thenReturn(23) and thenReturn(Promise.resolve(3)).
+  thenReturn: returnValue => finishExpectation(
+  // This will handle both thenReturn(23) and thenReturn(Promise.resolve(3)).
   {
     value: returnValue,
     isError: false,
@@ -1036,7 +893,6 @@ const createReturns = (builder, repository) => ({
  * const fn = mock<(x: number) => Promise<number>();
  * when(() => fn(23)).thenResolve(42);
  */
-
 const when = expectation => {
   setMode(Mode.EXPECT);
   expectation();
@@ -1060,7 +916,6 @@ const when = expectation => {
  *
  * fn(); // throws
  */
-
 const reset = mock => {
   getMockState(mock).repository.clear();
 };
@@ -1069,7 +924,6 @@ const reset = mock => {
  *
  * @see reset
  */
-
 const resetAll = () => {
   getAllMocks().forEach(([mock]) => {
     reset(mock);
@@ -1082,7 +936,6 @@ class UnmetExpectations extends Error {
 
  - ${expectations.map(e => e.toString()).join('\n - ')}`));
   }
-
 }
 /**
  * Merge property accesses and method calls for the same property
@@ -1092,18 +945,14 @@ class UnmetExpectations extends Error {
  * mergeCalls({ getData: [{ arguments: undefined }, { arguments: [1, 2, 3] }] }
  * // returns { getData: [{ arguments: [1, 2, 3] } }
  */
-
 const mergeCalls = callMap => new Map(Array.from(callMap.entries()).map(([property, calls]) => {
   const hasMethodCalls = calls.some(call => call.arguments);
   const hasPropertyAccesses = calls.some(call => !call.arguments);
-
   if (hasMethodCalls && hasPropertyAccesses) {
     return [property, calls.filter(call => call.arguments)];
   }
-
   return [property, calls];
 }));
-
 class UnexpectedCalls extends Error {
   constructor(unexpectedCalls, expectations) {
     const printedCalls = Array.from(mergeCalls(unexpectedCalls).entries()).map(([property, calls]) => calls.map(call => printCall(property, call.arguments)).join('\n - ')).join('\n - ');
@@ -1113,18 +962,14 @@ class UnexpectedCalls extends Error {
 
 ${printRemainingExpectations(expectations)}`));
   }
-
 }
 
 const verifyRepo = repository => {
   const unmetExpectations = repository.getUnmet();
-
   if (unmetExpectations.length) {
     throw new UnmetExpectations(unmetExpectations);
   }
-
   const callStats = repository.getCallStats();
-
   if (callStats.unexpected.size) {
     throw new UnexpectedCalls(callStats.unexpected, unmetExpectations);
   }
@@ -1146,7 +991,6 @@ const verifyRepo = repository => {
  *
  * verify(fn); // throws
  */
-
 const verify = mock => {
   const {
     repository
@@ -1158,7 +1002,6 @@ const verify = mock => {
  *
  * @see verify
  */
-
 const verifyAll = () => {
   getAllMocks().forEach(([mock]) => {
     verify(mock);
@@ -1172,7 +1015,6 @@ const verifyAll = () => {
  *
  * @see It.deepEquals A matcher that uses deep equality.
  */
-
 const is = expected => matches(actual => Object.is(actual, expected), {
   toString: () => `${printValue(expected)}`,
   getDiff: actual => ({
@@ -1190,7 +1032,6 @@ const is = expected => matches(actual => Object.is(actual, expected), {
  *
  * fn(23, 'foobar') === 1
  */
-
 const isAny = () => matches(() => true, {
   toString: () => 'Matcher<any>'
 });
@@ -1215,21 +1056,17 @@ const isAny = () => matches(() => true, {
  * @example
  * It.isArray([It.isString({ containing: 'foobar' })])
  */
-
 const isArray = containing => matches(actual => {
   if (!Array.isArray(actual)) {
     return false;
   }
-
   if (!containing) {
     return true;
   }
-
   return containing.every(x => actual.find(y => {
     if (isMatcher(x)) {
       return x.matches(y);
     }
-
     return deepEquals(x).matches(y);
   }) !== undefined);
 }, {
@@ -1242,12 +1079,10 @@ const isArray = containing => matches(actual => {
           if (isMatcher(value)) {
             return value.toString();
           }
-
           return value;
         }).join(', ')}])`
       };
     }
-
     return {
       actual: `${printValue(actual)} (${typeof actual})`,
       expected: 'Matcher<array>'
@@ -1265,7 +1100,6 @@ const isArray = containing => matches(actual => {
  * fn(20.5) === 42
  * fn(NaN) // throws
  */
-
 const isNumber = () => matches(actual => typeof actual === 'number' && !Number.isNaN(actual), {
   toString: () => 'Matcher<number>',
   getDiff: actual => ({
@@ -1278,7 +1112,7 @@ const isNumber = () => matches(actual => typeof actual === 'number' && !Number.i
  * Matches any plain object e.g. object literals or objects created with `Object.create()`.
  *
  * Classes, arrays, maps, sets etc. are not considered plain objects.
- * You can use {@link isPartial} or {@link matches} to match those.
+ * You can use {@link containsObject} or {@link matches} to match those.
  *
  * @example
  * const fn = mock<({ foo: string }) => number>();
@@ -1286,7 +1120,6 @@ const isNumber = () => matches(actual => typeof actual === 'number' && !Number.i
  *
  * fn({ foo: 'bar' }) // returns 42
  */
-
 const isPlainObject = () => matches(actual => lodash.isPlainObject(actual), {
   toString: () => 'Matcher<object>',
   getDiff: actual => {
@@ -1299,89 +1132,68 @@ const isPlainObject = () => matches(actual => lodash.isPlainObject(actual), {
 });
 
 const looksLikeObject = value => lodash.isPlainObject(value);
-
 const getExpectedObjectDiff = (actual, expected) => Object.fromEntries(getKeys(expected).map(key => {
   const expectedValue = getKey(expected, key);
   const actualValue = getKey(actual, key);
-
   if (isMatcher(expectedValue)) {
     return [key, expectedValue.getDiff(actualValue).expected];
   }
-
   if (looksLikeObject(expectedValue)) {
     return [key, getExpectedObjectDiff(actualValue, expectedValue)];
   }
-
   return [key, expectedValue];
 }));
-
 const getActualObjectDiff = (actual, expected) => {
   const actualKeys = getKeys(actual);
   const expectedKeys = new Set(getKeys(expected));
   const commonKeys = actualKeys.filter(key => expectedKeys.has(key));
-
   if (!commonKeys.length) {
     // When we don't have any common keys we return the whole object
     // so the user can inspect what's in there.
     return actual;
   }
-
   return Object.fromEntries(commonKeys.map(key => {
     const expectedValue = getKey(expected, key);
     const actualValue = getKey(actual, key);
-
     if (isMatcher(expectedValue)) {
       return [key, expectedValue.getDiff(actualValue).actual];
     }
-
     if (looksLikeObject(expectedValue)) {
       return [key, getActualObjectDiff(actualValue, expectedValue)];
     }
-
     return [key, actualValue];
   }));
 };
-
 const getKeys = value => {
   if (typeof value === 'object' && value !== null) {
     return Reflect.ownKeys(value);
   }
-
   return [];
 };
-
 const getKey = (value, key) => // @ts-expect-error because we're fine with a runtime undefined value
 value == null ? void 0 : value[key];
-
 const isMatch = (actual, expected) => {
   const actualKeys = getKeys(actual);
   const expectedKeys = getKeys(expected);
-
   if (!isArray(expectedKeys).matches(actualKeys)) {
     return false;
   }
-
   return expectedKeys.every(key => {
     const expectedValue = getKey(expected, key);
     const actualValue = getKey(actual, key);
-
     if (isMatcher(expectedValue)) {
       return expectedValue.matches(actualValue);
     }
-
     if (looksLikeObject(expectedValue)) {
       return isMatch(actualValue, expectedValue);
     }
-
     return deepEquals(expectedValue).matches(actualValue);
   });
 };
-
 const deepPrintObject = value => lodash.cloneDeepWith(value, value => {
   if (isMatcher(value)) {
     return value.toString();
   }
-
   return undefined;
 });
 /**
@@ -1391,21 +1203,22 @@ const deepPrintObject = value => lodash.cloneDeepWith(value, value => {
  * @param partial A subset of the expected object that will be recursively matched.
  *   Supports nested matchers.
  *   Concrete values will be compared with {@link deepEquals}.
- *   Note that a `{}` partial will match ANY value including non-objects.
- *   Use {@link isPlainObject} if you want to match any plain object.
+ *
+ * @see {@link isPlainObject} if you want to match any plain object.
  *
  * @example
  * const fn = mock<(pos: { x: number, y: number }) => number>();
- * when(() => fn(It.isPartial({ x: 23 }))).returns(42);
+ * when(() => fn(It.containsObject({ x: 23 }))).returns(42);
  *
  * fn({ x: 23, y: 200 }) // returns 42
  *
  * @example
- * It.isPartial({ foo: It.isString() })
+ * It.containsObject({ foo: It.isString() })
  */
-
-
-const isPartial = partial => matches(actual => isMatch(actual, partial), {
+// T is not constrained to ObjectType because of
+// https://github.com/microsoft/TypeScript/issues/57810,
+// but K is to avoid inferring non-object partials
+const containsObject = partial => matches(actual => isMatch(actual, partial), {
   toString: () => `Matcher<object>(${printValue(deepPrintObject(partial))})`,
   getDiff: actual => ({
     actual: getActualObjectDiff(actual, partial),
@@ -1426,27 +1239,22 @@ const isPartial = partial => matches(actual => isMatch(actual, partial), {
  * fn('foo', 'baz') // throws
  * fn('foo', 'bar') === 42
  */
-
 const isString = matching => matches(actual => {
   if (typeof actual !== 'string') {
     return false;
   }
-
   if (!matching) {
     return true;
   }
-
   if (typeof matching === 'string') {
     return actual.indexOf(matching) !== -1;
   }
-
   return matching.test(actual);
 }, {
   toString: () => {
     if (matching) {
       return `Matcher<string>(${matching})`;
     }
-
     return 'Matcher<string>';
   },
   getDiff: actual => {
@@ -1456,7 +1264,6 @@ const isString = matching => matches(actual => {
         actual
       };
     }
-
     return {
       expected: 'Matcher<string>',
       actual: `${actual} (${typeof actual})`
@@ -1481,7 +1288,6 @@ const isString = matching => matches(actual => {
  * fn(x => x + 1);
  * matcher.value?.(3) === 4
  */
-
 const willCapture = name => {
   let capturedValue;
   const matcher = {
@@ -1495,11 +1301,9 @@ const willCapture = name => {
       actual,
       expected: actual
     }),
-
     get value() {
       return capturedValue;
     }
-
   };
   return matcher;
 };
@@ -1514,7 +1318,7 @@ var it = {
   isArray: isArray,
   isNumber: isNumber,
   isPlainObject: isPlainObject,
-  isPartial: isPartial,
+  containsObject: containsObject,
   isString: isString,
   matches: matches,
   willCapture: willCapture