Add types for ReadonlyArray methods

Author: slowcheetah

packages/core-js-types/src/base/proposals/array-filtering.d.ts

@@ -11,6 +11,17 @@ interface Array<T> { // @type-options no-redefine
   filterReject(callbackFn: (value: T, index: number, target: T[]) => boolean, thisArg?: any): T[];
 }
 
+interface ReadonlyArray<T> { // @type-options no-export
+  /**
+   * Removes the items that return true
+   * @param callbackFn A function that accepts up to three arguments. The filterReject method calls the
+   * callbackFn function one time for each element in the array.
+   * @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.
+   */
+  filterReject(callbackFn: (value: T, index: number, target: T[]) => boolean, thisArg?: any): T[];
+}
+
 interface Int8Array { // @type-options no-export
   /**
    * Removes the items that return true

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

@@ -29,6 +29,31 @@ interface Array<T> { // @type-options no-redefine
   findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number;
 }
 
+interface ReadonlyArray<T> { // @type-options no-export
+  /**
+   * Returns the value of the last element in the array where predicate is true, and undefined
+   * otherwise.
+   * @param predicate findLast 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, findLast
+   * immediately returns that element value. Otherwise, findLast returns undefined.
+   * @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.
+   */
+  findLast<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S | undefined;
+  findLast(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | 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: T, index: number, array: T[]) => unknown, thisArg?: any): number;
+}
+
 interface Int8Array { // @type-options no-export
   /**
    * Returns the value of the last element in the array where predicate is true, and undefined

packages/core-js-types/src/base/proposals/array-flat-map.d.ts

@@ -25,3 +25,23 @@ interface Array<T> { // @type-options no-redefine
    */
   flat<A, D extends number = 1>(this: A, depth?: D): CoreJS.CoreJSFlatArray<A, D>[];
 }
+
+interface ReadonlyArray<T> { // @type-options no-export
+  /**
+   * Calls a defined callback function on each element of an array. Then, flattens the result into
+   * a new array.
+   * This is identical to a map followed by flat with depth 1.
+   * @param callback A function that accepts up to three arguments. The flatMap method calls the
+   * callback function one time for each element in the array.
+   * @param thisArg An object to which this keyword can refer in the callback function. If
+   * thisArg is omitted, undefined is used as this value.
+   */
+  flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
+
+  /**
+   * Returns a new array with all sub-array elements concatenated into it recursively up to the
+   * specified depth.
+   * @param depth The maximum recursion depth
+   */
+  flat<A, D extends number = 1>(this: A, depth?: D): CoreJS.CoreJSFlatArray<A, D>[];
+}

packages/core-js-types/src/base/proposals/array-includes.d.ts

@@ -13,6 +13,15 @@ interface Array<T> { // @type-options no-redefine
   includes(searchElement: T, fromIndex?: number): boolean;
 }
 
+interface ReadonlyArray<T> { // @type-options no-export
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(searchElement: T, fromIndex?: number): boolean;
+}
+
 interface Int8Array { // @type-options no-export
   /**
    * Determines whether an array includes a certain element, returning true or false as appropriate.

packages/core-js-types/src/base/proposals/array-unique.d.ts

@@ -10,6 +10,16 @@ interface Array<T> { // @type-options no-redefine
   uniqueBy(resolver?: keyof T | ((value: T) => any)): Array<T>;
 }
 
+interface ReadonlyArray<T> { // @type-options no-export
+  /**
+   * Returns a new array with unique items, determined by the resolver function or property key
+   * @param resolver A function that resolves the value to check uniqueness against,
+   * or a property key to compare the value from each item
+   * @returns A new `Array` with unique items
+   */
+  uniqueBy(resolver?: keyof T | ((value: T) => any)): Array<T>;
+}
+
 interface Int8Array { // @type-options no-export
   /**
    * Returns a new array with unique items, determined by the resolver function or property key

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

@@ -49,6 +49,51 @@ interface Array<T> { // @type-options no-redefine
   with(index: number, value: T): T[];
 }
 
+interface ReadonlyArray<T> { // @type-options no-export
+  /**
+   * @returns A copy of an array with its elements reversed.
+   */
+  toReversed(): T[];
+
+  /**
+   * Returns a copy of an array with its elements sorted.
+   * @param compareFn Function used to determine the order of the elements. It is expected to return
+   * 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, UTF-16 code unit order.
+   * ```ts
+   * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
+   * ```
+   */
+  toSorted(compareFn?: (a: T, b: T) => number): T[];
+
+  /**
+   * Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.
+   * @param start The zero-based location in the array from which to start removing elements.
+   * @param deleteCount The number of elements to remove.
+   * @param items Elements to insert into the copied array in place of the deleted elements.
+   * @returns The copied array.
+   */
+  toSpliced(start: number, deleteCount: number, ...items: T[]): T[];
+  /**
+   * Copies an array and removes elements while returning the remaining elements.
+   * @param start The zero-based location in the array from which to start removing elements.
+   * @param deleteCount The number of elements to remove.
+   * @returns A copy of the original array with the remaining elements.
+   */
+  toSpliced(start: number, deleteCount?: number): T[];
+
+  /**
+   * Copies an array, then overwrites the value at the provided index with the
+   * given value. If the index is negative, then it replaces from the end
+   * of the array.
+   * @param index The index of the value to overwrite. If the index is
+   * negative, then it replaces from the end of the array.
+   * @param value The value to write into the copied array.
+   * @returns The copied array with the updated value.
+   */
+  with(index: number, value: T): T[];
+}
+
 interface Int8Array { // @type-options no-export
   /**
    * @returns A copy of an array with its elements reversed.

packages/core-js-types/src/base/proposals/relative-indexing-method.d.ts

@@ -5,111 +5,111 @@
 // https://github.com/microsoft/TypeScript/blob/f450c1b80ce6dc7b04e81899db00534018932234/src/lib/es2022.string.d.ts
 // License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
 
-interface String { // @type-options no-export
+interface String {
   /**
    * Returns a new String consisting of the single UTF-16 code unit located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): string | undefined;
 }
 
-interface Array<T> { // @type-options no-export
+interface Array<T> {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): T | undefined;
 }
 
-interface ReadonlyArray<T> { // @type-options no-export
+interface ReadonlyArray<T> {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): T | undefined;
 }
 
-interface Int8Array { // @type-options no-export
+interface Int8Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Uint8Array { // @type-options no-export
+interface Uint8Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Uint8ClampedArray { // @type-options no-export
+interface Uint8ClampedArray {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Int16Array { // @type-options no-export
+interface Int16Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Uint16Array { // @type-options no-export
+interface Uint16Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Int32Array { // @type-options no-export
+interface Int32Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Uint32Array { // @type-options no-export
+interface Uint32Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Float32Array { // @type-options no-export
+interface Float32Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface Float64Array { // @type-options no-export
+interface Float64Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): number | undefined;
 }
 
-interface BigInt64Array { // @type-options no-export
+interface BigInt64Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
    */
   at(index: number): bigint | undefined;
 }
 
-interface BigUint64Array { // @type-options no-export
+interface BigUint64Array {
   /**
    * Returns the item located at the specified index.
    * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.