deferredPromise & waitPromise

README.md

@@ -23,6 +23,7 @@ modulo(5, 2); // 1
 - [dom](src/dom)
 - [envs](src/envs)
 - [math](src/math)
+- [promise](src/promise)
 - [social](src/social)
 - [string](src/string)
 

src/index.ts

@@ -10,6 +10,10 @@ export { clamp } from "./math/clamp"
 export { modulo } from "./math/modulo"
 export { normalizeValue } from "./math/normalizeValue"
 export { originalValueFromNormalized } from "./math/normalizeValue"
+// promise
+export { deferredPromise } from "./promise/deferredPromise"
+export type { TDeferredPromise } from "./promise/deferredPromise"
+export { waitPromise } from "./promise/waitPromise"
 // socials
 export * from "./social/shareUrls"
 // strings

src/promise/deferredPromise.ts

@@ -0,0 +1,38 @@
+/**
+ * Create a deferred promise who can be resolved or rejected from anywhere.
+ * Mainly stolen from https://github.com/willybrauner/deferred-promise
+ * @credit Willy Brauner https://github.com/willybrauner
+ * @name deferredPromise
+ * @return TDeferredPromise
+ *  ex:
+ *
+ *      const deferred = deferredPromise();
+ *
+ *      deferred.promise.then(() => {
+ *        // deferredPromise is resolved!
+ *      });
+ *
+ *      // when needed, resolve this promise
+ *      deferred.resolve();
+ *
+ *      // or reject it
+ *      deferred.reject();
+ *
+ */
+
+export type TDeferredPromise<T = any> = {
+  promise: Promise<T>
+  resolve: (resolve?: T) => void
+  reject: (error?: Error | any) => void
+}
+
+export function deferredPromise<T = any>(): TDeferredPromise<T> {
+  const deferred: TDeferredPromise<T> | any = {}
+
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve
+    deferred.reject = reject
+  })
+
+  return deferred
+}

src/promise/waitPromise.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a promise that resolves after a delay
+ * @param {number} delay
+ *
+ * ex:
+ *    await waitPromise(1000)
+ *
+ */
+export function waitPromise(delay: number = 1000): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delay))
+}

tests/promise/deferredPromise.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest"
+import { deferredPromise, waitPromise } from "../../src"
+
+/**
+ * @credit Willy Brauner https://github.com/willybrauner
+ * Mainly stolen from https://github.com/willybrauner/deferred-promise/blob/main/test/index.test.ts
+ */
+describe("deferredPromise", () => {
+  it("should resolve the deferred promise", async () => {
+    let resolve = false
+    let reject = false
+    const deferred = deferredPromise()
+
+    deferred.promise
+      .then(() => {
+        resolve = true
+      })
+      .catch(() => {
+        reject = true
+      })
+
+    expect(resolve).toBe(false)
+    expect(reject).toBe(false)
+
+    deferred.resolve()
+    await waitPromise(0)
+
+    expect(resolve).toBe(true)
+    expect(reject).toBe(false)
+  })
+
+  it("should reject the deferred promise", async () => {
+    let resolve = false
+    let reject = false
+    const deferred = deferredPromise()
+
+    deferred.promise
+      .then(() => {
+        resolve = true
+      })
+      .catch(() => {
+        reject = true
+      })
+
+    expect(resolve).toBe(false)
+    expect(reject).toBe(false)
+
+    deferred.reject()
+    await waitPromise(0)
+
+    expect(resolve).toBe(false)
+    expect(reject).toBe(true)
+  })
+})

tests/promise/waitPromise.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest"
+import { waitPromise } from "../../src"
+
+describe("waitPromise", () => {
+  it("should be resolve after delay", async () => {
+    const test = async (delay: number): Promise<any> => {
+      const start = performance.now()
+      await waitPromise(delay)
+      const now = performance.now() - start
+      expect(now).toBeGreaterThanOrEqual(delay - 10)
+    }
+    return Promise.all([test(100), test(200), test(300)])
+  })
+})