feat: add recursiveResolve

src/__tests__/__snapshots__/index.test.ts.snap

@@ -164,6 +164,7 @@ exports[`test existence of exported functions 1`] = `
   "getRescaler",
   "isPowerOfTwo",
   "nextPowerOfTwo",
+  "recursiveResolve",
   "stringify",
 ]
 `;

src/utils/__tests__/recursiveResolve.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'vitest';
+
+import { recursiveResolve } from '../recursiveResolve';
+
+test('primitive', async () => {
+  expect(await recursiveResolve(1)).toBe(1);
+  expect(await recursiveResolve({})).toStrictEqual({});
+  expect(await recursiveResolve(true)).toBeTruthy();
+});
+
+test('simple object', async () => {
+  const object = {
+    a: {
+      b: {
+        c: Promise.resolve(1),
+      },
+    },
+  };
+
+  expect(await recursiveResolve(object)).toStrictEqual({
+    a: {
+      b: {
+        c: 1,
+      },
+    },
+  });
+});
+
+test('with array', async () => {
+  const object = {
+    a: {
+      b: {
+        c: [Promise.resolve(1), Promise.resolve(2)],
+      },
+    },
+  };
+
+  expect(await recursiveResolve(object)).toStrictEqual({
+    a: {
+      b: {
+        c: [1, 2],
+      },
+    },
+  });
+});

src/utils/index.ts

@@ -5,4 +5,5 @@ export * from './createStepArray';
 export * from './getRescaler';
 export * from './isPowerOfTwo';
 export * from './nextPowerOfTwo';
+export * from './recursiveResolve';
 export * from './stringify';

src/utils/recursiveResolve.ts

@@ -0,0 +1,26 @@
+/**
+ * wait recursively so that all promises are resolved
+ * need to go through all the nested objects and check if it is a promise
+ * if it is a promise, then await it
+ * @param object
+ * @returns
+ */
+export async function recursiveResolve(object: unknown) {
+  if (typeof object !== 'object') return object;
+  const promises: Array<Promise<unknown>> = [];
+  await appendPromises(object, promises);
+  await Promise.all(promises);
+  return object;
+}
+
+function appendPromises(object: any, promises: Array<Promise<unknown>>) {
+  if (typeof object !== 'object') return object;
+  for (const key in object) {
+    if (object[key] instanceof Promise) {
+      promises.push(object[key].then((value) => (object[key] = value)));
+    } else if (typeof object[key] === 'object') {
+      appendPromises(object[key], promises);
+    }
+  }
+  return object;
+}