Types refactoring

Author: slowcheetah

packages/core-js-types/src/base/proposals/array-find-from-last.d.ts

@@ -267,6 +267,15 @@ interface Float64Array { // @type-options: no-export
   findLast<S extends number>(predicate: (value: number, index: number, array: this) => value is S, thisArg?: any): S | undefined;
   findLast(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number | undefined;
 
+  /**
+   * Returns the index of the last element in the array where predicate is true, and -1
+   * otherwise.
+   * @param predicate - findLastIndex calls predicate once for each element of the array, in descending
+   * order, until it finds one where predicate returns true. If such an element is found,
+   * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
+   * @param thisArg - If provided, it will be used as this value for each invocation of
+   * predicate. If it is not provided, undefined is used instead.
+   */
   findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
 }
 

packages/core-js-types/src/base/proposals/async-iterator-helpers-custom.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="../core-js-types/async-iterator" />
+
+// Motivation: Custom type needed to keep generics strict
+
+// https://github.com/tc39/proposal-async-iterator-helpers
+
+declare namespace CoreJS {
+  export type AsyncIteratorFlatMap<T, U> = (callback: (value: T, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined> | AsyncIterator<U> | AsyncIterable<U>) => AsyncIteratorObject<U, undefined, unknown>;
+
+  export type AsyncIteratorMap<T, U> = (callback: (value: T, index: number) => U) => AsyncIteratorObject<U, undefined, unknown>;
+
+  export type AsyncIteratorReduce<T, U = T> = (callback: (accumulator: U, value: T, index: number) => U, initialValue?: U) => Promise<U>;
+}

packages/core-js-types/src/base/proposals/async-iterator-helpers.d.ts

@@ -26,28 +26,30 @@ interface AsyncIterator<T, TReturn = any, TNext = any> {
    * @param predicate - A function that tests each element of the iterator
    * @returns A promise that resolves to `true` if all elements pass the test, otherwise `false`
    */
-  every(predicate: (value: T, index: number) => boolean): Promise<boolean>;
+  every(predicate: (value: T, index: number) => unknown): Promise<boolean>;
 
   /**
    * Creates a new `AsyncIterator` that contains only the elements that pass the `predicate` function.
    * @param predicate - A function that tests each element of the iterator
    * @returns A new `AsyncIterator`
    */
+  filter<S extends T>(predicate: (value: T, index: number) => value is S): AsyncIteratorObject<S, undefined, unknown>;
   filter(predicate: (value: T, index: number) => boolean): AsyncIteratorObject<T>;
 
   /**
    * Finds the first element in the iterator that satisfies the `predicate` function.
    * @param predicate - A function that tests each element of the iterator
    * @returns A `Promise` that resolves to the found element, or `undefined` if no element satisfies the `predicate`
    */
-  find(predicate: (value: T, index: number) => boolean): Promise<T>;
+  find<S extends T>(predicate: (value: T, index: number) => value is S): Promise<S | undefined>;
+  find(predicate: (value: T, index: number) => boolean): Promise<T | undefined>;
 
   /**
    * Creates a new `AsyncIterator` by applying the `mapper` function to each element of the original iterator and flattening the result.
-   * @param mapper - A function that transforms each element of the iterator
+   * @param callback - A function that transforms each element of the iterator
    * @returns A new `AsyncIterator`
    */
-  flatMap(mapper: (value: T, index: number) => any): AsyncIteratorObject<any>;
+  flatMap<U>(callback: (value: T, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined> | AsyncIterator<U> | AsyncIterable<U>): AsyncIteratorObject<U, undefined, unknown>;
 
   /**
    * Executes a provided function once for each element in the iterator.
@@ -61,22 +63,23 @@ interface AsyncIterator<T, TReturn = any, TNext = any> {
    * @param mapper - A function that transforms each element of the iterator
    * @returns A new `AsyncIterator`
    */
-  map(mapper: (value: T, index: number) => any): AsyncIteratorObject<T>;
+  map<U>(mapper: (value: T, index: number) => U): AsyncIteratorObject<U, undefined, unknown>;
 
   /**
    * Reduces the elements of the iterator to a single value using the `reducer` function.
    * @param reducer - A function that combines two elements of the iterator
    * @param initialValue - An optional initial value to start the reduction
    * @returns A `Promise` that resolves to the reduced value
    */
-  reduce(reducer: (accumulator: any, value: T, index: number) => any, initialValue?: any): Promise<any>;
+  reduce<U>(reducer: (accumulator: U, value: T, index: number) => U, initialValue?: U): Promise<U>;
+  reduce(reducer: (accumulator: T, value: T, index: number) => T, initialValue?: T): Promise<T>;
 
   /**
    * Checks if any value in the iterator matches a given `predicate`
    * @param predicate - A function that tests each element of the iterator
    * @returns A `Promise` that resolves to `true` if any element passes the `predicate`, otherwise `false`
    */
-  some(predicate: (value: T, index: number) => boolean): Promise<boolean>;
+  some(predicate: (value: T, index: number) => unknown): Promise<boolean>;
 
   /**
    * Creates a new `AsyncIterator` that yields only the first `limit` elements from the original iterator.

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<any>>>(promises: D): Promise <{ [k in keyof D]: Awaited<D[k]> }>;
+  allKeyed<D extends Record<PropertyKey, Promise<any>>>(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<any>>>(promises: D): Promise <{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
+  allSettledKeyed<D extends Record<PropertyKey, Promise<any>>>(promises: D): Promise<{ [k in keyof D]: CoreJS.CoreJSPromiseSettledResult<Awaited<D[k]>> }>;
 }
 
 declare var Promise: PromiseConstructor;

packages/core-js-types/src/base/proposals/change-array-by-copy.d.ts

@@ -274,8 +274,8 @@ interface Uint32Array { // @type-options: no-export
    * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
    * value otherwise. If omitted, the elements are sorted in ascending order.
    * ```ts
-   * const myNums = Int32Array.from([11, 2, -22, 1]);
-   * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11]
+   * const myNums = Uint32Array.from([11, 2, -22, 1]);
+   * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [-22, 1, 2, 11]
    * ```
    */
   toSorted(compareFn?: (a: number, b: number) => number): Uint32Array;
@@ -303,7 +303,7 @@ interface Float32Array { // @type-options: no-export
    * value otherwise. If omitted, the elements are sorted in ascending order.
    * ```ts
    * const myNums = Float32Array.from([11.25, 2, -22.5, 1]);
-   * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5]
+   * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.25]
    * ```
    */
   toSorted(compareFn?: (a: number, b: number) => number): Float32Array;
@@ -331,7 +331,7 @@ interface Float64Array { // @type-options: no-export
    * value otherwise. If omitted, the elements are sorted in ascending order.
    * ```ts
    * const myNums = Float64Array.from([11.25, 2, -22.5, 1]);
-   * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5]
+   * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.25]
    * ```
    */
   toSorted(compareFn?: (a: number, b: number) => number): Float64Array;

packages/core-js-types/src/base/proposals/collection-of-from.d.ts

@@ -24,20 +24,19 @@ declare var Map: MapConstructor;
 
 interface SetConstructor {
   /**
-   * Creates a new `Set` instance from an iterable or array-like object of [key, value] pairs.
-   * Optionally, applies a mapping function to each pair.
-   * @param source - Iterable or array-like object of [key, value] pairs.
-   * @param mapFn - Function to call on every [key, value] pair before adding to the `Set`.
-   * @param thisArg - Value to use as this when executing mapFn.
-   * @returns A new `Set` instance.
+   * Creates a new `Set` instance from an iterable, optionally transforming elements with a mapping function.
+   * @param source - Iterable whose elements will be added to the new Set.
+   * @param mapFn - Optional mapping function. Transforms each element before adding to Set.
+   * @param thisArg - Value to use as `this` when executing `mapFn`.
+   * @returns A new `Set` instance
    */
   from<T, U = T>(source: Iterable<T>, mapFn?: (value: T, index: number) => U, thisArg?: any): Set<U>;
 
   /**
-   * Creates a new `Set` instance from a variable number of arguments,
-   * where each pair of arguments is interpreted as a key and a value.
-   * @param items - An even number of arguments representing key-value pairs.
-   * @returns A new `Set` instance.
+   * Creates a new `Set` instance from a variable number of arguments.
+   * Each argument becomes an element of the Set.
+   * @param items - Zero or more arguments to add as Set elements.
+   * @returns A new `Set` instance
    */
   of<T>(...items: T[]): Set<T>;
 }
@@ -59,7 +58,7 @@ interface WeakMapConstructor {
    * Creates a new `WeakMap` instance from a variable number of arguments,
    * where each pair of arguments is interpreted as a key and a value.
    * @param items - An even number of arguments representing key-value pairs.
-   * @returns A new `Weak` instance.
+   * @returns A new `WeakMap` instance.
    */
   of<K extends object, V>(...items: [K, V][]): WeakMap<K, V>;
 }
@@ -68,20 +67,19 @@ declare var WeakMap: WeakMapConstructor;
 
 interface WeakSetConstructor {
   /**
-   * Creates a new `WeakSet` instance from an iterable or array-like object of [key, value] pairs.
-   * Optionally, applies a mapping function to each pair.
-   * @param source - Iterable or array-like object of [key, value] pairs.
-   * @param mapFn - Function to call on every [key, value] pair before adding to the `WeakSet`.
-   * @param thisArg - Value to use as this when executing mapFn.
-   * @returns A new `WeakSet` instance.
+   * Creates a new `WeakSet` instance from an iterable of objects, optionally transforming with mapFn.
+   *
+   * @param source - Iterable of objects to add to WeakSet.
+   * @param mapFn - Optional mapping function transforming each object.
+   * @param thisArg - Value to use as `this` in `mapFn`.
+   * @returns New `WeakSet` instance.
    */
   from<T extends object, U extends object = T>(source: Iterable<T>, mapFn?: (value: T, index: number) => U, thisArg?: any): WeakSet<U>;
 
   /**
-   * Creates a new `WeakSet` instance from a variable number of arguments,
-   * where each pair of arguments is interpreted as a key and a value.
-   * @param items - An even number of arguments representing key-value pairs.
-   * @returns A new `WeakSet` instance.
+   * Creates a new `WeakSet` instance from object arguments.
+   * @param items - Zero or more objects to add as WeakSet elements.
+   * @returns New `WeakSet` instance.
    */
   of<T extends object>(...items: T[]): WeakSet<T>;
 }

packages/core-js-types/src/base/proposals/explicit-resource-management.d.ts

@@ -148,33 +148,7 @@ interface AsyncDisposableStack {
   defer(onDisposeAsync: () => PromiseLike<void> | void): void;
 
   /**
-   * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
-   * @example
-   * ```ts
-   * class C {
-   *   #res1: Disposable;
-   *   #res2: Disposable;
-   *   #disposables: DisposableStack;
-   *   constructor() {
-   *     // stack will be disposed when exiting constructor for any reason
-   *     using stack = new DisposableStack();
-   *
-   *     // get first resource
-   *     this.#res1 = stack.use(getResource1());
-   *
-   *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-   *     this.#res2 = stack.use(getResource2());
-   *
-   *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
-   *     // when constructor exits
-   *     this.#disposables = stack.move();
-   *   }
-   *
-   *   [Symbol.dispose]() {
-   *     this.#disposables.dispose();
-   *   }
-   * }
-   * ```
+   * Move all resources out of this stack and into a new `AsyncDisposableStack`, and marks this stack as disposed.
    */
   move(): AsyncDisposableStack;