fix(delay): resolve value

__tests__/promise/async-pool.test.ts

@@ -0,0 +1,22 @@
+import { asyncPool, delay } from '../../src/promise';
+
+describe('promise/asyncPool', () => {
+  test('should be executed one by one', async function () {
+    const pool = asyncPool({ maxConcurrency: 1 });
+    const start = Date.now();
+    pool.executor(() => delay(100));
+    pool.executor(() => delay(100));
+    await pool.executor(() => delay(100));
+    expect(Date.now() - start).toBeGreaterThanOrEqual(300);
+  });
+
+  test('should be executed concurrently', async function () {
+    const pool = asyncPool({ maxConcurrency: 3 });
+    const start = Date.now();
+    pool.executor(() => delay(100));
+    pool.executor(() => delay(100));
+    await pool.executor(() => delay(100));
+    // If the timer is inaccurate, add 10 to the safety range
+    expect(Date.now() - start).toBeLessThanOrEqual(110);
+  });
+});

__tests__/promise.memoize.test.ts → __tests__/promise/memoize.test.ts

@@ -1,4 +1,4 @@
-import { memoize, delay } from '../src/promise';
+import { memoize, delay } from '../../src/promise';
 
 describe('promise/memoize', () => {
   test('cache 1000ms', async () => {

__tests__/promise.timeout.test.ts → __tests__/promise/timeout.test.ts

@@ -1,4 +1,4 @@
-import { timeout, delay } from '../src/promise';
+import { timeout, delay } from '../../src/promise';
 
 describe('promise/timeout', () => {
   test('resolves appropriate value when function finishes first', async () => {

src/promise/delay.ts

@@ -12,7 +12,7 @@ async function delay<T>(delayTimeMs: number, value: T): Promise<T>;
 async function delay<T>(delayTimeMs: number): Promise<void>;
 async function delay<T>(delayTime: number, value?: T): Promise<void | T> {
   if (delayTime <= 17) {
-    return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+    return new Promise((resolve) => requestAnimationFrame(() => resolve(value)));
   }
   return new Promise((resolve) => setTimeout(() => resolve(value), delayTime));
 }