feat: add CustomPromise (#67)

* feat: add `CustomPromise`

* refactor: rename custom promise to promise

* refactor(then): move wrappers to the bottom

* build(bun): set coverage limit

* ci(gh-actions): add codecov v4

* refactor: rewrite the `PromiseState` type

* feat: add `then` method

* test: replace bun test runner with vitest

* build(husky): set test:unit script

* feat: add `catch` method

* feat: add base promise implementation

* build: update lock file

* feat: add finally method

* refactor: add global variables `resolvedPromise` and `rejectedPromise`

* refactor(comparator): simplify structure

* refactor: remove unused types

* feat: add `all` static method

* refactor: replace acc with accumulator

* feat: add `race` method

* test: add appropriate value for the test

* test(race): replace error with error.message

* feat: add `allSettled` static method

Author: mg901

.github/workflows/pull-request.yml

@@ -17,7 +17,11 @@ jobs:
       - name: Unit Testing
         run: bun test:unit:coverage
 
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
+      - uses: actions/checkout@master
+      - uses: codecov/codecov-action@v4
+        with:
+          flags: unittests # optional
+          name: codecov-umbrella
+          verbose: true
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

bun.lockb

@@ -2,4 +2,4 @@
 
 # always enable coverage
 coverage = true
-coverageThreshold = 0.9
+coverageThreshold = 0.6

bunfig.toml

@@ -17,30 +17,35 @@
   "devDependencies": {
     "@commitlint/cli": "^18.6.0",
     "@commitlint/config-conventional": "^18.6.0",
+    "@types/lodash.delay": "^4.1.9",
     "@types/lodash.isequal": "^4.5.8",
+    "@types/lodash.isfunction": "^3.0.9",
     "@typescript-eslint/eslint-plugin": "^6.19.1",
     "@typescript-eslint/parser": "^6.19.1",
     "@vitest/coverage-v8": "^1.2.2",
     "bun-types": "^1.0.25",
     "commitizen": "^4.3.0",
-    "cz-conventional-changelog": "^3.3.0",
     "eslint": "^8.56.0",
     "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
     "git-cz": "^4.9.0",
     "husky": "^8.0.3",
-    "lint-staged": "^15.2.0",
-    "prettier": "^3.2.4",
+    "lint-staged": "^15.2.2",
+    "prettier": "^3.2.5",
     "typescript": "^5.3.3",
+    "utility-types": "^3.11.0",
     "vite-tsconfig-paths": "^4.3.1",
     "vitest": "^1.2.2"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "lodash.isequal": "^4.5.0"
+    "lodash.delay": "^4.1.1",
+    "lodash.isequal": "^4.5.0",
+    "lodash.isfunction": "^3.0.9"
   }
 }

package.json

@@ -65,117 +65,6 @@ describe('DoublyLinkedList', () => {
     });
   });
 
-  describe('isEmpty', () => {
-    it('works correctly', () => {
-      // Arrange
-      expect(doublyLinkedList.isEmpty).toBeTruthy();
-      doublyLinkedList.append(1);
-
-      // Act and Assert
-      expect(doublyLinkedList.isEmpty).toBeFalsy();
-    });
-  });
-
-  describe('toString', () => {
-    it('converts a list to string', () => {
-      doublyLinkedList.append(1).append(2);
-
-      expect(doublyLinkedList.toString()).toBe('1,2');
-    });
-    it('converts a list to string with custom callback', () => {
-      // Arrange
-      type NodeValue = {
-        key: string;
-        value: number;
-      };
-
-      const list = new DoublyLinkedList<NodeValue>();
-
-      list
-        .append({
-          key: 'one',
-          value: 1,
-        })
-        .append({
-          key: 'two',
-          value: 2,
-        });
-
-      // Act
-      const received = list.toString((node) => `${node.value}`);
-
-      // Assert
-      expect(received).toBe('1,2');
-    });
-  });
-
-  describe('fromArray', () => {
-    it('creates an empty list when an empty array is passed', () => {
-      // Act
-      doublyLinkedList.fromArray([]);
-
-      // Assert
-      expect(doublyLinkedList.head).toBeNull();
-      expect(doublyLinkedList.tail).toBeNull();
-      expect(doublyLinkedList.size).toBe(0);
-    });
-
-    it('creates a list with the same nodes as the input array', () => {
-      // Act
-      doublyLinkedList.fromArray([1, 2]);
-
-      // Assert
-      expect(doublyLinkedList.toString()).toBe('1,2');
-    });
-  });
-
-  describe('Iterator', () => {
-    it('handles an empty list', () => {
-      // Act
-      const received = Array.from(doublyLinkedList);
-
-      // Assert
-      expect(received).toEqual([]);
-    });
-    it('iterates through the elements of the list', () => {
-      // Arrange
-      const expected = [1, 2, 3];
-
-      doublyLinkedList.fromArray(expected);
-
-      // Act
-      const received = Array.from(doublyLinkedList, (node) => node.data);
-
-      // Assert
-      expect(received).toEqual(expected);
-    });
-  });
-
-  describe('toArray', () => {
-    it('converts an empty list to an array', () => {
-      // Act
-      const received = doublyLinkedList.toArray();
-
-      // Assert
-      expect(received).toEqual([]);
-      expect(doublyLinkedList.head).toBeNull();
-      expect(doublyLinkedList.tail).toBeNull();
-      expect(doublyLinkedList.size).toBe(0);
-    });
-
-    it('converts a list to an array', () => {
-      // Arrange
-      const expected = [1, 2];
-      doublyLinkedList.fromArray(expected);
-
-      // Act
-      const received = doublyLinkedList.toArray();
-
-      // Assert
-      expect(received).toEqual(expected);
-    });
-  });
-
   describe('prepend', () => {
     it('prepends a new node to the beginning of the empty list', () => {
       // Arrange
@@ -424,6 +313,7 @@ describe('DoublyLinkedList', () => {
       const received = () => doublyLinkedList.insertAt(-1, 1);
 
       // Assert
+      expect(received).toThrow(RangeError);
       expect(received).toThrow(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );
@@ -434,6 +324,7 @@ describe('DoublyLinkedList', () => {
       const received = () => doublyLinkedList.insertAt(10, 1);
 
       // Assert
+      expect(received).toThrow(RangeError);
       expect(received).toThrow(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );
@@ -592,123 +483,4 @@ describe('DoublyLinkedList', () => {
       expect(doublyLinkedList.size).toBe(1);
     });
   });
-
-  describe('indexOf', () => {
-    it('returns -1 for an empty list', () => {
-      // Act and Assert
-      expect(doublyLinkedList.indexOf(42)).toBe(-1);
-    });
-
-    beforeEach(() => {
-      // Arrange
-      doublyLinkedList.fromArray([1, 2, 3, 3, 4]);
-    });
-
-    it('returns -1 for a value not present in the list', () => {
-      // Act and Assert
-      expect(doublyLinkedList.indexOf(42)).toBe(-1);
-    });
-
-    it('returns the correct index for a value present in the list', () => {
-      // Act and Assert
-      expect(doublyLinkedList.indexOf(2)).toBe(1);
-    });
-
-    it('returns the index of the first occurrence of the value', () => {
-      // Act and Assert
-      expect(doublyLinkedList.indexOf(3)).toBe(2);
-    });
-
-    it('returns the correct index for the head value', () => {
-      // Act and Assert
-      expect(doublyLinkedList.indexOf(1)).toBe(0);
-    });
-
-    it('returns the correct index for the tail value', () => {
-      // Act and Assert
-      expect(doublyLinkedList.indexOf(4)).toBe(4);
-    });
-
-    it('handles custom objects and comparison correctly', () => {
-      type Item = {
-        key: string;
-      };
-      // Arrange
-      const list = new DoublyLinkedList<Item>().fromArray([
-        { key: 'value1' },
-        { key: 'value2' },
-      ]);
-
-      // Act and Assert
-      expect(list.indexOf({ key: 'value1' })).toBe(0);
-    });
-  });
-
-  describe('find', () => {
-    it('returns null for a not-found node', () => {
-      // Act and Assert
-      expect(doublyLinkedList.find(1)).toBeNull();
-      expect(doublyLinkedList.find((value) => value === 100)).toBeNull();
-    });
-
-    it('finds a node by value', () => {
-      // Arrange
-      doublyLinkedList.fromArray([1, 2]);
-
-      // Act
-      const foundedNode = doublyLinkedList.find(2);
-
-      // Assert
-      expect(foundedNode?.data).toBe(2);
-    });
-
-    it('finds a node by predicate', () => {
-      // Arrange
-      doublyLinkedList.fromArray([1, 2, 3]);
-
-      // Act
-      const foundedNode = doublyLinkedList.find((value) => value > 2);
-
-      // Assert
-      expect(foundedNode?.data).toBe(3);
-    });
-
-    it('prioritizes predicate over value', () => {
-      // Arrange
-      doublyLinkedList.fromArray([1, 2]);
-
-      // Act
-      const foundedNode = doublyLinkedList.find((value) => value > 1);
-
-      // Assert
-      expect(foundedNode?.data).toBe(2);
-    });
-
-    it('returns the first node if multiple nodes match the predicate', () => {
-      // Arrange
-      doublyLinkedList.fromArray([1, 2, 3, 4]);
-
-      // Act
-      const foundedNode = doublyLinkedList.find((value) => value > 1);
-
-      // Assert
-      expect(foundedNode?.data).toBe(2);
-    });
-  });
-
-  describe('clear', () => {
-    it('removes all nodes from the linked list', () => {
-      // Arrange
-      doublyLinkedList.fromArray([1, 2, 3]);
-
-      // Act
-      doublyLinkedList.clear();
-
-      // Assert
-      expect(doublyLinkedList.head).toBeNull();
-      expect(doublyLinkedList.tail).toBeNull();
-      expect(doublyLinkedList.size).toBe(0);
-      expect(doublyLinkedList.isEmpty).toBeTruthy();
-    });
-  });
 });

src/data-structures/doubly-linked-list/index.spec.ts

@@ -27,7 +27,7 @@ export class DoublyLinkedList<T = any> extends BaseLinkedList<T, Node<T>> {
     return this;
   }
 
-  prepend(value: T): this {
+  prepend(value: T) {
     const newNode = new Node(value);
 
     if (this._head === null) {
@@ -112,7 +112,7 @@ export class DoublyLinkedList<T = any> extends BaseLinkedList<T, Node<T>> {
     const isInvalidIndex = index < 0 || index > this._size;
 
     if (isInvalidIndex) {
-      throw new Error(
+      throw new RangeError(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );
     }

src/data-structures/doubly-linked-list/index.ts

@@ -7,8 +7,6 @@ describe('DoublyLinkedListNode', () => {
     const doublyList = new DoublyLinkedListNode<number>(1);
 
     // Assert
-    expect(doublyList.data).toBe(1);
-    expect(doublyList.next).toBeNull();
     expect(doublyList.prev).toBeNull();
   });
 
@@ -23,8 +21,6 @@ describe('DoublyLinkedListNode', () => {
     const list = new DoublyLinkedListNode<typeof expectedValue>(expectedValue);
 
     // Assert
-    expect(list.data).toEqual(expectedValue);
-    expect(list.next).toBeNull();
     expect(list.prev).toBeNull();
   });
 

src/data-structures/doubly-linked-list/node/index.spec.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
 import { HashMap } from './index';
 
 describe('HashMap', () => {
@@ -245,46 +245,48 @@ describe('HashMap', () => {
   });
 
   describe('forEach', () => {
+    let callbackSpy: Mock<any, any>;
+
+    // Arrange
+    beforeEach(() => {
+      callbackSpy = vi.fn();
+    });
+
     it('iterates over each the key-value pairs', () => {
       // Arrange
       hashMap.set('one', 1);
       hashMap.set('two', 2);
       hashMap.set('three', 3);
 
-      const callbackFn = vi.fn();
-
       // Act
-      hashMap.forEach(callbackFn);
+      hashMap.forEach(callbackSpy);
 
       // Assert
-      expect(callbackFn).toHaveBeenCalledTimes(3);
+      expect(callbackSpy).toHaveBeenCalledTimes(3);
     });
 
     it('uses the provided thisArg as the context if provided', () => {
       // Arrange
       hashMap.set('one', 1);
 
       const thisArg = { customContext: true };
-      const callbackFn = vi.fn();
 
       // Act
-      hashMap.forEach(callbackFn, thisArg);
+      hashMap.forEach(callbackSpy, thisArg);
 
       // Assert
-      expect(callbackFn.mock.calls[0][2]).toBe(thisArg);
+      expect(callbackSpy.mock.calls[0][2]).toBe(thisArg);
     });
 
     it('uses the HashMap as the context if thisArg is not provided', () => {
       // Arrange
       hashMap.set('one', 1);
 
-      const callbackFn = vi.fn();
-
       // Act
-      hashMap.forEach(callbackFn);
+      hashMap.forEach(callbackSpy);
 
       // Assert
-      expect(callbackFn.mock.calls[0][2]).toBe(hashMap);
+      expect(callbackSpy.mock.calls[0][2]).toBe(hashMap);
     });
   });
 

src/data-structures/hash-map/index.spec.ts

@@ -46,7 +46,7 @@ export class HashMap<K = any, V = any> {
     return 'HashMap';
   }
 
-  #hashCode(key: K): number {
+  #hashCode(key: K) {
     const hashString = String(key);
 
     // The choice of 31 is a common practice in hash functions due to its properties.
@@ -66,7 +66,7 @@ export class HashMap<K = any, V = any> {
     return hash;
   }
 
-  #resizeIfNeeded(): void {
+  #resizeIfNeeded() {
     const RESIZE_THRESHOLD = 0.7;
     const loadFactor = this.#size / this.#buckets.length;
     if (loadFactor < RESIZE_THRESHOLD) return;
@@ -88,13 +88,13 @@ export class HashMap<K = any, V = any> {
     this.#capacity = newCapacity;
   }
 
-  #findBucketByKey(key: K): LinkedList<KeyValuePair<K, V>> | undefined {
+  #findBucketByKey(key: K) {
     const index = this.#hashCode(key);
 
-    return this.#buckets[index];
+    return this.#buckets[index] as LinkedList<KeyValuePair<K, V>> | undefined;
   }
 
-  set(key: K, value: V): this {
+  set(key: K, value: V) {
     this.#resizeIfNeeded();
 
     const hash = this.#hashCode(key);
@@ -159,7 +159,7 @@ export class HashMap<K = any, V = any> {
     return Boolean(node);
   }
 
-  delete(key: K): boolean {
+  delete(key: K) {
     const hash = this.#hashCode(key);
     const bucket = this.#buckets[hash];
 

src/data-structures/hash-map/index.ts

@@ -379,6 +379,7 @@ describe('LinkedList', () => {
       const received = () => linkedList.insertAt(-1, 1);
 
       // Assert
+      expect(received).toThrow(RangeError);
       expect(received).toThrow(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );
@@ -389,6 +390,7 @@ describe('LinkedList', () => {
       const received = () => linkedList.insertAt(10, 1);
 
       // Assert
+      expect(received).toThrow(RangeError);
       expect(received).toThrow(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );

src/data-structures/linked-list/index.spec.ts

@@ -2,7 +2,7 @@ import { BaseLinkedList, type Predicate } from '@/shared/base-linked-list';
 import { BaseLinkedListNode as Node } from '@/shared/base-linked-list/node';
 
 export class LinkedList<T = any> extends BaseLinkedList<T, Node<T>> {
-  append(value: T): this {
+  append(value: T) {
     const newNode = new Node(value);
 
     if (this._head === null) {
@@ -26,7 +26,7 @@ export class LinkedList<T = any> extends BaseLinkedList<T, Node<T>> {
     return this;
   }
 
-  prepend(value: T): this {
+  prepend(value: T) {
     const newNode = new Node(value);
 
     if (this._head === null) {
@@ -108,7 +108,7 @@ export class LinkedList<T = any> extends BaseLinkedList<T, Node<T>> {
     const isInvalidIndex = index < 0 || index > this._size;
 
     if (isInvalidIndex) {
-      throw new Error(
+      throw new RangeError(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );
     }

src/data-structures/linked-list/index.ts

@@ -37,7 +37,7 @@ export class LRUCache<Key extends string | number | symbol = any, Value = any> {
     return newNode;
   }
 
-  #deleteByReference(node: Node): void {
+  #deleteByReference(node: Node) {
     if (this.#head === this.#tail) {
       this.#head = null;
       this.#tail = null;
@@ -65,7 +65,7 @@ export class LRUCache<Key extends string | number | symbol = any, Value = any> {
     return node.data.value;
   }
 
-  put(key: Key, value: Value): void {
+  put(key: Key, value: Value) {
     if (Object.hasOwn(this.#nodeMap, key)) {
       const node = this.#nodeMap[key];
       this.#deleteByReference(node!);

src/data-structures/lru-cache/index.ts

@@ -17,7 +17,7 @@ export class LRUCacheOnMap<Key = any, Value = any> {
     return value;
   }
 
-  put(key: Key, value: Value): void {
+  put(key: Key, value: Value) {
     if (this.#cache.has(key)) {
       this.#cache.delete(key);
     }

src/data-structures/lru-cache/lru-cache-on-map/index.ts

@@ -0,0 +1,261 @@
+import isFunction from 'lodash.isfunction';
+import { ValuesType } from 'utility-types';
+
+const STATE = {
+  PENDING: 'pending',
+  FULFILLED: 'fulfilled',
+  REJECTED: 'rejected',
+} as const;
+
+type State = ValuesType<typeof STATE>;
+
+type Value<T> = T | PromiseLike<T>;
+
+type Callback = () => void;
+
+interface PromiseFulfilledResult<T> {
+  status: typeof STATE.FULFILLED;
+  value: T;
+}
+
+interface PromiseRejectedResult {
+  status: typeof STATE.REJECTED;
+  reason: any;
+}
+
+type PromiseSettledResult<T> =
+  | PromiseFulfilledResult<T>
+  | PromiseRejectedResult;
+
+export class CustomPromise<T = any> {
+  #state: State = STATE.PENDING;
+
+  #value?: Value<T>;
+
+  #onfulfilledCallbacks: Callback[] = [];
+
+  #onrejectedCallbacks: Callback[] = [];
+
+  static resolve(): CustomPromise<void>;
+  static resolve<T>(value: T): CustomPromise<Awaited<T>>;
+  static resolve<T>(value: T | PromiseLike<T>): CustomPromise<Awaited<T>>;
+  static resolve<T>(value?: T | PromiseLike<T>) {
+    if (isCustomPromise(value)) {
+      return value;
+    }
+
+    return new CustomPromise<Awaited<T>>((resolve) =>
+      resolve(value as Awaited<T>),
+    );
+  }
+
+  static reject<T = never>(reason?: any) {
+    if (isCustomPromise(reason)) {
+      return reason as T;
+    }
+
+    return new CustomPromise<T>((_, reject) => reject(reason));
+  }
+
+  static all<T>(values: Iterable<T | PromiseLike<T>>) {
+    assertIterable(values);
+
+    return new CustomPromise<Awaited<T>[]>((resolve, reject) => {
+      const promises = Array.from(values);
+
+      promises
+        .reduce<CustomPromise<Awaited<T>[]>>(
+          (accumulator, promise) =>
+            accumulator.then((results) =>
+              CustomPromise.resolve(promise).then((value) =>
+                results.concat(value),
+              ),
+            ),
+          CustomPromise.resolve([]),
+        )
+        .then(
+          (results) => {
+            resolve(results);
+          },
+          (error) => {
+            reject(error);
+          },
+        );
+    });
+  }
+
+  static race<T>(values: Iterable<T | PromiseLike<T>> = []) {
+    assertIterable(values);
+
+    return new CustomPromise<Awaited<T>>((resolve, reject) => {
+      for (const value of values) {
+        CustomPromise.resolve(value).then(resolve, reject);
+      }
+    });
+  }
+
+  static any<T extends readonly unknown[] | []>(
+    values: T,
+  ): CustomPromise<Awaited<T[number]>>;
+  static any<T>(
+    values: Iterable<T | PromiseLike<T>>,
+  ): CustomPromise<Awaited<T>>;
+  static any<T>(values: Iterable<T | PromiseLike<T>>) {
+    assertIterable(values);
+
+    const promises = Array.from(values);
+    let errors: Error[] = [];
+
+    return new CustomPromise<Awaited<T>>((resolve, reject) => {
+      for (const promise of promises) {
+        CustomPromise.resolve(promise).then(resolve, (error: Error) => {
+          errors.push(error);
+          if (errors.length === promises.length) {
+            reject(new AggregateError('All promises were rejected'));
+          }
+        });
+      }
+    });
+  }
+
+  static allSettled<T extends readonly unknown[] | []>(
+    values: T,
+  ): CustomPromise<{
+    -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>;
+  }>;
+  static allSettled<T>(
+    values: Iterable<T | PromiseLike<T>>,
+  ): CustomPromise<PromiseSettledResult<Awaited<T>>[]>;
+  static allSettled<T>(values: Iterable<T | PromiseLike<T>> = []) {
+    assertIterable(values);
+
+    return CustomPromise.all<PromiseSettledResult<Awaited<T>>>(
+      Array.from(values).map((promise) =>
+        CustomPromise.resolve(promise).then(
+          (value) => ({
+            status: STATE.FULFILLED,
+            value,
+          }),
+          (error) => ({
+            status: STATE.REJECTED,
+            reason: error,
+          }),
+        ),
+      ),
+    );
+  }
+
+  constructor(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: any) => void,
+    ) => void,
+  ) {
+    try {
+      executor(this.#resolve.bind(this), this.#reject.bind(this));
+    } catch (error) {
+      this.#reject(error);
+    }
+  }
+
+  #resolve(value: Value<T>) {
+    if (this.#state === STATE.PENDING) {
+      this.#state = STATE.FULFILLED;
+      this.#value = value;
+
+      this.#onfulfilledCallbacks.forEach((callback) => {
+        queueMicrotask(() => callback());
+      });
+
+      this.#onfulfilledCallbacks = [];
+    }
+  }
+
+  #reject(reason?: any) {
+    if (this.#state === STATE.PENDING) {
+      this.#state = STATE.REJECTED;
+      this.#value = reason;
+
+      this.#onrejectedCallbacks.forEach((callback) => {
+        queueMicrotask(() => callback());
+      });
+
+      this.#onrejectedCallbacks = [];
+    }
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+  ) {
+    return new CustomPromise<TResult1 | TResult2>((resolve, reject) => {
+      type Handler = typeof onfulfilled | typeof onrejected;
+
+      const executeHandler = (handler: Handler) => {
+        try {
+          if (isFunction(handler)) {
+            const result = handler(this.#value as T);
+
+            if (isCustomPromise(result)) {
+              result.then(resolve, reject);
+            } else {
+              resolve(result);
+            }
+          } else {
+            reject(this.#value);
+          }
+        } catch (error) {
+          reject(error);
+        }
+      };
+
+      const handlers = {
+        [STATE.PENDING]: () => {
+          this.#onfulfilledCallbacks.push(() => executeHandler(onfulfilled));
+          this.#onrejectedCallbacks.push(() => executeHandler(onrejected));
+        },
+        [STATE.FULFILLED]: () => executeHandler(onfulfilled),
+        [STATE.REJECTED]: () => executeHandler(onrejected),
+      };
+
+      handlers[this.#state]();
+    });
+  }
+
+  catch<TResult = never>(
+    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,
+  ) {
+    return this.then(null, onrejected);
+  }
+
+  finally(onfinally?: (() => void) | undefined | null) {
+    return this.then(
+      (value) => {
+        if (isFunction(onfinally)) {
+          onfinally();
+        }
+
+        return value;
+      },
+      (reason) => {
+        if (isFunction(onfinally)) {
+          onfinally();
+        }
+
+        return reason;
+      },
+    );
+  }
+}
+
+function isCustomPromise(value: any): value is CustomPromise {
+  return value instanceof CustomPromise;
+}
+
+const assertIterable = (value: any) => {
+  if (!value[Symbol.iterator]) {
+    throw new TypeError(
+      `${typeof value} is not iterable (cannot read property Symbol(Symbol.iterator))`,
+    );
+  }
+};

src/data-structures/promise/index.ts

@@ -33,7 +33,7 @@ export class BinaryTreeNode<T = any> {
     return this.leftHeight - this.rightHeight;
   }
 
-  setValue(value: T): this {
+  setValue(value: T) {
     this.value = value;
 
     return this;

src/data-structures/promise/promise.spec.ts

@@ -1,3 +1,4 @@
+import isFunction from 'lodash.isfunction';
 import { Comparator, CompareFunction } from '../comparator';
 import { BaseLinkedListNode, type Callback } from './node';
 
@@ -114,7 +115,3 @@ export abstract class BaseLinkedList<
   abstract deleteHead(): Node | null;
   abstract deleteTail(): Node | null;
 }
-
-function isFunction(a: unknown): a is Predicate {
-  return typeof a === 'function';
-}

src/data-structures/tree/binary-tree-node.ts

@@ -1,55 +1,33 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { BaseLinkedListNode } from './index';
 
-class BaseLinkedListNodeTest<T> extends BaseLinkedListNode<T> {}
-
 describe('BaseLinkedListNode', () => {
-  it('creates list node with value', () => {
-    // Act
-    const node = new BaseLinkedListNodeTest<number>(1);
+  let node: BaseLinkedListNode<number>;
 
-    // Assert
-    expect(node.data).toEqual(1);
-    expect(node.next).toBeNull();
+  beforeEach(() => {
+    node = new BaseLinkedListNode<number>(1);
   });
 
-  it('creates list node with object as a value', () => {
-    // Arrange
-    const nodeValueMock = {
-      value: 1,
-      key: 'test',
-    };
-
-    // Act
-    const node = new BaseLinkedListNodeTest<typeof nodeValueMock>(
-      nodeValueMock,
-    );
-
+  it('creates initial state correctly', () => {
     // Assert
-    expect(node.data.value).toEqual(1);
-    expect(node.data.key).toEqual('test');
+    expect(node).toBeDefined();
+    expect(node.data).toEqual(1);
     expect(node.next).toBeNull();
   });
 
   it('links nodes together', () => {
-    // Arrange
-    const node2 = new BaseLinkedListNodeTest<number>(1);
-
     // Act
-    const node1 = new BaseLinkedListNodeTest<number>(2, node2);
+    const node0 = new BaseLinkedListNode<number>(0, node);
 
     // Assert
-    expect(node1.next).toBeDefined();
-    expect(node2.next).toBeNull();
-    expect(node1.data).toEqual(2);
-    expect(node1.next?.data).toEqual(1);
+    expect(node0.next).toBeDefined();
+    expect(node.next).toBeNull();
+    expect(node0.data).toEqual(0);
+    expect(node0.next?.data).toEqual(1);
   });
 
   describe('toString', () => {
     it('converts node to string', () => {
-      // Arrange
-      const node = new BaseLinkedListNodeTest<number>(1);
-
       // Act and Assert
       expect(node.toString()).toEqual('1');
     });
@@ -61,7 +39,7 @@ describe('BaseLinkedListNode', () => {
         key: 'test',
       };
 
-      const list = new BaseLinkedListNodeTest<typeof nodeValue>(nodeValue);
+      const list = new BaseLinkedListNode<typeof nodeValue>(nodeValue);
       const toStringCallback = (x: typeof nodeValue) =>
         `value: ${x.value}, key: ${x.key}`;
 

src/shared/base-linked-list/index.ts

@@ -10,7 +10,7 @@ export class BaseLinkedListNode<T = any> {
     this.next = next;
   }
 
-  toString(callback?: Callback<T>): string {
+  toString(callback?: Callback<T>) {
     return callback ? callback(this.data) : `${this.data}`;
   }
 }

src/shared/base-linked-list/node/index.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test as it } from 'vitest';
-import { Comparator } from './comparator';
-import type { CompareFunction } from './comparator';
+import { Comparator } from '.';
+import type { CompareFunction } from '.';
 
 describe('Comparator', () => {
   it('compares values using default comparison function', () => {

src/shared/base-linked-list/node/index.ts

@@ -1 +1,45 @@
-export * from './comparator';
+import isEqual from 'lodash.isequal';
+
+export type CompareFunction<T> = (a: T, b: T) => -1 | 0 | 1;
+
+export class Comparator<T = unknown> {
+  #compare: CompareFunction<T>;
+
+  #isEqual = isEqual;
+
+  static defaultCompareFunction<T = unknown>(a: T, b: T) {
+    if (a === b) return 0;
+
+    return a < b ? -1 : 1;
+  }
+
+  constructor(compareFunction?: CompareFunction<T>) {
+    this.#compare = compareFunction ?? Comparator.defaultCompareFunction;
+  }
+
+  equal(a: unknown, b: unknown) {
+    return this.#isEqual(a, b);
+  }
+
+  lessThan(a: T, b: T) {
+    return this.#compare(a, b) < 0;
+  }
+
+  greaterThan(a: T, b: T) {
+    return this.#compare(a, b) > 0;
+  }
+
+  lessThanOrEqual(a: T, b: T) {
+    return this.lessThan(a, b) || this.equal(a, b);
+  }
+
+  greaterThanOrEqual(a: T, b: T) {
+    return this.greaterThan(a, b) || this.equal(a, b);
+  }
+
+  reverse() {
+    const compareOriginal = this.#compare;
+
+    this.#compare = (a, b) => compareOriginal(b, a);
+  }
+}

src/shared/comparator/comparator.ts

@@ -17,7 +17,7 @@
     "forceConsistentCasingInFileNames": true,
     "allowJs": true,
     "types": [
-      "bun-types", // add Bun global
-    ],
-  },
+      "bun-types" // add Bun global
+    ]
+  }
 }

src/shared/comparator/comparator.spec.ts src/shared/comparator/index.spec.ts

@@ -1,5 +1,7 @@
-import { defineConfig } from 'vitest/config';
+/// <reference types="vitest" />
+
 import tsconfigPaths from 'vite-tsconfig-paths';
+import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   plugins: [tsconfigPaths()],