Add support for primitives in Promise.allKeyed & Promise.allSettledKeyed types & add tests

Author: slowcheetah

packages/core-js-types/src/base/proposals/await-dictionary.d.ts

@@ -9,7 +9,7 @@ interface PromiseConstructor {
    * @param promises - An object of promises
    * @returns A new `Promise` that resolves to an object of fulfilled values or rejects if any promise rejects.
    */
-  allKeyed<D extends Record<PropertyKey, Promise<unknown>>>(promises: D): Promise<{ [k in keyof D]: Awaited<D[k]> }>;
+  allKeyed<D extends Record<PropertyKey, unknown>>(promises: D): Promise<{ [k in keyof D]: Awaited<D[k]> }>;
 
   /**
    * Takes an object whose values are promises and returns a single `Promise` that resolves
@@ -18,7 +18,7 @@ interface PromiseConstructor {
    * @returns A new Promise that resolves to an object with the same keys as the input object,
    * where each key maps to the settlement result (`{ status, value }` or `{ status, reason }`) of the corresponding promise.
    */
-  allSettledKeyed<D extends Record<PropertyKey, Promise<unknown>>>(promises: D): Promise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
+  allSettledKeyed<D extends Record<PropertyKey, unknown>>(promises: D): Promise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
 }
 
 declare var Promise: PromiseConstructor;

packages/core-js-types/src/base/pure/proposals/await-dictionary.d.ts

@@ -13,7 +13,7 @@ declare namespace CoreJS {
      * @param promises - An object of promises
      * @returns A new `Promise` that resolves to an object of fulfilled values or rejects if any promise rejects.
      */
-    allKeyed<D extends Record<PropertyKey, Promise<unknown>>>(promises: D): CoreJS.CoreJSPromise<{ [k in keyof D]: Awaited<D[k]> }>;
+    allKeyed<D extends Record<PropertyKey, unknown>>(promises: D): CoreJS.CoreJSPromise<{ [k in keyof D]: Awaited<D[k]> }>;
 
     /**
      * Takes an object whose values are promises and returns a single `Promise` that resolves
@@ -22,7 +22,7 @@ declare namespace CoreJS {
      * @returns A new Promise that resolves to an object with the same keys as the input object,
      * where each key maps to the settlement result (`{ status, value }` or `{ status, reason }`) of the corresponding promise.
      */
-    allSettledKeyed<D extends Record<PropertyKey, Promise<unknown>>>(promises: D): CoreJS.CoreJSPromise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
+    allSettledKeyed<D extends Record<PropertyKey, unknown>>(promises: D): Promise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
   }
 
   var CoreJSPromise: CoreJSPromiseConstructor;

tests/type-definitions/global/proposals/await-dictionary.test.ts

@@ -23,6 +23,11 @@ const resNS2: Promise<{ a: number, b: string, c: boolean }> = $Promise.allKeyed(
 const resNS3: Promise<{ [sym]: CoreJSPromiseResult<number> }> = allSettledKeyed({
   [sym]: Promise.resolve(1),
 });
+Promise.allKeyed({
+  a: 1,
+  b: Promise.resolve('string'),
+  c: 3,
+});
 
 // @ts-expect-error
 allKeyed();
@@ -42,8 +47,6 @@ const res2: Promise<{ [sym]: number }> = Promise.allKeyed({
 // @ts-expect-error
 Promise.allKeyed();
 // @ts-expect-error
-Promise.allKeyed({ a: 1, b: Promise.resolve(2) });
-// @ts-expect-error
 Promise.allKeyed([Promise.resolve(1), Promise.resolve(2)]);
 
 const resASK: Promise<{ a: CoreJSPromiseResult<number>, b: CoreJSPromiseResult<string>, c: CoreJSPromiseResult<boolean> }> = Promise.allSettledKeyed({
@@ -56,9 +59,13 @@ const resASK2: Promise<{ [sym]: CoreJSPromiseResult<number> }> = Promise.allSett
   [sym]: Promise.resolve(1),
 });
 
+Promise.allSettledKeyed({
+  a: 1,
+  b: Promise.resolve('string'),
+  c: 3,
+});
+
 // @ts-expect-error
 Promise.allSettledKeyed();
 // @ts-expect-error
-Promise.allSettledKeyed({ a: 1, b: Promise.resolve(2) });
-// @ts-expect-error
 Promise.allSettledKeyed([Promise.resolve(1), Promise.resolve(2)]);

tests/type-definitions/pure/proposals/await-dictionary.test.ts

@@ -16,16 +16,34 @@ const res2 = promiseAllKeyed({
 });
 assertCoreJSPromiseLike<{ [sym]: number }>(res2);
 
+promiseAllKeyed({
+  a: 1,
+  b: promiseResolve('string'),
+  c: 3,
+});
+
 // @ts-expect-error
 promiseAllKeyed();
 // @ts-expect-error
-promiseAllKeyed({ a: 1, b: promiseResolve(2) });
-// @ts-expect-error
 promiseAllKeyed([promiseResolve(1), promiseResolve(2)]);
 
+promiseAllSettledKeyed({
+  a: Promise.resolve(1),
+  b: Promise.resolve('string'),
+  c: Promise.resolve(true),
+});
+
+promiseAllSettledKeyed({
+  [sym]: Promise.resolve(1),
+});
+
+promiseAllSettledKeyed({
+  a: 1,
+  b: Promise.resolve('string'),
+  c: 3,
+});
+
 // @ts-expect-error
 promiseAllSettledKeyed();
 // @ts-expect-error
-promiseAllSettledKeyed({ a: 1, b: promiseResolve(2) });
-// @ts-expect-error
 promiseAllSettledKeyed([promiseResolve(1), promiseResolve(2)]);

tests/unit-global/esnext.promise.all-keyed.js

@@ -6,6 +6,20 @@ QUnit.test('Promise.allKeyed', assert => {
   assert.true(Promise.allKeyed({}) instanceof Promise, 'returns a promise');
 });
 
+QUnit.test('Promise.allKeyed, resolved with primitives', assert => {
+  return Promise.allKeyed({
+    a: 1,
+    b: Promise.resolve(2),
+    c: 3,
+  }).then(it => {
+    assert.deepEqual(it, {
+      a: 1,
+      b: 2,
+      c: 3,
+    }, 'resolved with a correct value');
+  });
+});
+
 QUnit.test('Promise.allKeyed, resolved', assert => {
   return Promise.allKeyed({
     a: Promise.resolve(1),

tests/unit-global/esnext.promise.all-settled-keyed.js

@@ -20,6 +20,20 @@ QUnit.test('Promise.allSettledKeyed, resolved', assert => {
   });
 });
 
+QUnit.test('Promise.allSettledKeyed, resolved with primitives', assert => {
+  return Promise.allSettledKeyed({
+    a: 1,
+    b: Promise.resolve(2),
+    c: 3,
+  }).then(it => {
+    assert.deepEqual(it, {
+      a: { value: 1, status: 'fulfilled' },
+      b: { value: 2, status: 'fulfilled' },
+      c: { value: 3, status: 'fulfilled' },
+    }, 'resolved with a correct value');
+  });
+});
+
 QUnit.test('Promise.allSettledKeyed, resolved with rejection', assert => {
   return Promise.allSettledKeyed({
     a: Promise.resolve(1),

tests/unit-pure/esnext.promise.all-keyed.js

@@ -22,6 +22,20 @@ QUnit.test('Promise.allKeyed, resolved', assert => {
   });
 });
 
+QUnit.test('Promise.allKeyed, resolved with primitives', assert => {
+  return Promise.allKeyed({
+    a: 1,
+    b: Promise.resolve(2),
+    c: 3,
+  }).then(it => {
+    assert.deepEqual(it, {
+      a: 1,
+      b: 2,
+      c: 3,
+    }, 'resolved with a correct value');
+  });
+});
+
 QUnit.test('Promise.allKeyed, resolved with rejection', assert => {
   return Promise.allKeyed({
     a: Promise.resolve(1),

tests/unit-pure/esnext.promise.all-settled-keyed.js

@@ -22,6 +22,20 @@ QUnit.test('Promise.allSettledKeyed, resolved', assert => {
   });
 });
 
+QUnit.test('Promise.allSettledKeyed, resolved with primitives', assert => {
+  return Promise.allSettledKeyed({
+    a: 1,
+    b: Promise.resolve(2),
+    c: 3,
+  }).then(it => {
+    assert.deepEqual(it, {
+      a: { value: 1, status: 'fulfilled' },
+      b: { value: 2, status: 'fulfilled' },
+      c: { value: 3, status: 'fulfilled' },
+    }, 'resolved with a correct value');
+  });
+});
+
 QUnit.test('Promise.allSettledKeyed, resolved with rejection', assert => {
   return Promise.allSettledKeyed({
     a: Promise.resolve(1),