Create deferredPromise & waitPromise

src/index.ts

@@ -10,6 +10,9 @@ 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 { 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,56 @@
+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<void>()
+
+    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<void>()
+
+    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)
+  })
+
+})