fix(CancellablePromise): allSettled return type

lib/CancellablePromise.test.ts

@@ -15,4 +15,36 @@ describe('all', function () {
         expect(promise1.cancel).toHaveBeenCalled();
         expect(promise2.cancel).toHaveBeenCalled();
     });
+    test('should reject with an error when the `all` method is used with some rejected promises', async () => {
+        expect.assertions(1);
+
+        const promises = [
+            new CancellablePromise(Promise.resolve('some value')),
+            new CancellablePromise(Promise.reject('first reason')),
+            new CancellablePromise(Promise.reject('second reason')),
+        ];
+
+        try {
+            await CancellablePromise.all(promises);
+        } catch (error) {
+            expect(error).toBe('first reason');
+        }
+    });
+    test('should resolve with some settled result when the `allSettled` method is used with some rejected promises', async () => {
+        expect.assertions(1);
+
+        const promises = [
+            new CancellablePromise(Promise.resolve('some value')),
+            new CancellablePromise(Promise.reject('some reason')),
+        ];
+
+        try {
+            const result = await CancellablePromise.allSettled(promises);
+
+            expect(result).toStrictEqual([
+                {status: 'fulfilled', value: 'some value'},
+                {status: 'rejected', reason: 'some reason'},
+            ]);
+        } catch (error) {}
+    });
 });

lib/CancellablePromise.ts

@@ -25,7 +25,7 @@ export class CancellablePromise<T = unknown> implements Promise<T> {
 
         return new CancellablePromise(
             Promise.allSettled(values) as unknown as Promise<{
-                -readonly [P in keyof Values]: Awaited<Values[P]>;
+                -readonly [P in keyof Values]: PromiseSettledResult<Awaited<Values[P]>>;
             }>,
             cancel,
         );