Types stabilization for ts 5.5

Author: slowcheetah

packages/core-js-types/package.json

@@ -25,8 +25,16 @@
     "email": "zloirock@zloirock.ru",
     "url": "http://zloirock.ru"
   },
-  "types": "dist/core-js-types.latest.d.ts",
+  "types": "dist/core-js-types.56.d.ts",
   "files": [
-    "dist/core-js-types.latest.d.ts"
-  ]
+    "dist/core-js-types.56.d.ts"
+  ],
+  "typesVersions": {
+    ">=5.6": {
+      "*": ["dist/core-js-types.56.d.ts"]
+    },
+    ">=5.2": {
+      "*": ["dist/core-js-types.52.d.ts"]
+    }
+  }
 }

packages/core-js-types/src/52/common/efficient-script-yielding.d.ts

@@ -0,0 +1,5 @@
+type Immediate = number | object;
+
+declare function setImmediate(handler: (...args: any[]) => void, ...args: any[]): Immediate;
+
+declare function clearImmediate(immediate: Immediate): void;

packages/core-js-types/src/52/common/object-prototype-accessor-methods.d.ts

@@ -0,0 +1,9 @@
+interface Object {
+  __defineGetter__(prop: PropertyKey, getter: () => any): void;
+
+  __defineSetter__(prop: PropertyKey, setter: (val: any) => void): void;
+
+  __lookupGetter__(prop: PropertyKey): (() => any) | undefined;
+
+  __lookupSetter__(prop: PropertyKey): ((val: any) => void) | undefined;
+}

packages/core-js-types/src/52/common/url-parse.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  interface URLConstructor {
+    parse(url: string | URL, base?: string | URL): URL | null;
+  }
+}
+
+export {};

packages/core-js-types/src/52/core-js-types/core-js-types.d.ts

@@ -0,0 +1,49 @@
+// For ensuring compatibility with TypeScript standard types, this code is based on:
+// https://github.com/microsoft/TypeScript/blob/2a90a739c1c1e87e3c3d0c93e16f7e5baadf8035/src/lib/es2019.array.d.ts
+// https://github.com/microsoft/TypeScript/blob/6f4fb0145845db22791188c4d38e3a1a0edfd449/src/lib/es2018.asyncgenerator.d.ts
+// License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
+
+declare global {
+  interface IteratorObject<T, TReturn = any, TNext = any> extends Iterator<T, TReturn, TNext> {}
+
+  interface AsyncIteratorObject<T, TReturn = any, TNext = any> extends AsyncIterator<T> {
+    [Symbol.asyncIterator](): AsyncIteratorObject<T, TReturn, TNext>;
+  }
+
+  interface AsyncGenerator<T = unknown, TReturn = any, TNext = unknown> extends AsyncIteratorObject<T, TReturn, TNext> {
+    next(...[value]: [] | [undefined]): Promise<IteratorResult<T, TReturn>>;
+    return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw(e: any): Promise<IteratorResult<T, TReturn>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+  }
+
+  interface PromiseFulfilledResult<T> { status: "fulfilled"; value: T; }
+
+  interface PromiseRejectedResult { status: "rejected"; reason: any; }
+
+  interface AsyncIterable<T, TReturn = any, TNext = any> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+  }
+}
+
+export type CoreJSDecoratorMetadataObject = typeof globalThis extends { DecoratorMetadataObject: infer O } // from ts 5.2
+  ? O
+  : Record<PropertyKey, unknown> & object;
+
+export type CoreJSIteratorObject<T, TReturn = any, TNext = undefined> = IteratorObject<T, TReturn, TNext>;
+
+export type CoreJSFlatArray<Arr, Depth extends number> = typeof globalThis extends { FlatArray: infer O } // from ts 4.4
+  ? O
+  : {
+    done: Arr;
+    recur: Arr extends ReadonlyArray<infer InnerArr> ? CoreJSFlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
+      : Arr;
+  }[Depth extends -1 ? "done" : "recur"];
+
+export type CoreJSPromiseSettledResult<T> = typeof globalThis extends { PromiseSettledResult: infer O }  // from ts 3.8 and es2020
+  ? O
+  : PromiseFulfilledResult<T> | PromiseRejectedResult;
+
+export type CoreJSBuiltinIteratorReturn = ReturnType<any[][typeof Symbol.iterator]> extends Iterator<any, infer TReturn>
+  ? TReturn
+  : any;

packages/core-js-types/src/52/proposals/accessible-object-hasownproperty.d.ts

@@ -0,0 +1,9 @@
+// proposal stage: 4
+// https://github.com/tc39/proposal-accessible-object-hasownproperty
+
+// For ensuring compatibility with TypeScript standard types, this code is based on:
+// https://github.com/microsoft/TypeScript/blob/069de743dbd17b47cc2fc58e1d16da5410911284/src/lib/es2022.object.d.ts
+// License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
+interface ObjectConstructor {
+  hasOwn(o: object, v: PropertyKey): boolean;
+}

packages/core-js-types/src/52/proposals/array-buffer-base64.d.ts

@@ -0,0 +1,41 @@
+// proposal stage: 3
+// https://github.com/tc39/proposal-arraybuffer-base64
+
+// For ensuring compatibility with TypeScript standard types, this code is based on:
+// https://github.com/microsoft/TypeScript/blob/d3be7e171bf3149fe93c3ce5a85280f1eba3ef8d/src/lib/esnext.typedarrays.d.ts
+// License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
+
+type alphabet = 'base64' | 'base64url';
+
+type lastChunkHandling = 'loose' | 'strict' | 'stop-before-partial';
+
+type fromBase64Options = {
+  alphabet?: alphabet;
+  lastChunkHandling?: lastChunkHandling;
+}
+
+type toBase64Options = {
+  alphabet?: alphabet;
+  omitPadding?: boolean;
+}
+
+type processMetadata = {
+  read: number;
+  written: number;
+}
+
+interface Uint8ArrayConstructor {
+  fromBase64(str: string, opts?: fromBase64Options): Uint8Array;
+
+  fromHex(str: string): Uint8Array;
+}
+
+interface Uint8Array {
+  setFromBase64(str: string, opts?: fromBase64Options): processMetadata;
+
+  setFromHex(str: string): processMetadata;
+
+  toBase64(opts?: toBase64Options): string;
+
+  toHex(): string;
+}

packages/core-js-types/src/52/proposals/array-buffer-transfer.d.ts

@@ -0,0 +1,11 @@
+// proposal stage: 4
+// https://github.com/tc39/proposal-arraybuffer-transfer
+
+interface ArrayBuffer {
+  // todo hack for modern ts
+  // get detached(): boolean;
+
+  transfer(newByteLength?: number): ArrayBuffer;
+
+  transferToFixedLength(newByteLength?: number): ArrayBuffer;
+}

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

@@ -0,0 +1,50 @@
+// proposal stage: 1
+// https://github.com/tc39/proposal-array-filtering
+
+interface Array<T> {
+  filterReject(callbackFn: (value: T, index: number, target: T[]) => boolean, thisArg?: any): T[];
+}
+
+interface Int8Array {
+  filterReject(callbackFn: (value: number, index: number, target: Int8Array) => boolean, thisArg?: any): Int8Array;
+}
+
+interface Uint8Array {
+  filterReject(callbackFn: (value: number, index: number, target: Uint8Array) => boolean, thisArg?: any): Uint8Array;
+}
+
+interface Uint8ClampedArray {
+  filterReject(callbackFn: (value: number, index: number, target: Uint8ClampedArray) => boolean, thisArg?: any): Uint8ClampedArray;
+}
+
+interface Int16Array {
+  filterReject(callbackFn: (value: number, index: number, target: Int16Array) => boolean, thisArg?: any): Int16Array;
+}
+
+interface Uint16Array {
+  filterReject(callbackFn: (value: number, index: number, target: Uint16Array) => boolean, thisArg?: any): Uint16Array;
+}
+
+interface Int32Array {
+  filterReject(callbackFn: (value: number, index: number, target: Int32Array) => boolean, thisArg?: any): Int32Array;
+}
+
+interface Uint32Array {
+  filterReject(callbackFn: (value: number, index: number, target: Uint32Array) => boolean, thisArg?: any): Uint32Array;
+}
+
+interface Float32Array {
+  filterReject(callbackFn: (value: number, index: number, target: Float32Array) => boolean, thisArg?: any): Float32Array;
+}
+
+interface Float64Array {
+  filterReject(callbackFn: (value: number, index: number, target: Float64Array) => boolean, thisArg?: any): Float64Array;
+}
+
+interface BigInt64Array {
+  filterReject(callbackFn: (value: bigint, index: number, target: BigInt64Array) => boolean, thisArg?: any): BigInt64Array;
+}
+
+interface BigUint64Array {
+  filterReject(callbackFn: (value: bigint, index: number, target: BigUint64Array) => boolean, thisArg?: any): BigUint64Array;
+}

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

@@ -0,0 +1,102 @@
+// proposal stage: 4
+// https://github.com/tc39/proposal-array-find-from-last
+
+// For ensuring compatibility with TypeScript standard types, this code is based on:
+// https://github.com/microsoft/TypeScript/blob/069de743dbd17b47cc2fc58e1d16da5410911284/src/lib/es2023.array.d.ts
+// License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
+
+interface Array<T> {
+  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;
+
+  findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number;
+}
+
+interface Int8Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Uint8Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Uint8ClampedArray {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Int16Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Uint16Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Int32Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Uint32Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Float32Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface Float64Array {
+  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;
+
+  findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface BigInt64Array {
+  findLast<S extends bigint>(predicate: (value: bigint, index: number, array: this) => value is S, thisArg?: any): S | undefined;
+
+  findLast(predicate: (value: bigint, index: number, array: this) => unknown, thisArg?: any): bigint | undefined;
+
+  findLastIndex(predicate: (value: bigint, index: number, array: this) => unknown, thisArg?: any): number;
+}
+
+interface BigUint64Array {
+  findLast<S extends bigint>(predicate: (value: bigint, index: number, array: this) => value is S, thisArg?: any): S | undefined;
+
+  findLast(predicate: (value: bigint, index: number, array: this) => unknown, thisArg?: any): bigint | undefined;
+
+  findLastIndex(predicate: (value: bigint, index: number, array: this) => unknown, thisArg?: any): number;
+}