[pull] master from DefinitelyTyped:master

types/d3-array/d3-array-tests.ts

@@ -2530,9 +2530,9 @@ const chars = ["x", "y"];
 const nums = [1, 2];
 
 crossed = d3Array.cross(chars, nums);
-crossed = d3Array.cross<string, number>(chars, nums);
+crossed = d3Array.cross<[string, number]>(chars, nums);
 
-let strArray: string[] = d3Array.cross<number, number, string>([2, 3], [5, 6], (a, b) => (a + b) + "px");
+let strArray: string[] = d3Array.cross<[number, number], string>([2, 3], [5, 6], (a, b) => (a + b) + "px");
 strArray = d3Array.cross([2, 3], [5, 6], (a, b) => {
     const aa: number = a;
     const bb: number = b;
@@ -2543,9 +2543,9 @@ const readonlyChars = chars as readonly string[];
 const readonlyNums = new Uint8Array(nums);
 
 crossed = d3Array.cross(readonlyChars, readonlyNums);
-crossed = d3Array.cross<string, number>(readonlyChars, readonlyNums);
+crossed = d3Array.cross<[string, number]>(readonlyChars, readonlyNums);
 
-strArray = d3Array.cross<number, number, string>(
+strArray = d3Array.cross<[number, number], string>(
     [2, 3] as readonly number[],
     new Uint8ClampedArray([5, 6]),
     (a, b) => (a + b) + "px",

types/d3-array/index.d.ts

@@ -648,25 +648,56 @@ export function count<TObject>(
 ): number;
 
 /**
- * Returns the Cartesian product of the two arrays a and b.
- * For each element i in the specified array a and each element j in the specified array b, in order,
- * it creates a two-element array for each pair.
+ * Computes the Cartesian product of any number of iterables.
  *
- * @param a First input array.
- * @param b Second input array.
- */
-export function cross<S, T>(a: Iterable<S>, b: Iterable<T>): Array<[S, T]>;
+ * When called **without** a reducer, the result is an array of tuples,
+ * where each tuple contains one element from each input iterable.
+ *
+ * @typeParam T - A tuple type describing the element type of each iterable argument.
+ *                For example, passing `[number[], string[]]` infers `T` as `[number, string]`.
+ *
+ * @param iterables - Two or more iterables to combine into a Cartesian product.
+ * @returns An array of tuples containing one value from each iterable.
+ *
+ * @example
+ * ```ts
+ * const nums = [1, 2];
+ * const chars = ['a', 'b'];
+ * const out = cross(nums, chars);
+ * //    ^? type: [number, string][]
+ * // Example value: [[1,'a'], [1,'b'], [2,'a'], [2,'b']]
+ * ```
+ */
+export function cross<T extends unknown[]>(
+    ...iterables: { [K in keyof T]: Iterable<T[K]> }
+): T[];
 
 /**
- * Returns the Cartesian product of the two arrays a and b.
- * For each element i in the specified array a and each element j in the specified array b, in order,
- * invokes the specified reducer function passing the element i and element j.
+ * Computes the Cartesian product of any number of iterables and then applies
+ * a reducer to each tuple, returning the reduced values.
  *
- * @param a First input array.
- * @param b Second input array.
- * @param reducer A reducer function taking as input an element from "a" and "b" and returning a reduced value.
- */
-export function cross<S, T, U>(a: Iterable<S>, b: Iterable<T>, reducer: (a: S, b: T) => U): U[];
+ * The final argument **must** be the reducer function; all prior arguments are iterables.
+ *
+ * @typeParam T - A tuple type describing the element type of each iterable argument.
+ * @typeParam U - The result type produced by the reducer.
+ *
+ * @param args - The iterables to combine, followed by a reducer function.
+ * @param args.reducer - A function invoked with one element from each iterable
+ *                       (spread as individual parameters) that returns a reduced value.
+ * @returns An array of reduced values returned by the reducer.
+ *
+ * @example
+ * ```ts
+ * const nums = [1, 2];
+ * const chars = ['a', 'b'];
+ * const out = cross(nums, chars, (n, c) => `${n}${c}`);
+ * //    ^? type: string[]
+ * // Example value: ['1a', '1b', '2a', '2b']
+ * ```
+ */
+export function cross<T extends unknown[], U>(
+    ...args: [...iterables: { [K in keyof T]: Iterable<T[K]> }, reducer: (...values: T) => U]
+): U[];
 
 /**
  * Merges the specified arrays into a single array.

types/d3-array/v2/d3-array-tests.ts

@@ -901,9 +901,9 @@ const chars = ["x", "y"];
 const nums = [1, 2];
 
 crossed = d3Array.cross(chars, nums);
-crossed = d3Array.cross<string, number>(chars, nums);
+crossed = d3Array.cross<[string, number]>(chars, nums);
 
-let strArray: string[] = d3Array.cross<number, number, string>([2, 3], [5, 6], (a, b) => (a + b) + "px");
+let strArray: string[] = d3Array.cross<[number, number], string>([2, 3], [5, 6], (a, b) => (a + b) + "px");
 strArray = d3Array.cross([2, 3], [5, 6], (a, b) => {
     const aa: number = a;
     const bb: number = b;
@@ -914,9 +914,9 @@ const readonlyChars = chars as readonly string[];
 const readonlyNums = new Uint8Array(nums);
 
 crossed = d3Array.cross(readonlyChars, readonlyNums);
-crossed = d3Array.cross<string, number>(readonlyChars, readonlyNums);
+crossed = d3Array.cross<[string, number]>(readonlyChars, readonlyNums);
 
-strArray = d3Array.cross<number, number, string>(
+strArray = d3Array.cross<[number, number], string>(
     [2, 3] as readonly number[],
     new Uint8ClampedArray([5, 6]),
     (a, b) => (a + b) + "px",

types/d3-array/v2/index.d.ts

@@ -702,25 +702,56 @@ export function count<TObject>(
 ): number;
 
 /**
- * Returns the Cartesian product of the two arrays a and b.
- * For each element i in the specified array a and each element j in the specified array b, in order,
- * it creates a two-element array for each pair.
+ * Computes the Cartesian product of any number of iterables.
  *
- * @param a First input array.
- * @param b Second input array.
- */
-export function cross<S, T>(a: Iterable<S>, b: Iterable<T>): Array<[S, T]>;
+ * When called **without** a reducer, the result is an array of tuples,
+ * where each tuple contains one element from each input iterable.
+ *
+ * @typeParam T - A tuple type describing the element type of each iterable argument.
+ *                For example, passing `[number[], string[]]` infers `T` as `[number, string]`.
+ *
+ * @param iterables - Two or more iterables to combine into a Cartesian product.
+ * @returns An array of tuples containing one value from each iterable.
+ *
+ * @example
+ * ```ts
+ * const nums = [1, 2];
+ * const chars = ['a', 'b'];
+ * const out = cross(nums, chars);
+ * //    ^? type: [number, string][]
+ * // Example value: [[1,'a'], [1,'b'], [2,'a'], [2,'b']]
+ * ```
+ */
+export function cross<T extends unknown[]>(
+    ...iterables: { [K in keyof T]: Iterable<T[K]> }
+): T[];
 
 /**
- * Returns the Cartesian product of the two arrays a and b.
- * For each element i in the specified array a and each element j in the specified array b, in order,
- * invokes the specified reducer function passing the element i and element j.
+ * Computes the Cartesian product of any number of iterables and then applies
+ * a reducer to each tuple, returning the reduced values.
  *
- * @param a First input array.
- * @param b Second input array.
- * @param reducer A reducer function taking as input an element from "a" and "b" and returning a reduced value.
- */
-export function cross<S, T, U>(a: Iterable<S>, b: Iterable<T>, reducer: (a: S, b: T) => U): U[];
+ * The final argument **must** be the reducer function; all prior arguments are iterables.
+ *
+ * @typeParam T - A tuple type describing the element type of each iterable argument.
+ * @typeParam U - The result type produced by the reducer.
+ *
+ * @param args - The iterables to combine, followed by a reducer function.
+ * @param args.reducer - A function invoked with one element from each iterable
+ *                       (spread as individual parameters) that returns a reduced value.
+ * @returns An array of reduced values returned by the reducer.
+ *
+ * @example
+ * ```ts
+ * const nums = [1, 2];
+ * const chars = ['a', 'b'];
+ * const out = cross(nums, chars, (n, c) => `${n}${c}`);
+ * //    ^? type: string[]
+ * // Example value: ['1a', '1b', '2a', '2b']
+ * ```
+ */
+export function cross<T extends unknown[], U>(
+    ...args: [...iterables: { [K in keyof T]: Iterable<T[K]> }, reducer: (...values: T) => U]
+): U[];
 
 /**
  * Merges the specified arrays into a single array.

types/emscripten/emscripten-tests.ts

@@ -108,6 +108,16 @@ function FSTest(): void {
     FS.symlink("file", "link");
 
     FS.writeFile("/foobar.txt", "Hello, world");
+
+    // Test writeFile with extended options
+    FS.writeFile("/test-with-mode.txt", "content", { mode: parseInt("0644", 8) });
+    FS.writeFile("/test-with-flags.txt", "content", { flags: "w+" });
+    FS.writeFile("/test-with-canown.txt", "content", { canOwn: true });
+    FS.writeFile("/test-with-all-opts.txt", "content", {
+        flags: "w",
+        mode: parseInt("0755", 8),
+        canOwn: false,
+    });
     FS.unlink("/foobar.txt");
 
     FS.writeFile("file", "foobar");

types/emscripten/index.d.ts

@@ -336,7 +336,11 @@ declare namespace FS {
     function readFile(path: string, opts: { encoding: "binary"; flags?: string | undefined }): Uint8Array;
     function readFile(path: string, opts: { encoding: "utf8"; flags?: string | undefined }): string;
     function readFile(path: string, opts?: { flags?: string | undefined }): Uint8Array;
-    function writeFile(path: string, data: string | ArrayBufferView, opts?: { flags?: string | undefined }): void;
+    function writeFile(
+        path: string,
+        data: string | ArrayBufferView,
+        opts?: { flags?: string | undefined; mode?: number | undefined; canOwn?: boolean | undefined },
+    ): void;
 
     //
     // module-level FS code

types/gimloader/.npmignore

@@ -0,0 +1,5 @@
+*
+!**/*.d.ts
+!**/*.d.cts
+!**/*.d.mts
+!**/*.d.*.ts

types/gimloader/gimloader-tests.ts

@@ -0,0 +1,33 @@
+GL; // $ExpectType typeof Api
+api; // $ExpectType Api
+
+new GL(); // $ExpectType Api
+
+api.React; // $ExpectType typeof React
+api.UI; // $ExpectType Readonly<ScopedUIApi>
+api.hotkeys; // $ExpectType Readonly<ScopedHotkeysApi>
+api.libs; // $ExpectType Readonly<LibsApi>
+api.net; // $ExpectType Readonly<ScopedNetApi>
+api.patcher; // $ExpectType Readonly<ScopedPatcherApi>
+api.plugins; // $ExpectType Readonly<PluginsApi>
+api.rewriter; // $ExpectType Readonly<ScopedRewriterApi>
+api.storage; // $ExpectType Readonly<ScopedStorageApi>
+
+GL.React; // $ExpectType typeof React
+GL.UI; // $ExpectType Readonly<UIApi>
+GL.hotkeys; // $ExpectType Readonly<HotkeysApi>
+GL.libs; // $ExpectType Readonly<LibsApi>
+GL.net; // $ExpectType Readonly<NetApi>
+GL.patcher; // $ExpectType Readonly<PatcherApi>
+GL.plugins; // $ExpectType Readonly<PluginsApi>
+GL.rewriter; // $ExpectType Readonly<RewriterApi>
+GL.storage; // $ExpectType Readonly<StorageApi>
+
+// @ts-expect-error
+GL.onStop;
+// @ts-expect-error
+GL.openSettingsMenu;
+// @ts-expect-error
+api.onStop();
+// @ts-expect-error
+api.openSettingsMenu();