feat(assertions): add some more aliases; cleanup

chore(diff): cleanup

Author: boneskull

site/assertions/collection.md

@@ -58,6 +58,11 @@ expect([1, 2, 3], 'not to be empty');
 
 ### `{array} to have length {nonnegative-integer}`
 
+> ✏️ Aliases:
+>
+>     {array} to have length {nonnegative-integer}
+>     {array} to have size {nonnegative-integer}
+
 **Success**:
 
 ```js

site/assertions/object.md

@@ -89,6 +89,12 @@ expect({ a: 1 }, 'not to be empty');
 >     {object} to have keys {array}
 >     {object} to have properties {array}
 >     {object} to have props {array}
+>     {object} to include keys {array}
+>     {object} to include properties {array}
+>     {object} to include props {array}
+>     {object} to contain keys {array}
+>     {object} to contain properties {array}
+>     {object} to contain props {array}
 
 **Success**:
 
@@ -117,6 +123,12 @@ expect({ a: 1 }, 'not to have keys', ['a', 'b']);
 >     {object} to have key {keypath}
 >     {object} to have property {keypath}
 >     {object} to have prop {keypath}
+>     {object} to include key {keypath}
+>     {object} to include property {keypath}
+>     {object} to include prop {keypath}
+>     {object} to contain key {keypath}
+>     {object} to contain property {keypath}
+>     {object} to contain prop {keypath}
 
 Tests whether an object has a property at the specified keypath using dot or bracket notation. This assertion supports complex _keypath_ traversal including nested properties, array indices, and quoted keys.
 

src/assertion/impl/async-parametric.ts

@@ -51,8 +51,6 @@ export const functionResolveAssertion = createAsyncAssertion(
       await subject();
     } catch {
       return {
-        actual: 'function rejected',
-        expected: 'function to fulfill',
         message: 'Expected function to fulfill, but it rejected instead',
       };
     }
@@ -67,18 +65,11 @@ export const functionResolveAssertion = createAsyncAssertion(
  * ```typescript
  * await expectAsync(Promise.resolve('success'), 'to resolve'); // passes
  * await expectAsync(Promise.reject('error'), 'to fulfill'); // fails
- * /**
- * Assertion for testing if a promise resolves.
- *
- * @example
- *
- * ```typescript
- * await expectAsync(Promise.resolve('success'), 'to resolve'); // passes
- * await expectAsync(Promise.reject('error'), 'to resolve'); // fails
  * ```
  *
- * @group Parametric Assertions (Async) @bupkisAnchor promise-to-resolve
  * @bupkisAssertionCategory promise
+ * @bupkisAnchor promise-to-resolve
+ * @group Parametric Assertions (Async)
  */
 export const promiseResolveAssertion = createAsyncAssertion(
   [WrappedPromiseLikeSchema, ['to resolve', 'to fulfill']],
@@ -87,8 +78,6 @@ export const promiseResolveAssertion = createAsyncAssertion(
       await subject;
     } catch {
       return {
-        actual: 'promise rejected',
-        expected: 'promise to fulfill',
         message: 'Expected promise to fulfill, but it rejected instead',
       };
     }
@@ -113,8 +102,6 @@ export const functionRejectAssertion = createAsyncAssertion(
     const { error, result } = await trapAsyncFnError(subject);
     if (error === undefined) {
       return {
-        actual: 'function fulfilled',
-        expected: 'function rejected',
         message: `Expected function to reject, but it fulfilled with ${inspect(result)}`,
       };
     }
@@ -139,8 +126,6 @@ export const promiseRejectAssertion = createAsyncAssertion(
     const { error, result } = await trapPromiseError(subject);
     if (error === undefined) {
       return {
-        actual: 'Promise fulfilled',
-        expected: 'Promise rejected',
         message: `Expected Promise to reject, but it fulfilled with ${inspect(result)}`,
       };
     }