chrome-devtools-frontend 1.0.1362775 → 1.0.1376716

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

@@ -109,6 +109,65 @@ export interface ElementScreenshotOptions extends ScreenshotOptions {
   scrollIntoView?: boolean;
 }
 
+/**
+ * A given method will have it's `this` replaced with an isolated version of
+ * `this` when decorated with this decorator.
+ *
+ * All changes of isolated `this` are reflected on the actual `this`.
+ *
+ * @internal
+ */
+export function bindIsolatedHandle<This extends ElementHandle<Node>>(
+  target: (this: This, ...args: any[]) => Promise<any>,
+  _: unknown,
+): typeof target {
+  return async function (...args) {
+    // If the handle is already isolated, then we don't need to adopt it
+    // again.
+    if (this.realm === this.frame.isolatedRealm()) {
+      return await target.call(this, ...args);
+    }
+    let adoptedThis: This;
+    if (this['isolatedHandle']) {
+      adoptedThis = this['isolatedHandle'];
+    } else {
+      this['isolatedHandle'] = adoptedThis = await this.frame
+        .isolatedRealm()
+        .adoptHandle(this);
+    }
+    const result = await target.call(adoptedThis, ...args);
+    // If the function returns `adoptedThis`, then we return `this`.
+    if (result === adoptedThis) {
+      return this;
+    }
+    // If the function returns a handle, transfer it into the current realm.
+    if (result instanceof JSHandle) {
+      return await this.realm.transferHandle(result);
+    }
+    // If the function returns an array of handlers, transfer them into the
+    // current realm.
+    if (Array.isArray(result)) {
+      await Promise.all(
+        result.map(async (item, index, result) => {
+          if (item instanceof JSHandle) {
+            result[index] = await this.realm.transferHandle(item);
+          }
+        }),
+      );
+    }
+    if (result instanceof Map) {
+      await Promise.all(
+        [...result.entries()].map(async ([key, value]) => {
+          if (value instanceof JSHandle) {
+            result.set(key, await this.realm.transferHandle(value));
+          }
+        }),
+      );
+    }
+    return result;
+  };
+}
+
 /**
  * ElementHandle represents an in-page DOM element.
  *
@@ -157,65 +216,6 @@ export abstract class ElementHandle<
    */
   isolatedHandle?: typeof this;
 
-  /**
-   * A given method will have it's `this` replaced with an isolated version of
-   * `this` when decorated with this decorator.
-   *
-   * All changes of isolated `this` are reflected on the actual `this`.
-   *
-   * @internal
-   */
-  static bindIsolatedHandle<This extends ElementHandle<Node>>(
-    target: (this: This, ...args: any[]) => Promise<any>,
-    _: unknown
-  ): typeof target {
-    return async function (...args) {
-      // If the handle is already isolated, then we don't need to adopt it
-      // again.
-      if (this.realm === this.frame.isolatedRealm()) {
-        return await target.call(this, ...args);
-      }
-      let adoptedThis: This;
-      if (this['isolatedHandle']) {
-        adoptedThis = this['isolatedHandle'];
-      } else {
-        this['isolatedHandle'] = adoptedThis = await this.frame
-          .isolatedRealm()
-          .adoptHandle(this);
-      }
-      const result = await target.call(adoptedThis, ...args);
-      // If the function returns `adoptedThis`, then we return `this`.
-      if (result === adoptedThis) {
-        return this;
-      }
-      // If the function returns a handle, transfer it into the current realm.
-      if (result instanceof JSHandle) {
-        return await this.realm.transferHandle(result);
-      }
-      // If the function returns an array of handlers, transfer them into the
-      // current realm.
-      if (Array.isArray(result)) {
-        await Promise.all(
-          result.map(async (item, index, result) => {
-            if (item instanceof JSHandle) {
-              result[index] = await this.realm.transferHandle(item);
-            }
-          })
-        );
-      }
-      if (result instanceof Map) {
-        await Promise.all(
-          [...result.entries()].map(async ([key, value]) => {
-            if (value instanceof JSHandle) {
-              result.set(key, await this.realm.transferHandle(value));
-            }
-          })
-        );
-      }
-      return result;
-    };
-  }
-
   /**
    * @internal
    */
@@ -248,9 +248,9 @@ export abstract class ElementHandle<
    * @internal
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   override async getProperty<K extends keyof ElementType>(
-    propertyName: HandleOr<K>
+    propertyName: HandleOr<K>,
   ): Promise<HandleFor<ElementType[K]>> {
     return await this.handle.getProperty(propertyName);
   }
@@ -259,7 +259,7 @@ export abstract class ElementHandle<
    * @internal
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   override async getProperties(): Promise<Map<string, JSHandle>> {
     return await this.handle.getProperties();
   }
@@ -279,7 +279,7 @@ export abstract class ElementHandle<
   ): Promise<Awaited<ReturnType<Func>>> {
     pageFunction = withSourcePuppeteerURLIfNone(
       this.evaluate.name,
-      pageFunction
+      pageFunction,
     );
     return await this.handle.evaluate(pageFunction, ...args);
   }
@@ -299,7 +299,7 @@ export abstract class ElementHandle<
   ): Promise<HandleFor<Awaited<ReturnType<Func>>>> {
     pageFunction = withSourcePuppeteerURLIfNone(
       this.evaluateHandle.name,
-      pageFunction
+      pageFunction,
     );
     return await this.handle.evaluateHandle(pageFunction, ...args);
   }
@@ -308,7 +308,7 @@ export abstract class ElementHandle<
    * @internal
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   override async jsonValue(): Promise<ElementType> {
     return await this.handle.jsonValue();
   }
@@ -368,15 +368,15 @@ export abstract class ElementHandle<
    * matching the given selector. Otherwise, `null`.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async $<Selector extends string>(
-    selector: Selector
+    selector: Selector,
   ): Promise<ElementHandle<NodeFor<Selector>> | null> {
     const {updatedSelector, QueryHandler} =
       getQueryHandlerAndSelector(selector);
     return (await QueryHandler.queryOne(
       this,
-      updatedSelector
+      updatedSelector,
     )) as ElementHandle<NodeFor<Selector>> | null;
   }
 
@@ -404,7 +404,7 @@ export abstract class ElementHandle<
   @throwIfDisposed()
   async $$<Selector extends string>(
     selector: Selector,
-    options?: QueryOptions
+    options?: QueryOptions,
   ): Promise<Array<ElementHandle<NodeFor<Selector>>>> {
     if (options?.isolate === false) {
       return await this.#$$impl(selector);
@@ -417,9 +417,9 @@ export abstract class ElementHandle<
    *
    * @internal
    */
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async #$$<Selector extends string>(
-    selector: Selector
+    selector: Selector,
   ): Promise<Array<ElementHandle<NodeFor<Selector>>>> {
     return await this.#$$impl(selector);
   }
@@ -430,12 +430,12 @@ export abstract class ElementHandle<
    * @internal
    */
   async #$$impl<Selector extends string>(
-    selector: Selector
+    selector: Selector,
   ): Promise<Array<ElementHandle<NodeFor<Selector>>>> {
     const {updatedSelector, QueryHandler} =
       getQueryHandlerAndSelector(selector);
     return await (AsyncIterableUtil.collect(
-      QueryHandler.queryAll(this, updatedSelector)
+      QueryHandler.queryAll(this, updatedSelector),
     ) as Promise<Array<ElementHandle<NodeFor<Selector>>>>);
   }
 
@@ -451,10 +451,10 @@ export abstract class ElementHandle<
    * ```ts
    * const tweetHandle = await page.$('.tweet');
    * expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe(
-   *   '100'
+   *   '100',
    * );
    * expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe(
-   *   '10'
+   *   '10',
    * );
    * ```
    *
@@ -495,7 +495,7 @@ export abstract class ElementHandle<
     using elementHandle = await this.$(selector);
     if (!elementHandle) {
       throw new Error(
-        `Error: failed to find element matching selector "${selector}"`
+        `Error: failed to find element matching selector "${selector}"`,
       );
     }
     return await elementHandle.evaluate(pageFunction, ...args);
@@ -523,7 +523,7 @@ export abstract class ElementHandle<
    * ```ts
    * const feedHandle = await page.$('.feed');
    * expect(
-   *   await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))
+   *   await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText)),
    * ).toEqual(['Hello!', 'Hi!']);
    * ```
    *
@@ -566,7 +566,7 @@ export abstract class ElementHandle<
       (_, ...elements) => {
         return elements;
       },
-      ...results
+      ...results,
     );
     const [result] = await Promise.all([
       elements.evaluate(pageFunction, ...args),
@@ -615,10 +615,10 @@ export abstract class ElementHandle<
    * @throws Throws if an element matching the given selector doesn't appear.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async waitForSelector<Selector extends string>(
     selector: Selector,
-    options: WaitForSelectorOptions = {}
+    options: WaitForSelectorOptions = {},
   ): Promise<ElementHandle<NodeFor<Selector>> | null> {
     const {updatedSelector, QueryHandler, polling} =
       getQueryHandlerAndSelector(selector);
@@ -636,7 +636,7 @@ export abstract class ElementHandle<
       LazyArg.create(context => {
         return context.puppeteerUtil;
       }),
-      visibility
+      visibility,
     );
   }
 
@@ -654,7 +654,7 @@ export abstract class ElementHandle<
    *   is not `hidden` or `collapse`.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async isVisible(): Promise<boolean> {
     return await this.#checkVisibility(true);
   }
@@ -672,7 +672,7 @@ export abstract class ElementHandle<
    *   is `hidden` or `collapse`.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async isHidden(): Promise<boolean> {
     return await this.#checkVisibility(false);
   }
@@ -684,7 +684,7 @@ export abstract class ElementHandle<
    *
    * ```ts
    * const element: ElementHandle<Element> = await page.$(
-   *   '.class-name-of-anchor'
+   *   '.class-name-of-anchor',
    * );
    * // DO NOT DISPOSE `element`, this will be always be the same handle.
    * const anchor: ElementHandle<HTMLAnchorElement> =
@@ -696,7 +696,7 @@ export abstract class ElementHandle<
    * automatically disposed.**
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async toElement<
     K extends keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap,
   >(tagName: K): Promise<HandleFor<ElementFor<K>>> {
@@ -720,7 +720,7 @@ export abstract class ElementHandle<
    * Returns the middle point within an element unless a specific offset is provided.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async clickablePoint(offset?: Offset): Promise<Point> {
     const box = await this.#clickableBox();
     if (!box) {
@@ -744,7 +744,7 @@ export abstract class ElementHandle<
    * If the element is detached from DOM, the method throws an error.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async hover(this: ElementHandle<Element>): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint();
@@ -757,10 +757,10 @@ export abstract class ElementHandle<
    * If the element is detached from DOM, the method throws an error.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async click(
     this: ElementHandle<Element>,
-    options: Readonly<ClickOptions> = {}
+    options: Readonly<ClickOptions> = {},
   ): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint(options.offset);
@@ -774,10 +774,10 @@ export abstract class ElementHandle<
    * returned.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async drag(
     this: ElementHandle<Element>,
-    target: Point | ElementHandle<Element>
+    target: Point | ElementHandle<Element>,
   ): Promise<Protocol.Input.DragData | void> {
     await this.scrollIntoViewIfNeeded();
     const page = this.frame.page();
@@ -809,10 +809,10 @@ export abstract class ElementHandle<
    * @deprecated Do not use. `dragenter` will automatically be performed during dragging.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async dragEnter(
     this: ElementHandle<Element>,
-    data: Protocol.Input.DragData = {items: [], dragOperationsMask: 1}
+    data: Protocol.Input.DragData = {items: [], dragOperationsMask: 1},
   ): Promise<void> {
     const page = this.frame.page();
     await this.scrollIntoViewIfNeeded();
@@ -824,10 +824,10 @@ export abstract class ElementHandle<
    * @deprecated Do not use. `dragover` will automatically be performed during dragging.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async dragOver(
     this: ElementHandle<Element>,
-    data: Protocol.Input.DragData = {items: [], dragOperationsMask: 1}
+    data: Protocol.Input.DragData = {items: [], dragOperationsMask: 1},
   ): Promise<void> {
     const page = this.frame.page();
     await this.scrollIntoViewIfNeeded();
@@ -840,7 +840,7 @@ export abstract class ElementHandle<
    */
   async drop(
     this: ElementHandle<Element>,
-    element: ElementHandle<Element>
+    element: ElementHandle<Element>,
   ): Promise<void>;
 
   /**
@@ -848,20 +848,20 @@ export abstract class ElementHandle<
    */
   async drop(
     this: ElementHandle<Element>,
-    data?: Protocol.Input.DragData
+    data?: Protocol.Input.DragData,
   ): Promise<void>;
 
   /**
    * @internal
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async drop(
     this: ElementHandle<Element>,
     dataOrElement: ElementHandle<Element> | Protocol.Input.DragData = {
       items: [],
       dragOperationsMask: 1,
-    }
+    },
   ): Promise<void> {
     const page = this.frame.page();
     if ('items' in dataOrElement) {
@@ -881,16 +881,16 @@ export abstract class ElementHandle<
    * @deprecated Use `ElementHandle.drop` instead.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async dragAndDrop(
     this: ElementHandle<Element>,
     target: ElementHandle<Node>,
-    options?: {delay: number}
+    options?: {delay: number},
   ): Promise<void> {
     const page = this.frame.page();
     assert(
       page.isDragInterceptionEnabled(),
-      'Drag Interception is not enabled!'
+      'Drag Interception is not enabled!',
     );
     await this.scrollIntoViewIfNeeded();
     const startPoint = await this.clickablePoint();
@@ -915,7 +915,7 @@ export abstract class ElementHandle<
    * one is taken into account.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async select(...values: string[]): Promise<string[]> {
     for (const value of values) {
       assert(
@@ -924,7 +924,7 @@ export abstract class ElementHandle<
           value +
           '" of type "' +
           typeof value +
-          '"'
+          '"',
       );
     }
 
@@ -981,7 +981,7 @@ export abstract class ElementHandle<
    */
   abstract queryAXTree(
     name?: string,
-    role?: string
+    role?: string,
   ): AwaitableIterable<ElementHandle<Node>>;
 
   /**
@@ -990,7 +990,7 @@ export abstract class ElementHandle<
    * If the element is detached from DOM, the method throws an error.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async tap(this: ElementHandle<Element>): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint();
@@ -998,7 +998,7 @@ export abstract class ElementHandle<
   }
 
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async touchStart(this: ElementHandle<Element>): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint();
@@ -1006,7 +1006,7 @@ export abstract class ElementHandle<
   }
 
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async touchMove(this: ElementHandle<Element>): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     const {x, y} = await this.clickablePoint();
@@ -1014,7 +1014,7 @@ export abstract class ElementHandle<
   }
 
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async touchEnd(this: ElementHandle<Element>): Promise<void> {
     await this.scrollIntoViewIfNeeded();
     await this.frame.page().touchscreen.touchEnd();
@@ -1024,7 +1024,7 @@ export abstract class ElementHandle<
    * Calls {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus | focus} on the element.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async focus(): Promise<void> {
     await this.evaluate(element => {
       if (!(element instanceof HTMLElement)) {
@@ -1060,10 +1060,10 @@ export abstract class ElementHandle<
    * @param options - Delay in milliseconds. Defaults to 0.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async type(
     text: string,
-    options?: Readonly<KeyboardTypeOptions>
+    options?: Readonly<KeyboardTypeOptions>,
   ): Promise<void> {
     await this.focus();
     await this.frame.page().keyboard.type(text, options);
@@ -1084,10 +1084,10 @@ export abstract class ElementHandle<
    * See {@link KeyInput} for a list of all key names.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async press(
     key: KeyInput,
-    options?: Readonly<KeyPressOptions>
+    options?: Readonly<KeyPressOptions>,
   ): Promise<void> {
     await this.focus();
     await this.frame.page().keyboard.press(key, options);
@@ -1175,7 +1175,7 @@ export abstract class ElementHandle<
    * (example: `display: none`).
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async boundingBox(): Promise<BoundingBox | null> {
     const box = await this.evaluate(element => {
       if (!(element instanceof Element)) {
@@ -1214,7 +1214,7 @@ export abstract class ElementHandle<
    * Each Point is an object `{x, y}`. Box points are sorted clock-wise.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async boxModel(): Promise<BoxModel | null> {
     const model = await this.evaluate(element => {
       if (!(element instanceof Element)) {
@@ -1266,7 +1266,7 @@ export abstract class ElementHandle<
 
       function transformQuadWithOffsets(
         quad: Quad,
-        offsets: {top: number; left: number; right: number; bottom: number}
+        offsets: {top: number; left: number; right: number; bottom: number},
       ): Quad {
         return [
           {
@@ -1352,14 +1352,14 @@ export abstract class ElementHandle<
    * If the element is detached from DOM, the method throws an error.
    */
   async screenshot(
-    options: Readonly<ScreenshotOptions> & {encoding: 'base64'}
+    options: Readonly<ScreenshotOptions> & {encoding: 'base64'},
   ): Promise<string>;
   async screenshot(options?: Readonly<ScreenshotOptions>): Promise<Uint8Array>;
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async screenshot(
     this: ElementHandle<Element>,
-    options: Readonly<ElementScreenshotOptions> = {}
+    options: Readonly<ElementScreenshotOptions> = {},
   ): Promise<string | Uint8Array> {
     const {scrollIntoView = true, clip} = options;
 
@@ -1423,7 +1423,7 @@ export abstract class ElementHandle<
    * @internal
    */
   protected async scrollIntoViewIfNeeded(
-    this: ElementHandle<Element>
+    this: ElementHandle<Element>,
   ): Promise<void> {
     if (
       await this.isIntersectingViewport({
@@ -1444,12 +1444,12 @@ export abstract class ElementHandle<
    * (full intersection). Defaults to 1.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async isIntersectingViewport(
     this: ElementHandle<Element>,
     options: {
       threshold?: number;
-    } = {}
+    } = {},
   ): Promise<boolean> {
     await this.assertConnectedElement();
     // eslint-disable-next-line rulesdir/use-using -- Returns `this`.
@@ -1466,7 +1466,7 @@ export abstract class ElementHandle<
         });
         return threshold === 1 ? visibleRatio === 1 : visibleRatio > threshold;
       },
-      options.threshold ?? 0
+      options.threshold ?? 0,
     );
   }
 
@@ -1475,7 +1475,7 @@ export abstract class ElementHandle<
    * or by calling element.scrollIntoView.
    */
   @throwIfDisposed()
-  @ElementHandle.bindIsolatedHandle
+  @bindIsolatedHandle
   async scrollIntoView(this: ElementHandle<Element>): Promise<void> {
     await this.assertConnectedElement();
     await this.evaluate(async (element): Promise<void> => {
@@ -1492,7 +1492,7 @@ export abstract class ElementHandle<
    * etc.).
    */
   async #asSVGElementHandle(
-    this: ElementHandle<Element>
+    this: ElementHandle<Element>,
   ): Promise<ElementHandle<SVGElement> | null> {
     if (
       await this.evaluate(element => {
@@ -1506,7 +1506,7 @@ export abstract class ElementHandle<
   }
 
   async #getOwnerSVGElement(
-    this: ElementHandle<SVGElement>
+    this: ElementHandle<SVGElement>,
   ): Promise<ElementHandle<SVGSVGElement>> {
     // SVGSVGElement.ownerSVGElement === null.
     return await this.evaluateHandle(element => {
@@ -1562,18 +1562,18 @@ export interface AutofillData {
 function intersectBoundingBox(
   box: BoundingBox,
   width: number,
-  height: number
+  height: number,
 ): void {
   box.width = Math.max(
     box.x >= 0
       ? Math.min(width - box.x, box.width)
       : Math.min(width, box.width + box.x),
-    0
+    0,
   );
   box.height = Math.max(
     box.y >= 0
       ? Math.min(height - box.y, box.height)
       : Math.min(height, box.height + box.y),
-    0
+    0,
   );
 }