🤖 Merge PR DefinitelyTyped#74295 Type updates for v1.5.0 k6 release by @inancgumus

Co-authored-by: Ankur <akahank@gmail.com>

Author: inancgumus

types/k6/browser/index.d.ts

@@ -3231,6 +3231,29 @@ export interface Locator {
      */
     press(key: string, options?: KeyboardPressOptions): Promise<void>;
 
+    /**
+     * Focuses the element and then sends a `keydown`, `keypress`/`input`, and
+     * `keyup` event for each character in the text.
+     *
+     * This method is useful for simulating real user typing behavior when the page
+     * has special keyboard event handling, such as input validation or autocomplete.
+     * For simple text input without special keyboard handling, use {@link fill | fill()}
+     * instead as it's faster and more reliable.
+     *
+     * @example
+     * ```js
+     * // Type text instantly
+     * await locator.pressSequentially('Hello World');
+     *
+     * // Type text with delay between keypresses (like a real user)
+     * await locator.pressSequentially('Hello World', { delay: 100 });
+     * ```
+     *
+     * @param text Text to type into the focused element character by character.
+     * @param options Typing options.
+     */
+    pressSequentially(text: string, options?: KeyboardPressOptions): Promise<void>;
+
     /**
      * Type a text into the input field.
      * @param text Text to type into the input field.
@@ -5693,6 +5716,120 @@ export interface Page {
         },
     ): Promise<Request | null>;
 
+    /**
+     * Waits for the specified event to be emitted.
+     *
+     * This method blocks until the event is captured or the timeout is reached.
+     * Supported event types are `console`, `request`, or `response`.
+     *
+     * @example
+     * ```js
+     * // Wait for a console message containing 'hello'
+     * const msgPromise = page.waitForEvent('console', msg => msg.text().includes('hello'));
+     * await page.evaluate(() => console.log('hello world'));
+     * const msg = await msgPromise;
+     * ```
+     *
+     * @param event Event name to wait for: `'console'`.
+     * @param optionsOrPredicate Either a predicate function or an options object.
+     */
+    waitForEvent(
+        event: "console",
+        optionsOrPredicate?:
+            | ((msg: ConsoleMessage) => boolean)
+            | {
+                /**
+                 * Predicate function that returns `true` when the expected event is received.
+                 */
+                predicate?: (msg: ConsoleMessage) => boolean;
+                /**
+                 * Maximum time to wait in milliseconds. Defaults to `30` seconds.
+                 * The default value can be changed via the
+                 * browserContext.setDefaultTimeout(timeout) or
+                 * page.setDefaultTimeout(timeout) methods.
+                 *
+                 * Setting the value to `0` will disable the timeout.
+                 */
+                timeout?: number;
+            },
+    ): Promise<ConsoleMessage>;
+
+    /**
+     * Waits for the specified event to be emitted.
+     *
+     * This method blocks until the event is captured or the timeout is reached.
+     * It can wait for any page event such as `console`, `request`, or `response`.
+     *
+     * @example
+     * ```js
+     * // Wait for a request to a specific URL
+     * const reqPromise = page.waitForEvent('request', req => req.url().includes('/api'));
+     * await page.click('button');
+     * const req = await reqPromise;
+     * ```
+     *
+     * @param event Event name to wait for: `'request'`.
+     * @param optionsOrPredicate Either a predicate function or an options object.
+     */
+    waitForEvent(
+        event: "request",
+        optionsOrPredicate?:
+            | ((req: Request) => boolean)
+            | {
+                /**
+                 * Predicate function that returns `true` when the expected event is received.
+                 */
+                predicate?: (req: Request) => boolean;
+                /**
+                 * Maximum time to wait in milliseconds. Defaults to `30` seconds.
+                 * The default value can be changed via the
+                 * browserContext.setDefaultTimeout(timeout) or
+                 * page.setDefaultTimeout(timeout) methods.
+                 *
+                 * Setting the value to `0` will disable the timeout.
+                 */
+                timeout?: number;
+            },
+    ): Promise<Request>;
+
+    /**
+     * Waits for the specified event to be emitted.
+     *
+     * This method blocks until the event is captured or the timeout is reached.
+     * It can wait for any page event such as `console`, `request`, or `response`.
+     *
+     * @example
+     * ```js
+     * // Wait for a response from a specific URL
+     * const resPromise = page.waitForEvent('response', res => res.url().includes('/api'));
+     * await page.click('button');
+     * const res = await resPromise;
+     * ```
+     *
+     * @param event Event name to wait for: `'response'`.
+     * @param optionsOrPredicate Either a predicate function or an options object.
+     */
+    waitForEvent(
+        event: "response",
+        optionsOrPredicate?:
+            | ((res: Response) => boolean)
+            | {
+                /**
+                 * Predicate function that returns `true` when the expected event is received.
+                 */
+                predicate?: (res: Response) => boolean;
+                /**
+                 * Maximum time to wait in milliseconds. Defaults to `30` seconds.
+                 * The default value can be changed via the
+                 * browserContext.setDefaultTimeout(timeout) or
+                 * page.setDefaultTimeout(timeout) methods.
+                 *
+                 * Setting the value to `0` will disable the timeout.
+                 */
+                timeout?: number;
+            },
+    ): Promise<Response>;
+
     /**
      * **NOTE** Use web assertions that assert visibility or a locator-based
      * locator.waitFor([options]) instead.

types/k6/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@types/k6",
-    "version": "1.4.9999",
+    "version": "1.5.9999",
     "type": "module",
     "projects": [
         "https://grafana.com/docs/k6/latest/"

types/k6/test/browser.ts

@@ -1054,6 +1054,31 @@ async function test() {
     // $ExpectType Promise<Request | null>
     page.waitForRequest("https://example.com", { timeout: 10000 });
 
+    // @ts-expect-error
+    page.waitForEvent();
+    // $ExpectType Promise<ConsoleMessage>
+    page.waitForEvent("console");
+    // $ExpectType Promise<ConsoleMessage>
+    page.waitForEvent("console", (msg) => msg.text().includes("hello"));
+    // $ExpectType Promise<ConsoleMessage>
+    page.waitForEvent("console", { predicate: (msg) => msg.text().includes("hello") });
+    // $ExpectType Promise<ConsoleMessage>
+    page.waitForEvent("console", { timeout: 10000 });
+    // $ExpectType Promise<ConsoleMessage>
+    page.waitForEvent("console", { predicate: (msg) => msg.text().includes("hello"), timeout: 10000 });
+    // $ExpectType Promise<Request>
+    page.waitForEvent("request");
+    // $ExpectType Promise<Request>
+    page.waitForEvent("request", (req) => req.url().includes("/api"));
+    // $ExpectType Promise<Request>
+    page.waitForEvent("request", { predicate: (req) => req.url().includes("/api"), timeout: 10000 });
+    // $ExpectType Promise<Response>
+    page.waitForEvent("response");
+    // $ExpectType Promise<Response>
+    page.waitForEvent("response", (res) => res.url().includes("/api"));
+    // $ExpectType Promise<Response>
+    page.waitForEvent("response", { predicate: (res) => res.url().includes("/api"), timeout: 10000 });
+
     // @ts-expect-error
     page.waitForSelector();
     // $ExpectType Promise<ElementHandle>
@@ -1434,6 +1459,19 @@ async function test() {
     // $ExpectType Promise<void>
     locator.setChecked(true, { position: { x: 0, y: 0 } });
 
+    // @ts-expect-error
+    locator.pressSequentially();
+    // @ts-expect-error
+    locator.pressSequentially({ timeout: 10000 });
+    // $ExpectType Promise<void>
+    locator.pressSequentially("text");
+    // $ExpectType Promise<void>
+    locator.pressSequentially("text", { delay: 100 });
+    // $ExpectType Promise<void>
+    locator.pressSequentially("text", { noWaitAfter: true });
+    // $ExpectType Promise<void>
+    locator.pressSequentially("text", { timeout: 10000 });
+
     // @ts-expect-error
     locator.type();
     // @ts-expect-error