chrome-devtools-frontend 1.0.1376716 → 1.0.1380117

package/front_end/third_party/puppeteer/package/src/api/ElementHandle.ts

@@ -28,6 +28,7 @@ import type {
   KeyboardTypeOptions,
   KeyPressOptions,
   MouseClickOptions,
+  TouchHandle,
 } from './Input.js';
 import {JSHandle} from './JSHandle.js';
 import type {
@@ -997,19 +998,36 @@ export abstract class ElementHandle<
     await this.frame.page().touchscreen.tap(x, y);
   }
 
+  /**
+   * This method scrolls the element into view if needed, and then
+   * starts a touch in the center of the element.
+   * @returns A {@link TouchHandle} representing the touch that was started
+   */
   @throwIfDisposed()
   @bindIsolatedHandle
-  async touchStart(this: ElementHandle<Element>): Promise<void> {
+  async touchStart(this: ElementHandle<Element>): Promise<TouchHandle> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint();
-    await this.frame.page().touchscreen.touchStart(x, y);
+    return await this.frame.page().touchscreen.touchStart(x, y);
   }
 
+  /**
+   * This method scrolls the element into view if needed, and then
+   * moves the touch to the center of the element.
+   * @param touch - An optional {@link TouchHandle}. If provided, this touch
+   * will be moved. If not provided, the first active touch will be moved.
+   */
   @throwIfDisposed()
   @bindIsolatedHandle
-  async touchMove(this: ElementHandle<Element>): Promise<void> {
+  async touchMove(
+    this: ElementHandle<Element>,
+    touch?: TouchHandle,
+  ): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint();
+    if (touch) {
+      return await touch.move(x, y);
+    }
     await this.frame.page().touchscreen.touchMove(x, y);
   }
 

package/front_end/third_party/puppeteer/package/src/api/Input.ts

@@ -6,7 +6,9 @@
 
 import type {Protocol} from 'devtools-protocol';
 
+import {TouchError} from '../common/Errors.js';
 import type {KeyInput} from '../common/USKeyboardLayout.js';
+import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
 
 import type {Point} from './ElementHandle.js';
 
@@ -469,36 +471,71 @@ export abstract class Mouse {
     options?: {delay?: number},
   ): Promise<void>;
 }
-
+/**
+ * The TouchHandle interface exposes methods to manipulate touches that have been started
+ * @public
+ */
+export interface TouchHandle {
+  /**
+   * Dispatches a `touchMove` event for this touch.
+   * @param x - Horizontal position of the move.
+   * @param y - Vertical position of the move.
+   */
+  move(x: number, y: number): Promise<void>;
+  /**
+   * Dispatches a `touchend` event for this touch.
+   */
+  end(): Promise<void>;
+}
 /**
  * The Touchscreen class exposes touchscreen events.
  * @public
  */
 export abstract class Touchscreen {
+  /**
+   * @internal
+   */
+  idGenerator = createIncrementalIdGenerator();
+  /**
+   * @internal
+   */
+  touches: TouchHandle[] = [];
   /**
    * @internal
    */
   constructor() {}
 
+  /**
+   * @internal
+   */
+  removeHandle(handle: TouchHandle): void {
+    const index = this.touches.indexOf(handle);
+    if (index === -1) {
+      return;
+    }
+    this.touches.splice(index, 1);
+  }
+
   /**
    * Dispatches a `touchstart` and `touchend` event.
    * @param x - Horizontal position of the tap.
    * @param y - Vertical position of the tap.
    */
   async tap(x: number, y: number): Promise<void> {
-    await this.touchStart(x, y);
-    await this.touchEnd();
+    const touch = await this.touchStart(x, y);
+    await touch.end();
   }
 
   /**
    * Dispatches a `touchstart` event.
    * @param x - Horizontal position of the tap.
    * @param y - Vertical position of the tap.
+   * @returns A handle for the touch that was started.
    */
-  abstract touchStart(x: number, y: number): Promise<void>;
+  abstract touchStart(x: number, y: number): Promise<TouchHandle>;
 
   /**
-   * Dispatches a `touchMove` event.
+   * Dispatches a `touchMove` event on the first touch that is active.
    * @param x - Horizontal position of the move.
    * @param y - Vertical position of the move.
    *
@@ -509,10 +546,22 @@ export abstract class Touchscreen {
    * {@link https://developer.chrome.com/blog/a-more-compatible-smoother-touch/#chromes-new-model-the-throttled-async-touchmove-model | throttles}
    * touch move events.
    */
-  abstract touchMove(x: number, y: number): Promise<void>;
+  async touchMove(x: number, y: number): Promise<void> {
+    const touch = this.touches[0];
+    if (!touch) {
+      throw new TouchError('Must start a new Touch first');
+    }
+    return await touch.move(x, y);
+  }
 
   /**
-   * Dispatches a `touchend` event.
+   * Dispatches a `touchend` event on the first touch that is active.
    */
-  abstract touchEnd(): Promise<void>;
+  async touchEnd(): Promise<void> {
+    const touch = this.touches.shift();
+    if (!touch) {
+      throw new TouchError('Must start a new Touch first');
+    }
+    await touch.end();
+  }
 }

package/front_end/third_party/puppeteer/package/src/bidi/ElementHandle.ts

@@ -102,13 +102,15 @@ export class BidiElementHandle<
   ): Promise<void> {
     // Locate all files and confirm that they exist.
     const path = environment.value.path;
-    files = files.map(file => {
-      if (path.win32.isAbsolute(file) || path.posix.isAbsolute(file)) {
-        return file;
-      } else {
-        return path.resolve(file);
-      }
-    });
+    if (path) {
+      files = files.map(file => {
+        if (path.win32.isAbsolute(file) || path.posix.isAbsolute(file)) {
+          return file;
+        } else {
+          return path.resolve(file);
+        }
+      });
+    }
     await this.frame.setFiles(this, files);
   }
 

package/front_end/third_party/puppeteer/package/src/bidi/Frame.ts

@@ -193,6 +193,7 @@ export class BidiFrame extends Frame {
             text,
             args,
             getStackTraceLocations(entry.stackTrace),
+            this,
           ),
         );
       } else if (isJavaScriptLogEntry(entry)) {

package/front_end/third_party/puppeteer/package/src/bidi/Input.ts

@@ -12,6 +12,7 @@ import {
   Mouse,
   MouseButton,
   Touchscreen,
+  type TouchHandle,
   type KeyboardTypeOptions,
   type KeyDownOptions,
   type KeyPressOptions,
@@ -21,6 +22,7 @@ import {
   type MouseWheelOptions,
 } from '../api/Input.js';
 import {UnsupportedOperation} from '../common/Errors.js';
+import {TouchError} from '../common/Errors.js';
 import type {KeyInput} from '../common/USKeyboardLayout.js';
 
 import type {BidiPage} from './Page.js';
@@ -613,79 +615,87 @@ export class BidiMouse extends Mouse {
 /**
  * @internal
  */
-export class BidiTouchscreen extends Touchscreen {
+class BidiTouchHandle implements TouchHandle {
+  #started = false;
+  #x: number;
+  #y: number;
+  #bidiId: string;
   #page: BidiPage;
+  #touchScreen: BidiTouchscreen;
+  #properties: Bidi.Input.PointerCommonProperties;
 
-  constructor(page: BidiPage) {
-    super();
+  constructor(
+    page: BidiPage,
+    touchScreen: BidiTouchscreen,
+    id: number,
+    x: number,
+    y: number,
+    properties: Bidi.Input.PointerCommonProperties,
+  ) {
     this.#page = page;
+    this.#touchScreen = touchScreen;
+    this.#x = Math.round(x);
+    this.#y = Math.round(y);
+    this.#properties = properties;
+    this.#bidiId = `${InputId.Finger}_${id}`;
   }
 
-  override async touchStart(
-    x: number,
-    y: number,
-    options: BidiTouchMoveOptions = {},
-  ): Promise<void> {
+  async start(options: BidiTouchMoveOptions = {}): Promise<void> {
+    if (this.#started) {
+      throw new TouchError('Touch has already started');
+    }
     await this.#page.mainFrame().browsingContext.performActions([
       {
         type: SourceActionsType.Pointer,
-        id: InputId.Finger,
+        id: this.#bidiId,
         parameters: {
           pointerType: Bidi.Input.PointerType.Touch,
         },
         actions: [
           {
             type: ActionType.PointerMove,
-            x: Math.round(x),
-            y: Math.round(y),
+            x: this.#x,
+            y: this.#y,
             origin: options.origin,
           },
           {
+            ...this.#properties,
             type: ActionType.PointerDown,
             button: 0,
-            width: 0.5 * 2, // 2 times default touch radius.
-            height: 0.5 * 2, // 2 times default touch radius.
-            pressure: 0.5,
-            altitudeAngle: Math.PI / 2,
           },
         ],
       },
     ]);
+    this.#started = true;
   }
 
-  override async touchMove(
-    x: number,
-    y: number,
-    options: BidiTouchMoveOptions = {},
-  ): Promise<void> {
-    await this.#page.mainFrame().browsingContext.performActions([
+  move(x: number, y: number): Promise<void> {
+    const newX = Math.round(x);
+    const newY = Math.round(y);
+    return this.#page.mainFrame().browsingContext.performActions([
       {
         type: SourceActionsType.Pointer,
-        id: InputId.Finger,
+        id: this.#bidiId,
         parameters: {
           pointerType: Bidi.Input.PointerType.Touch,
         },
         actions: [
           {
+            ...this.#properties,
             type: ActionType.PointerMove,
-            x: Math.round(x),
-            y: Math.round(y),
-            origin: options.origin,
-            width: 0.5 * 2, // 2 times default touch radius.
-            height: 0.5 * 2, // 2 times default touch radius.
-            pressure: 0.5,
-            altitudeAngle: Math.PI / 2,
+            x: newX,
+            y: newY,
           },
         ],
       },
     ]);
   }
 
-  override async touchEnd(): Promise<void> {
+  async end(): Promise<void> {
     await this.#page.mainFrame().browsingContext.performActions([
       {
         type: SourceActionsType.Pointer,
-        id: InputId.Finger,
+        id: this.#bidiId,
         parameters: {
           pointerType: Bidi.Input.PointerType.Touch,
         },
@@ -697,5 +707,36 @@ export class BidiTouchscreen extends Touchscreen {
         ],
       },
     ]);
+    this.#touchScreen.removeHandle(this);
+  }
+}
+/**
+ * @internal
+ */
+export class BidiTouchscreen extends Touchscreen {
+  #page: BidiPage;
+  declare touches: BidiTouchHandle[];
+
+  constructor(page: BidiPage) {
+    super();
+    this.#page = page;
+  }
+
+  override async touchStart(
+    x: number,
+    y: number,
+    options: BidiTouchMoveOptions = {},
+  ): Promise<TouchHandle> {
+    const id = this.idGenerator();
+    const properties: Bidi.Input.PointerCommonProperties = {
+      width: 0.5 * 2, // 2 times default touch radius.
+      height: 0.5 * 2, // 2 times default touch radius.
+      pressure: 0.5,
+      altitudeAngle: Math.PI / 2,
+    };
+    const touch = new BidiTouchHandle(this.#page, this, id, x, y, properties);
+    await touch.start(options);
+    this.touches.push(touch);
+    return touch;
   }
 }

package/front_end/third_party/puppeteer/package/src/cdp/ElementHandle.ts

@@ -101,25 +101,30 @@ export class CdpElementHandle<
   @bindIsolatedHandle
   override async uploadFile(
     this: CdpElementHandle<HTMLInputElement>,
-    ...filePaths: string[]
+    ...files: string[]
   ): Promise<void> {
     const isMultiple = await this.evaluate(element => {
       return element.multiple;
     });
     assert(
-      filePaths.length <= 1 || isMultiple,
+      files.length <= 1 || isMultiple,
       'Multiple file uploads only work with <input type=file multiple>',
     );
 
     // Locate all files and confirm that they exist.
     const path = environment.value.path;
-    const files = filePaths.map(filePath => {
-      if (path.win32.isAbsolute(filePath) || path.posix.isAbsolute(filePath)) {
-        return filePath;
-      } else {
-        return path.resolve(filePath);
-      }
-    });
+    if (path) {
+      files = files.map(filePath => {
+        if (
+          path.win32.isAbsolute(filePath) ||
+          path.posix.isAbsolute(filePath)
+        ) {
+          return filePath;
+        } else {
+          return path.resolve(filePath);
+        }
+      });
+    }
 
     /**
      * The zero-length array is a special case, it seems that

package/front_end/third_party/puppeteer/package/src/cdp/Input.ts

@@ -13,6 +13,7 @@ import {
   Mouse,
   MouseButton,
   Touchscreen,
+  type TouchHandle,
   type KeyDownOptions,
   type KeyPressOptions,
   type KeyboardTypeOptions,
@@ -21,6 +22,7 @@ import {
   type MouseOptions,
   type MouseWheelOptions,
 } from '../api/Input.js';
+import {TouchError} from '../common/Errors.js';
 import {
   _keyDefinitions,
   type KeyDefinition,
@@ -552,57 +554,100 @@ export class CdpMouse extends Mouse {
 /**
  * @internal
  */
-export class CdpTouchscreen extends Touchscreen {
+class CdpTouchHandle implements TouchHandle {
+  #started = false;
+  #touchScreen: CdpTouchscreen;
+  #touchPoint: Protocol.Input.TouchPoint;
   #client: CDPSession;
   #keyboard: CdpKeyboard;
 
-  constructor(client: CDPSession, keyboard: CdpKeyboard) {
-    super();
+  constructor(
+    client: CDPSession,
+    touchScreen: CdpTouchscreen,
+    keyboard: CdpKeyboard,
+    touchPoint: Protocol.Input.TouchPoint,
+  ) {
     this.#client = client;
+    this.#touchScreen = touchScreen;
     this.#keyboard = keyboard;
+    this.#touchPoint = touchPoint;
   }
 
   updateClient(client: CDPSession): void {
     this.#client = client;
   }
 
-  override async touchStart(x: number, y: number): Promise<void> {
+  async start(): Promise<void> {
+    if (this.#started) {
+      throw new TouchError('Touch has already started');
+    }
     await this.#client.send('Input.dispatchTouchEvent', {
       type: 'touchStart',
-      touchPoints: [
-        {
-          x: Math.round(x),
-          y: Math.round(y),
-          radiusX: 0.5,
-          radiusY: 0.5,
-          force: 0.5,
-        },
-      ],
+      touchPoints: [this.#touchPoint],
       modifiers: this.#keyboard._modifiers,
     });
+    this.#started = true;
   }
 
-  override async touchMove(x: number, y: number): Promise<void> {
-    await this.#client.send('Input.dispatchTouchEvent', {
+  move(x: number, y: number): Promise<void> {
+    this.#touchPoint.x = Math.round(x);
+    this.#touchPoint.y = Math.round(y);
+    return this.#client.send('Input.dispatchTouchEvent', {
       type: 'touchMove',
-      touchPoints: [
-        {
-          x: Math.round(x),
-          y: Math.round(y),
-          radiusX: 0.5,
-          radiusY: 0.5,
-          force: 0.5,
-        },
-      ],
+      touchPoints: [this.#touchPoint],
       modifiers: this.#keyboard._modifiers,
     });
   }
 
-  override async touchEnd(): Promise<void> {
+  async end(): Promise<void> {
     await this.#client.send('Input.dispatchTouchEvent', {
       type: 'touchEnd',
-      touchPoints: [],
+      touchPoints: [this.#touchPoint],
       modifiers: this.#keyboard._modifiers,
     });
+    this.#touchScreen.removeHandle(this);
+  }
+}
+
+/**
+ * @internal
+ */
+export class CdpTouchscreen extends Touchscreen {
+  #client: CDPSession;
+  #keyboard: CdpKeyboard;
+  declare touches: CdpTouchHandle[];
+
+  constructor(client: CDPSession, keyboard: CdpKeyboard) {
+    super();
+    this.#client = client;
+    this.#keyboard = keyboard;
+  }
+
+  updateClient(client: CDPSession): void {
+    this.#client = client;
+    this.touches.forEach(t => {
+      t.updateClient(client);
+    });
+  }
+
+  override async touchStart(x: number, y: number): Promise<TouchHandle> {
+    const id = this.idGenerator();
+    const touchPoint: Protocol.Input.TouchPoint = {
+      x: Math.round(x),
+      y: Math.round(y),
+      radiusX: 0.5,
+      radiusY: 0.5,
+      force: 0.5,
+      id,
+    };
+    const touch = new CdpTouchHandle(
+      this.#client,
+      this,
+      this.#keyboard,
+      touchPoint,
+    );
+    await touch.start();
+    this.touches.push(touch);
+    return touch;
   }
 }

package/front_end/third_party/puppeteer/package/src/common/CallbackRegistry.ts

@@ -6,6 +6,7 @@
 
 import {Deferred} from '../util/Deferred.js';
 import {rewriteError} from '../util/ErrorLike.js';
+import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
 
 import {ProtocolError, TargetCloseError} from './Errors.js';
 import {debugError} from './util.js';
@@ -159,18 +160,3 @@ export class Callback {
     return this.#label;
   }
 }
-
-/**
- * @internal
- */
-export function createIncrementalIdGenerator(): GetIdFn {
-  let id = 0;
-  return (): number => {
-    return ++id;
-  };
-}
-
-/**
- * @internal
- */
-export type GetIdFn = () => number;

package/front_end/third_party/puppeteer/package/src/common/ConsoleMessage.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {Frame} from '../api/Frame.js';
 import type {JSHandle} from '../api/JSHandle.js';
 
 /**
@@ -60,6 +61,7 @@ export class ConsoleMessage {
   #text: string;
   #args: JSHandle[];
   #stackTraceLocations: ConsoleMessageLocation[];
+  #frame?: Frame;
 
   /**
    * @internal
@@ -69,11 +71,13 @@ export class ConsoleMessage {
     text: string,
     args: JSHandle[],
     stackTraceLocations: ConsoleMessageLocation[],
+    frame?: Frame,
   ) {
     this.#type = type;
     this.#text = text;
     this.#args = args;
     this.#stackTraceLocations = stackTraceLocations;
+    this.#frame = frame;
   }
 
   /**
@@ -101,7 +105,10 @@ export class ConsoleMessage {
    * The location of the console message.
    */
   location(): ConsoleMessageLocation {
-    return this.#stackTraceLocations[0] ?? {};
+    return (
+      this.#stackTraceLocations[0] ??
+      (this.#frame ? {url: this.#frame.url()} : {})
+    );
   }
 
   /**

package/front_end/third_party/puppeteer/package/src/common/Errors.ts

@@ -38,6 +38,13 @@ export class PuppeteerError extends Error {
  */
 export class TimeoutError extends PuppeteerError {}
 
+/**
+ * TouchError is thrown when an attempt is made to move or end a touch that does
+ * not exist.
+ * @public
+ */
+export class TouchError extends PuppeteerError {}
+
 /**
  * ProtocolError is emitted whenever there is an error from the protocol.
  *

package/front_end/third_party/puppeteer/package/src/common/WaitTask.ts

@@ -56,15 +56,9 @@ export class WaitTask<T = unknown> {
     this.#polling = options.polling;
     this.#root = options.root;
     this.#signal = options.signal;
-    this.#signal?.addEventListener(
-      'abort',
-      () => {
-        void this.terminate(this.#signal?.reason);
-      },
-      {
-        once: true,
-      },
-    );
+    this.#signal?.addEventListener('abort', this.#onAbortSignal, {
+      once: true,
+    });
 
     switch (typeof fn) {
       case 'string':
@@ -176,6 +170,8 @@ export class WaitTask<T = unknown> {
   async terminate(error?: Error): Promise<void> {
     this.#world.taskManager.delete(this);
 
+    this.#signal?.removeEventListener('abort', this.#onAbortSignal);
+
     clearTimeout(this.#timeout);
 
     if (error && !this.#result.finished()) {
@@ -242,6 +238,10 @@ export class WaitTask<T = unknown> {
       cause: error,
     });
   }
+
+  #onAbortSignal = () => {
+    void this.terminate(this.#signal?.reason);
+  };
 }
 
 /**

package/front_end/third_party/puppeteer/package/src/environment.ts

@@ -16,7 +16,7 @@ export const isNode = !!(typeof process !== 'undefined' && process.version);
 
 export interface EnvironmentDependencies {
   fs: typeof FS;
-  path: typeof Path;
+  path?: typeof Path;
   ScreenRecorder: typeof ScreenRecorder;
 }
 
@@ -31,9 +31,6 @@ export const environment: {
     get fs(): typeof FS {
       throw new Error('fs is not available in this environment');
     },
-    get path(): typeof Path {
-      throw new Error('path is not available in this environment');
-    },
     get ScreenRecorder(): typeof ScreenRecorder {
       throw new Error('ScreenRecorder is not available in this environment');
     },