Promise types refactoring for pure version

Author: slowcheetah

packages/core-js-types/src/base/proposals/promise-all-settled.d.ts

@@ -13,13 +13,13 @@ interface PromiseConstructor {
    * @param values - An array of Promises.
    * @returns A new Promise.
    */
-  allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: CoreJS.CoreJSPromiseSettledResult<Awaited<T[P]>>; }>; // @type-options: prefix-return-type
+  allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: CoreJS.CoreJSPromiseSettledResult<Awaited<T[P]>>; }>;
 
   /**
    * Creates a Promise that is resolved with an array of results when all
    * of the provided Promises resolve or reject.
    * @param values - An array of Promises.
    * @returns A new Promise.
    */
-  allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<CoreJS.CoreJSPromiseSettledResult<Awaited<T>>[]>; // @type-options: prefix-return-type
+  allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<CoreJS.CoreJSPromiseSettledResult<Awaited<T>>[]>;
 }

packages/core-js-types/src/base/proposals/promise-any.d.ts

@@ -10,21 +10,21 @@ interface PromiseConstructor {
    * @param values - An array or iterable of Promises.
    * @returns A new Promise.
    */
-  any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>; // @type-options: prefix-return-type
+  any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
 
   /**
    * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
    * @param values - An array or iterable of Promises.
    * @returns A new Promise.
    */
-  any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>; // @type-options: prefix-return-type
+  any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
 }
 
-interface AggregateError extends Error { // @type-options: no-redefine
+interface AggregateError extends Error {
   errors: any[];
 }
 
-interface AggregateErrorConstructor { // @type-options: no-extends, no-redefine
+interface AggregateErrorConstructor {
   new (errors: Iterable<any>, message?: string): AggregateError;
   (errors: Iterable<any>, message?: string): AggregateError;
   readonly prototype: AggregateError;

packages/core-js-types/src/base/proposals/promise-finally.d.ts

@@ -11,5 +11,5 @@ interface Promise<T> {
    * @param onfinally - The callback to execute when the Promise is settled (fulfilled or rejected).
    * @returns A Promise for the completion of the callback.
    */
-  finally(onfinally?: (() => void) | undefined | null): Promise<T>; // @type-options: prefix-return-type
+  finally(onfinally?: (() => void) | undefined | null): Promise<T>;
 }

packages/core-js-types/src/base/proposals/promise-try.d.ts

@@ -18,6 +18,6 @@ interface PromiseConstructor {
    * - Already rejected, if the callback synchronously throws an error.
    * - Asynchronously fulfilled or rejected, if the callback returns a promise.
    */
-  try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>; // @type-options: prefix-return-type
+  try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>;
 }
 

packages/core-js-types/src/base/proposals/promise-with-resolvers.d.ts

@@ -4,8 +4,8 @@
 // https://github.com/microsoft/TypeScript/blob/af3a3779de6bc27619c85077e1b4d1de8feddd35/src/lib/es2024.promise.d.ts
 // License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
 
-interface PromiseWithResolvers<T> { // @type-options: no-extends, no-prefix
-  promise: Promise<T>; // @type-options: prefix-return-type
+interface PromiseWithResolvers<T> {
+  promise: Promise<T>;
 
   resolve: (value: T | PromiseLike<T>) => void;
 

packages/core-js-types/src/base/pure/core-js-types/aggregate-error.d.ts

@@ -0,0 +1,13 @@
+declare namespace CoreJS {
+  export interface CoreJSAggregateError extends Error {
+    errors: any[];
+  }
+
+  export interface CoreJSAggregateErrorConstructor {
+    new (errors: Iterable<any>, message?: string): CoreJSAggregateError;
+    (errors: Iterable<any>, message?: string): CoreJSAggregateError;
+    readonly prototype: CoreJSAggregateError;
+  }
+
+  var CoreJSAggregateError: CoreJSAggregateErrorConstructor;
+}

packages/core-js-types/src/base/pure/core-js-types/promise.d.ts

@@ -1,6 +1,21 @@
+/// <reference types="./promise-settled-result" />
+
+// https://github.com/tc39/proposal-await-dictionary
+
+// https://github.com/tc39/proposal-promise-allSettled
+
+// https://github.com/tc39/proposal-promise-any
+
+// https://github.com/tc39/proposal-promise-try
+
+// https://github.com/tc39/proposal-promise-with-resolvers
+
 // For ensuring compatibility with TypeScript standard types, this code is aligned with:
-// https://github.com/microsoft/TypeScript/blob/347254895823a36a1b1b1c80471422da54ad77de/src/lib/es2021.promise.d.ts#L16
-// https://github.com/microsoft/TypeScript/blob/347254895823a36a1b1b1c80471422da54ad77de/src/lib/es2025.promise.d.ts#L4
+// https://github.com/microsoft/TypeScript/blob/2a90a739c1c1e87e3c3d0c93e16f7e5baadf8035/src/lib/es2020.promise.d.ts
+// https://github.com/microsoft/TypeScript/blob/347254895823a36a1b1b1c80471422da54ad77de/src/lib/es2021.promise.d.ts
+// https://github.com/microsoft/TypeScript/blob/af3a3779de6bc27619c85077e1b4d1de8feddd35/src/lib/es2024.promise.d.ts
+// https://github.com/microsoft/TypeScript/blob/347254895823a36a1b1b1c80471422da54ad77de/src/lib/es2025.promise.d.ts
+// https://github.com/microsoft/TypeScript/blob/af3a3779de6bc27619c85077e1b4d1de8feddd35/src/lib/esnext.promise.d.ts
 // License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
 
 declare namespace CoreJS {
@@ -31,6 +46,51 @@ declare namespace CoreJS {
      */
     all<T extends readonly unknown[] | []>(values: T): CoreJSPromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
 
+    /**
+     * Takes an object of promises and returns a single Promise that resolves to an object
+     * with the same keys and fulfilled values, or rejects as soon as any of the input promises rejects.
+     * @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, unknown>>(promises: D): CoreJSPromise<{ [k in keyof D]: Awaited<D[k]> }>;
+
+    /**
+     * Takes an object whose values are promises and returns a single `Promise` that resolves
+     * to an object with the same keys, after all of the input promises have settled.
+     * @param promises - An object of promises
+     * @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, unknown>>(promises: D): CoreJSPromise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all
+     * of the provided Promises resolve or reject.
+     * @param values - An array of Promises.
+     * @returns A new Promise.
+     */
+    allSettled<T extends readonly unknown[] | []>(values: T): CoreJSPromise<{ -readonly [P in keyof T]: CoreJS.CoreJSPromiseSettledResult<Awaited<T[P]>>; }>;
+    /**
+     * Creates a Promise that is resolved with an array of results when all
+     * of the provided Promises resolve or reject.
+     * @param values - An array of Promises.
+     * @returns A new Promise.
+     */
+    allSettled<T>(values: Iterable<T | PromiseLike<T>>): CoreJSPromise<CoreJS.CoreJSPromiseSettledResult<Awaited<T>>[]>;
+
+    /**
+     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
+     * @param values - An array or iterable of Promises.
+     * @returns A new Promise.
+     */
+    any<T extends readonly unknown[] | []>(values: T): CoreJSPromise<Awaited<T[number]>>;
+    /**
+     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
+     * @param values - An array or iterable of Promises.
+     * @returns A new Promise.
+     */
+    any<T>(values: Iterable<T | PromiseLike<T>>): CoreJSPromise<Awaited<T>>;
+
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
@@ -58,21 +118,6 @@ declare namespace CoreJS {
      */
     resolve<T>(value: T | PromiseLike<T>): CoreJSPromise<Awaited<T>>;
 
-    // allSettled, any, try
-
-    /**
-     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
-     * @param values - An array or iterable of Promises.
-     * @returns A new Promise.
-     */
-    any<T extends readonly unknown[] | []>(values: T): CoreJSPromise<Awaited<T[number]>>;
-    /**
-     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
-     * @param values - An array or iterable of Promises.
-     * @returns A new Promise.
-     */
-    any<T>(values: Iterable<T | PromiseLike<T>>): CoreJSPromise<Awaited<T>>;
-
     /**
      * Takes a callback of any kind (returns or throws, synchronously or asynchronously) and wraps its result
      * in a Promise.
@@ -87,6 +132,16 @@ declare namespace CoreJS {
      * - Asynchronously fulfilled or rejected, if the callback returns a promise.
      */
     try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): CoreJSPromise<Awaited<T>>;
+
+    /**
+     * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
+     * @returns An object with the properties `promise`, `resolve`, and `reject`.
+     *
+     * ```ts
+     * const { promise, resolve, reject } = Promise.withResolvers<T>();
+     * ```
+     */
+    withResolvers<T>(): CoreJSPromiseWithResolvers<T>;
   }
 
   var CoreJSPromise: CoreJSPromiseConstructor;

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

@@ -1,29 +1,2 @@
-/// <reference types="../../core-js-types/promise-settled-result" />
-/// <reference types="../core-js-types/promise" />
-
-// Motivation: Using our own Promise type in return
-
-// https://github.com/tc39/proposal-await-dictionary
-
-declare namespace CoreJS {
-  export interface CoreJSPromiseConstructor extends PromiseConstructor {
-    /**
-     * Takes an object of promises and returns a single Promise that resolves to an object
-     * with the same keys and fulfilled values, or rejects as soon as any of the input promises rejects.
-     * @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, 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
-     * to an object with the same keys, after all of the input promises have settled.
-     * @param promises - An object of promises
-     * @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, unknown>>(promises: D): CoreJS.CoreJSPromise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
-  }
-
-  var CoreJSPromise: CoreJSPromiseConstructor;
-}
+// empty
+// Moved to ../core-js-types/promise.d.ts

packages/core-js-types/src/base/pure/proposals/promise-all-settled.d.ts

@@ -0,0 +1,2 @@
+// empty
+// Moved to ../core-js-types/promise.d.ts

packages/core-js-types/src/base/pure/proposals/promise-any.d.ts

@@ -0,0 +1,2 @@
+// empty
+// Moved to ../core-js-types/promise.d.ts