refactor: Remove isObject

BREAKING CHANGE: `isObject` has been replaced by `isPlainObject` and
`isPartial`.

README.md

@@ -85,7 +85,7 @@ const fn = mock<(pos: { x: number; y: number }) => boolean>();
 
 when(() =>
   fn(
-    It.isObject({
+    It.isPartial({
       x: It.isNumber(),
       y: It.matches<number>((y) => y > 0)
     })
@@ -289,7 +289,7 @@ const fn = mock<
 
 when(() => fn(
   It.isAny(),
-  It.isObject({ values: [1, 2, 3] })
+  It.isPartial({ values: [1, 2, 3] })
 )).thenReturn('matched!');
 
 console.log(fn(
@@ -301,7 +301,7 @@ console.log(fn(
 You can mix matchers with concrete arguments:
 
 ```typescript
-when(() => fn(42, It.isObject())).thenReturn('matched');
+when(() => fn(42, It.isPlainObject())).thenReturn('matched');
 ```
 
 Available matchers:
@@ -311,7 +311,8 @@ Available matchers:
 - `isNumber` - matches any number,
 - `isString` - matches any string, can search for substrings and patterns,
 - `isArray` - matches any array, can search for subsets,
-- `isObject` - matches any object, can search for partial objects,
+- `isPlainObject` - matches any plain object,
+- `isPartial` - recursively matches a subset of an object,
 - `matches` - build your own matcher,
 - `willCapture` - matches anything and stores the received value.
 
@@ -324,12 +325,12 @@ The following table illustrates the differences between the equality matchers:
 | `{ }`              | `{ foo: undefined }` | not equal | not equal       | equal                              |
 | `new (class {})()` | `new (class {})()`   | not equal | not equal       | equal                              |
 
-Some matchers, like `isObject` and `isArray` support nesting matchers:
+Some matchers, like `isPartial` and `isArray` support nesting matchers:
 
 ```typescript
-It.isObject({ foo: It.isString() })
+It.isPartial({ foo: It.isString() })
 
-It.isArray([ It.isObject({
+It.isArray([ It.isPartial({
   foo: It.isString({ matching: /foo/ })
 })])
 ```

adrs/002-matcher-diffs.md

@@ -89,7 +89,7 @@ This ADR aims to cover printing arguments that match the expected values as part
 
 - matchers must handle the case where the received value matches the expected value and return a representation of the received value according to the matcher's definition
 - except for `deepEquals` and `is`, all matchers will hide some part of the received value in the diff, potentially making debugging harder; the full values will always be present at the top of the error message, but with large diffs that might be easy to miss
-- increases matcher complexity, as values can be formatted naively e.g. `object` for `isObject`, or in a more complex way e.g. showing only the partial match for `isObject(partial)`
+- increases matcher complexity, as values can be formatted naively e.g. `object` for `isPartial`, or in a more complex way e.g. showing only the partial match for `isPartial(partial)`
 - increases duplication between `toString` and `getDiff`
 
 ### State of the art

src/matchers/deep-equals.ts

@@ -24,7 +24,7 @@ const removeUndefined = (object: any): any => {
  *   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.isObject} or {@link It.isArray} if you want to nest matchers.
+ * @see {@link It.isPartial} or {@link It.isArray} if you want to nest matchers.
  * @see {@link It.is} if you want to use strict equality.
  */
 export const deepEquals = <T>(

src/matchers/is-array.spec.ts

@@ -1,6 +1,6 @@
 import { expectAnsilessEqual } from '../../tests/ansiless';
 import { isArray } from './is-array';
-import { isObject } from './is-object';
+import { isPartial } from './is-partial';
 import { isString } from './is-string';
 import { matches } from './matcher';
 
@@ -48,7 +48,7 @@ describe('isArray', () => {
 
   it('should match nested matchers', () => {
     expect(
-      isArray([isString(), isObject({ foo: 'bar' })]).matches([
+      isArray([isString(), isPartial({ foo: 'bar' })]).matches([
         'foo',
         { foo: 'bar' },
       ])