fix: minor typing changes, add more expect chain tests

Author: pathurs

source/assert/assert.ts

@@ -8,7 +8,7 @@ import {
 class Assert<TSubject> {
     public readonly subject: TSubject;
 
-    public constructor (subject: TSubject) {
+    public constructor(subject: TSubject) {
         this.subject = subject;
     }
 
@@ -144,8 +144,7 @@ class Assert<TSubject> {
         const isTypeOfResult = this.isTypeOf('boolean');
 
         if (!isTypeOfResult.result) {
-            // @ts-expect-error
-            return isTypeOfResult;
+            return <AssertionResult<unknown, unknown, true>>isTypeOfResult;
         }
 
         // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -161,8 +160,7 @@ class Assert<TSubject> {
         const isTypeOfResult = this.isTypeOf('boolean');
 
         if (!isTypeOfResult.result) {
-            // @ts-expect-error
-            return isTypeOfResult;
+            return <AssertionResult<unknown, unknown, false>>isTypeOfResult;
         }
 
         // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -205,7 +203,9 @@ class Assert<TSubject> {
         return this.custom(this.subject, undefined, this.subject === undefined, 'Expected %subject% to %reverse=not %be undefined.', reverse);
     }
 
+    // eslint-disable-next-line @typescript-eslint/ban-types
     public isIn<TExpected extends object>(expected: TExpected): AssertionResult<TSubject, TSubject, TExpected>;
+    // eslint-disable-next-line @typescript-eslint/ban-types
     public isIn<TExpected extends object>(
         expected: TExpected,
         reverse: boolean
@@ -294,6 +294,7 @@ class Assert<TSubject> {
     public async resolves<TExpected>(expected: TExpected): Promise<AssertionResult<TSubject, unknown, TExpected>>;
     public async resolves<TExpected>(expected: TExpected, reverse: boolean): Promise<AssertionResult<TSubject, unknown, TExpected>>;
     public async resolves(expected: unknown = anything, reverse: boolean = false): Promise<AssertionResult<unknown, unknown, unknown>> {
+        // eslint-disable-next-line @typescript-eslint/ban-types
         const isInResult = new Assert('then').isIn(<object><unknown>this.subject);
 
         if (!isInResult.result) {
@@ -328,6 +329,7 @@ class Assert<TSubject> {
     public async rejects<TExpected>(expected: TExpected): Promise<AssertionResult<TSubject, unknown, TExpected>>;
     public async rejects<TExpected>(expected: TExpected, reverse: boolean): Promise<AssertionResult<TSubject, unknown, TExpected>>;
     public async rejects(expected: unknown = anything, reverse: boolean = false): Promise<AssertionResult<unknown, unknown, unknown>> {
+        // eslint-disable-next-line @typescript-eslint/ban-types
         const isInResult = new Assert('then').isIn(<object><unknown>this.subject);
 
         if (!isInResult.result) {

source/assert/assertion-result.ts

@@ -1,10 +1,10 @@
+import { AssertionResultEvent } from '../test/test-reporter/events/assertion-result/assertion-result-event';
+import { AssertionResultEventType } from '../test/test-reporter/events/assertion-result/assertion-result-event-type';
+import { TestReporter } from '../test/test-reporter';
 import { toDisplayString } from '@colonise/utilities';
 import {
     Test, TestCase
 } from '../test';
-import { TestReporter } from '../test/test-reporter';
-import { AssertionResultEvent } from '../test/test-reporter/events/assertion-result/assertion-result-event';
-import { AssertionResultEventType } from '../test/test-reporter/events/assertion-result/assertion-result-event-type';
 
 export type UnknownAssertionResult = AssertionResult<unknown, unknown, unknown>;
 
@@ -65,7 +65,7 @@ export class AssertionResult<TSubject, TActual, TExpected> {
     }
 
     // eslint-disable-next-line max-params
-    public constructor (
+    public constructor(
         subject: TSubject,
         actual: TActual,
         expected: TExpected,

source/expect/a-or-an.ts

@@ -1,5 +1,6 @@
+import { assert } from '../assert';
+import type { AssertionResult } from '../assert';
 import type { Constructor } from '@colonise/utilities';
-import { assert, AssertionResult } from '../assert';
 
 export interface AChain<TSubject> {
 
@@ -65,14 +66,9 @@ export interface AnChain<TSubject> {
      */
     <TExpected extends string>(expected: TExpected): AssertionResult<TSubject, TSubject, TExpected>;
 
-    /**
-     * @example expect(actual).to.be.an.object()
-     */
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    object(): AssertionResult<TSubject, TSubject, object>;
-
     instance: {
         of: {
+
             /**
              * @example expect(actual).to.be.an(expected)
              *
@@ -86,22 +82,28 @@ export interface AnChain<TSubject> {
              * @param expected
              */
             <TExpected extends string>(expected: TExpected): AssertionResult<TSubject, TSubject, TExpected>;
-        }
-    }
+        };
+    };
+
+    /**
+     * @example expect(actual).to.be.an.object()
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    object(): AssertionResult<TSubject, TSubject, object>;
 }
 
+// eslint-disable-next-line max-lines-per-function
 export function createAOrAnChain<TSubject>(subject: TSubject, reverse: boolean = false): AChain<TSubject> & AnChain<TSubject> {
-    return Object.defineProperties(
+    return <AChain<TSubject> & AnChain<TSubject>>Object.defineProperties(
         // eslint-disable-next-line id-length, prefer-arrow-callback
         function a<TExpected extends Constructor<TSubject> | string>(
             expected: TExpected
         ): AssertionResult<TSubject, TSubject, TExpected> {
             if (typeof expected === 'string') {
                 return <AssertionResult<TSubject, TSubject, TExpected>><unknown>assert(subject).isTypeOf(<'string'>expected, reverse);
             }
-            else {
-                return <AssertionResult<TSubject, TSubject, TExpected>>assert(subject).isAnInstanceOf(<Constructor<TSubject>>expected, reverse);
-            }
+
+            return <AssertionResult<TSubject, TSubject, TExpected>>assert(subject).isAnInstanceOf(<Constructor<TSubject>>expected, reverse);
         },
         {
             string: {
@@ -119,7 +121,7 @@ export function createAOrAnChain<TSubject>(subject: TSubject, reverse: boolean =
                     return assert(subject).isTypeOf('bigint', reverse);
                 }
             },
-            boolean: {
+            'boolean': {
                 value(): AssertionResult<TSubject, TSubject, boolean> {
                     return assert(subject).isTypeOf('boolean', reverse);
                 }
@@ -129,25 +131,26 @@ export function createAOrAnChain<TSubject>(subject: TSubject, reverse: boolean =
                     return assert(subject).isTypeOf('symbol', reverse);
                 }
             },
-            // eslint-disable-next-line @typescript-eslint/ban-types
-            function: {
+            'function': {
+                // eslint-disable-next-line @typescript-eslint/ban-types
                 value(): AssertionResult<TSubject, TSubject, Function> {
                     return assert(subject).isTypeOf('function', reverse);
                 }
             },
-            // eslint-disable-next-line @typescript-eslint/ban-types
             object: {
+                // eslint-disable-next-line @typescript-eslint/ban-types
                 value(): AssertionResult<TSubject, TSubject, object> {
                     return assert(subject).isTypeOf('object', reverse);
                 }
             },
             instance: {
                 get() {
                     return {
-                        of: function (expected: Constructor) {
+                        // eslint-disable-next-line id-length
+                        of(expected: Constructor) {
                             return assert(subject).isAnInstanceOf(expected, reverse);
                         }
-                    }
+                    };
                 }
             }
         }