refactor(promise): rewrite promise (#175)

Author: mg901

.eslintrc.cjs

@@ -1,6 +1,8 @@
 module.exports = {
   env: {
     es2023: true,
+    node: true,
+    browser: true,
   },
   extends: [
     'airbnb-base',

src/data-structures/promise/index.ts

@@ -1,7 +1,5 @@
 // Promises/A+ spec
 // https://github.com/promises-aplus/promises-spec
-
-import isFunction from 'lodash.isfunction';
 import { ValueOf } from 'type-fest';
 
 /**
@@ -48,21 +46,19 @@ interface IMyPromise<T> {
   readonly [Symbol.toStringTag]: string;
 }
 
-const STATE = {
+const STATES = {
   PENDING: 'pending',
   FULFILLED: 'fulfilled',
   REJECTED: 'rejected',
 } as const;
 
-type Callback = () => void;
-
 interface PromiseFulfilledResult<T> {
-  status: typeof STATE.FULFILLED;
+  status: typeof STATES.FULFILLED;
   value: T;
 }
 
 interface PromiseRejectedResult {
-  status: typeof STATE.REJECTED;
+  status: typeof STATES.REJECTED;
   reason: any;
 }
 
@@ -71,16 +67,17 @@ type PromiseSettledResult<T> =
   | PromiseRejectedResult;
 
 export class MyPromise<T = any> implements IMyPromise<T> {
-  #state: ValueOf<typeof STATE> = STATE.PENDING;
+  #state: ValueOf<typeof STATES> = STATES.PENDING;
 
-  #value?: T | PromiseLike<T>;
+  #value: T | PromiseLike<T> | undefined = undefined;
 
-  #reason: any;
+  #reason: any = undefined;
 
-  #onfulfilledCallbacks: Callback[] = [];
+  #fulfilledCallbacksQueue: (() => void)[] = [];
 
-  #onrejectedCallbacks: Callback[] = [];
+  #rejectedCallbacksQueue: (() => void)[] = [];
 
+  // --- Resolve --------------------
   static resolve(): MyPromise<void>;
   static resolve<T>(value: T): MyPromise<Awaited<T>>;
   static resolve<T>(value: T | PromiseLike<T>): MyPromise<Awaited<T>>;
@@ -92,11 +89,13 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     return new MyPromise<Awaited<T>>((resolve) => resolve(value as Awaited<T>));
   }
 
+  // --- Reject --------------------
   static reject<T = never>(reason?: any) {
     return new MyPromise<T>((_, reject) => reject(reason));
   }
 
-  static all<T>(values: Iterable<T | PromiseLike<T>>) {
+  // --- All --------------------
+  static all<T>(values: Iterable<T | PromiseLike<T>> = []) {
     return new MyPromise<Awaited<T>[]>((resolve, reject) => {
       handleNonIterable(values);
 
@@ -127,6 +126,7 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     });
   }
 
+  // --- Race --------------------
   static race<T>(values: Iterable<T | PromiseLike<T>> = []) {
     return new MyPromise<Awaited<T>>((resolve, reject) => {
       handleNonIterable(values);
@@ -137,11 +137,12 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     });
   }
 
+  // --- Any --------------------
   static any<T extends readonly unknown[] | []>(
     values: T,
   ): MyPromise<Awaited<T[number]>>;
   static any<T>(values: Iterable<T | PromiseLike<T>>): MyPromise<Awaited<T>>;
-  static any<T>(values: Iterable<T | PromiseLike<T>>) {
+  static any<T>(values: Iterable<T | PromiseLike<T>> = []) {
     return new MyPromise<Awaited<T>>((resolve, reject) => {
       handleNonIterable(values);
 
@@ -173,6 +174,7 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     });
   }
 
+  // --- All Settled --------------------
   static allSettled<T extends readonly unknown[] | []>(
     values: T,
   ): MyPromise<{
@@ -185,11 +187,11 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     const items = Array.from(values).map((item) =>
       MyPromise.resolve(item).then(
         (value) => ({
-          status: STATE.FULFILLED,
+          status: STATES.FULFILLED,
           value,
         }),
         (reason) => ({
-          status: STATE.REJECTED,
+          status: STATES.REJECTED,
           reason,
         }),
       ),
@@ -198,6 +200,7 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     return MyPromise.all<PromiseSettledResult<Awaited<T>>>(items);
   }
 
+  // --- With Resolvers --------------------
   static withResolvers<T>() {
     let resolve!: (value: T | PromiseLike<T>) => void;
     let reject!: (reason?: any) => void;
@@ -214,114 +217,135 @@ export class MyPromise<T = any> implements IMyPromise<T> {
     };
   }
 
+  // --- Constructor --------------------
   constructor(
     executor: (
       resolve: (value: T | PromiseLike<T>) => void,
       reject: (reason?: any) => void,
     ) => void,
   ) {
+    // Error Handling -----
     if (new.target === undefined) {
       throw new TypeError(
         `${this.constructor.name} constructor cannot be invoked without 'new'`,
       );
     }
 
-    if (typeof executor !== 'function') {
+    if (!isFunction(executor)) {
       throw new TypeError(
-        `${this.constructor.name} resolver ${typeof executor} is not a function`,
+        `${this.constructor.name} resolver ${type(executor)} is not a function`,
       );
     }
 
-    try {
-      executor(this.#resolve.bind(this), this.#reject.bind(this));
-    } catch (error) {
-      this.#reject(error);
-    }
-  }
+    // Resolve -----
+    const internalResolve = (value: T | PromiseLike<T>) => {
+      if (this.#state !== STATES.PENDING) return;
 
-  #resolve(value: T | PromiseLike<T>) {
-    if (this.#state !== STATE.PENDING) return;
+      this.#state = STATES.FULFILLED;
+      this.#value = value;
 
-    this.#state = STATE.FULFILLED;
-    this.#value = value;
+      this.#fulfilledCallbacksQueue.forEach((callback) => {
+        callback();
+      });
 
-    executeCallbacks(this.#onfulfilledCallbacks);
-    this.#onfulfilledCallbacks = [];
-  }
+      this.#fulfilledCallbacksQueue = [];
+    };
 
-  #reject(reason?: any) {
-    if (this.#state !== STATE.PENDING) return;
+    // Reject -----
+    const internalReject = (reason: any) => {
+      if (this.#state !== STATES.PENDING) return;
 
-    this.#state = STATE.REJECTED;
-    this.#reason = reason;
+      this.#state = STATES.REJECTED;
+      this.#reason = reason;
 
-    executeCallbacks(this.#onrejectedCallbacks);
-    this.#onfulfilledCallbacks = [];
+      this.#rejectedCallbacksQueue.forEach((callback) => {
+        callback();
+      });
+
+      this.#fulfilledCallbacksQueue = [];
+    };
+
+    // Constructor execution -----
+    try {
+      executor(internalResolve, internalReject);
+    } catch (error) {
+      queueMicrotask(() => {
+        internalReject(error);
+      });
+    }
   }
 
+  // --- Then --------------------
   then<TResult1 = T, TResult2 = never>(
     onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
   ) {
     return new MyPromise((resolve, reject) => {
-      const handleFulfilled = executeHandler(onfulfilled, resolve);
-      const handleRejected = executeHandler(onrejected, reject);
+      if (this.#state === STATES.PENDING) {
+        this.#fulfilledCallbacksQueue.push(() => {
+          handleFulfilled(this.#value as T);
+        });
+
+        this.#rejectedCallbacksQueue.push(() => {
+          handleRejected(this.#reason);
+        });
+      } else if (this.#state === STATES.FULFILLED) {
+        if (isThenable(this.#value)) {
+          this.#value.then(handleFulfilled, handleFulfilled);
+        } else {
+          handleFulfilled(this.#value as T);
+        }
+      } else {
+        handleRejected(this.#reason);
+      }
 
-      const strategy = {
-        [STATE.FULFILLED]: () => {
+      function handleFulfilled(value: T) {
+        if (isFunction(onfulfilled)) {
           queueMicrotask(() => {
-            if (isThenable(this.#value)) {
-              this.#value.then(handleFulfilled);
-            } else {
-              handleFulfilled(this.#value);
-            }
+            executeCallback(onfulfilled, value);
           });
-        },
-        [STATE.REJECTED]: () => {
+        } else {
+          resolve(value);
+        }
+      }
+
+      function handleRejected(reason: any) {
+        if (isFunction(onrejected)) {
           queueMicrotask(() => {
-            handleRejected(this.#reason);
+            executeCallback(onrejected, reason);
           });
-        },
-        [STATE.PENDING]: () => {
-          this.#onfulfilledCallbacks.push(() => handleFulfilled(this.#value));
-          this.#onrejectedCallbacks.push(() => handleRejected(this.#reason));
-        },
-      };
-
-      strategy[this.#state]();
-
-      function executeHandler(
-        handler: typeof onfulfilled | typeof onrejected,
-        resolver: (value: any) => void,
+        } else {
+          reject(reason);
+        }
+      }
+
+      function executeCallback(
+        callback: typeof onfulfilled | typeof onrejected,
+        data: any,
       ) {
-        return (value: any) => {
-          try {
-            if (!isFunction(handler)) {
-              resolver(value);
-
-              return;
-            }
-
-            const result = handler(value);
-            if (isThenable(result)) {
-              result.then(resolve, reject);
-            } else {
-              resolve(result);
-            }
-          } catch (error) {
-            reject(error);
+        try {
+          const result = callback && callback(data);
+
+          if (isThenable(result)) {
+            result.then(resolve, reject);
+          } else {
+            resolve(result);
           }
-        };
+        } catch (error) {
+          reject(error);
+        }
       }
     });
   }
 
+  // --- Catch --------------------
   catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,
   ) {
     return this.then(null, onrejected);
   }
 
+  // --- Finally --------------------
   finally(onfinally?: (() => void) | undefined | null) {
     return this.then(
       (value) => {
@@ -346,13 +370,13 @@ export class MyPromise<T = any> implements IMyPromise<T> {
   }
 }
 
+// --- Utils --------------------
 function handleNonIterable(it: any): void {
   if (it[Symbol.iterator]) return;
 
-  let type = typeof it;
-  let prefix = `${type}`;
+  let prefix = `${type(it)}`;
 
-  if (type === 'number' || type === 'boolean') {
+  if (type(it) === 'number' || type(it) === 'boolean') {
     prefix += ` ${it}`;
   }
 
@@ -361,14 +385,18 @@ function handleNonIterable(it: any): void {
   );
 }
 
-function isThenable<T>(it: any): it is PromiseLike<T> {
-  return !!(it && isFunction(it.then));
+function isThenable(it: any): it is PromiseLike<unknown> {
+  return Boolean(isObject(it) && isFunction(it.then));
 }
 
-function executeCallbacks(queue: Callback[]) {
-  for (const callback of queue) {
-    queueMicrotask(() => {
-      callback();
-    });
-  }
+function isObject(it: unknown) {
+  return type(it) === 'object' ? it !== null : isFunction(it);
+}
+
+function isFunction(it: unknown): it is (...args: unknown[]) => unknown {
+  return type(it) === 'function';
+}
+
+function type(it: unknown) {
+  return typeof it;
 }

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

@@ -1,7 +1,7 @@
 {
   "extends": "./tsconfig.custom.json",
   "compilerOptions": {
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "DOM"],
     "module": "esnext",
     "target": "esnext",
     "moduleResolution": "bundler",