selenium-webdriver 4.0.0-alpha.5 → 4.0.0-beta.1

package/lib/input.js

@@ -15,19 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
-'use strict';
+'use strict'
 
 /**
  * @fileoverview Defines types related to user input with the WebDriver API.
  */
 
-const promise = require('./promise');
-const {Command, Executor, Name} = require('./command');
+const promise = require('./promise')
+const { Command, Name } = require('./command')
 const {
   InvalidArgumentError,
   UnknownCommandError,
-  UnsupportedOperationError
-} = require('./error');
+  UnsupportedOperationError,
+} = require('./error')
 
 /**
  * Enumeration of the buttons used in the advanced interactions API.
@@ -36,10 +36,8 @@ const {
 const Button = {
   LEFT: 0,
   MIDDLE: 1,
-  RIGHT: 2
-};
-
-
+  RIGHT: 2,
+}
 
 /**
  * Representations of pressable keys that aren't text.  These are stored in
@@ -50,69 +48,69 @@ const Button = {
  * @see <https://www.w3.org/TR/webdriver/#keyboard-actions>
  */
 const Key = {
-  NULL:         '\uE000',
-  CANCEL:       '\uE001',  // ^break
-  HELP:         '\uE002',
-  BACK_SPACE:   '\uE003',
-  TAB:          '\uE004',
-  CLEAR:        '\uE005',
-  RETURN:       '\uE006',
-  ENTER:        '\uE007',
-  SHIFT:        '\uE008',
-  CONTROL:      '\uE009',
-  ALT:          '\uE00A',
-  PAUSE:        '\uE00B',
-  ESCAPE:       '\uE00C',
-  SPACE:        '\uE00D',
-  PAGE_UP:      '\uE00E',
-  PAGE_DOWN:    '\uE00F',
-  END:          '\uE010',
-  HOME:         '\uE011',
-  ARROW_LEFT:   '\uE012',
-  LEFT:         '\uE012',
-  ARROW_UP:     '\uE013',
-  UP:           '\uE013',
-  ARROW_RIGHT:  '\uE014',
-  RIGHT:        '\uE014',
-  ARROW_DOWN:   '\uE015',
-  DOWN:         '\uE015',
-  INSERT:       '\uE016',
-  DELETE:       '\uE017',
-  SEMICOLON:    '\uE018',
-  EQUALS:       '\uE019',
-
-  NUMPAD0:      '\uE01A',  // number pad keys
-  NUMPAD1:      '\uE01B',
-  NUMPAD2:      '\uE01C',
-  NUMPAD3:      '\uE01D',
-  NUMPAD4:      '\uE01E',
-  NUMPAD5:      '\uE01F',
-  NUMPAD6:      '\uE020',
-  NUMPAD7:      '\uE021',
-  NUMPAD8:      '\uE022',
-  NUMPAD9:      '\uE023',
-  MULTIPLY:     '\uE024',
-  ADD:          '\uE025',
-  SEPARATOR:    '\uE026',
-  SUBTRACT:     '\uE027',
-  DECIMAL:      '\uE028',
-  DIVIDE:       '\uE029',
-
-  F1:           '\uE031',  // function keys
-  F2:           '\uE032',
-  F3:           '\uE033',
-  F4:           '\uE034',
-  F5:           '\uE035',
-  F6:           '\uE036',
-  F7:           '\uE037',
-  F8:           '\uE038',
-  F9:           '\uE039',
-  F10:          '\uE03A',
-  F11:          '\uE03B',
-  F12:          '\uE03C',
-
-  COMMAND:      '\uE03D',  // Apple command key
-  META:         '\uE03D',  // alias for Windows key
+  NULL: '\uE000',
+  CANCEL: '\uE001', // ^break
+  HELP: '\uE002',
+  BACK_SPACE: '\uE003',
+  TAB: '\uE004',
+  CLEAR: '\uE005',
+  RETURN: '\uE006',
+  ENTER: '\uE007',
+  SHIFT: '\uE008',
+  CONTROL: '\uE009',
+  ALT: '\uE00A',
+  PAUSE: '\uE00B',
+  ESCAPE: '\uE00C',
+  SPACE: '\uE00D',
+  PAGE_UP: '\uE00E',
+  PAGE_DOWN: '\uE00F',
+  END: '\uE010',
+  HOME: '\uE011',
+  ARROW_LEFT: '\uE012',
+  LEFT: '\uE012',
+  ARROW_UP: '\uE013',
+  UP: '\uE013',
+  ARROW_RIGHT: '\uE014',
+  RIGHT: '\uE014',
+  ARROW_DOWN: '\uE015',
+  DOWN: '\uE015',
+  INSERT: '\uE016',
+  DELETE: '\uE017',
+  SEMICOLON: '\uE018',
+  EQUALS: '\uE019',
+
+  NUMPAD0: '\uE01A', // number pad keys
+  NUMPAD1: '\uE01B',
+  NUMPAD2: '\uE01C',
+  NUMPAD3: '\uE01D',
+  NUMPAD4: '\uE01E',
+  NUMPAD5: '\uE01F',
+  NUMPAD6: '\uE020',
+  NUMPAD7: '\uE021',
+  NUMPAD8: '\uE022',
+  NUMPAD9: '\uE023',
+  MULTIPLY: '\uE024',
+  ADD: '\uE025',
+  SEPARATOR: '\uE026',
+  SUBTRACT: '\uE027',
+  DECIMAL: '\uE028',
+  DIVIDE: '\uE029',
+
+  F1: '\uE031', // function keys
+  F2: '\uE032',
+  F3: '\uE033',
+  F4: '\uE034',
+  F5: '\uE035',
+  F6: '\uE036',
+  F7: '\uE037',
+  F8: '\uE038',
+  F9: '\uE039',
+  F10: '\uE03A',
+  F11: '\uE03B',
+  F12: '\uE03C',
+
+  COMMAND: '\uE03D', // Apple command key
+  META: '\uE03D', // alias for Windows key
 
   /**
    * Japanese modifier key for switching between full- and half-width
@@ -120,8 +118,7 @@ const Key = {
    * @see <https://en.wikipedia.org/wiki/Language_input_keys>
    */
   ZENKAKU_HANKAKU: '\uE040',
-};
-
+}
 
 /**
  * Simulate pressing many keys at once in a "chord". Takes a sequence of
@@ -135,10 +132,9 @@ const Key = {
  * @param {...string} keys The key sequence to concatenate.
  * @return {string} The null-terminated key sequence.
  */
-Key.chord = function(...keys) {
-  return keys.join('') + Key.NULL;
-};
-
+Key.chord = function (...keys) {
+  return keys.join('') + Key.NULL
+}
 
 /**
  * Used with {@link ./webelement.WebElement#sendKeys WebElement#sendKeys} on
@@ -152,10 +148,9 @@ Key.chord = function(...keys) {
  * elements. Of particular note is the
  * {@link selenium-webdriver/remote.FileDetector}, which should be used when
  * running against a remote
- * [Selenium Server](http://docs.seleniumhq.org/download/).
+ * [Selenium Server](https://selenium.dev/downloads/).
  */
 class FileDetector {
-
   /**
    * Handles the file specified by the given path, preparing it for use with
    * the current browser. If the path does not refer to a valid file, it will
@@ -170,12 +165,11 @@ class FileDetector {
    * @return {!Promise<string>} A promise for the processed file path.
    * @package
    */
-  handleFile(driver, path) {
-    return Promise.resolve(path);
+  handleFile(driver, path) { // eslint-disable-line
+    return Promise.resolve(path)
   }
 }
 
-
 /**
  * Generic description of a single action to send to the remote end.
  *
@@ -185,21 +179,20 @@ class FileDetector {
 class Action {
   constructor() {
     /** @type {!Action.Type} */
-    this.type;
+    this.type
     /** @type {(number|undefined)} */
-    this.duration;
+    this.duration
     /** @type {(string|undefined)} */
-    this.value;
+    this.value
     /** @type {(Button|undefined)} */
-    this.button;
+    this.button
     /** @type {(number|undefined)} */
-    this.x;
+    this.x
     /** @type {(number|undefined)} */
-    this.y;
+    this.y
   }
 }
 
-
 /**
  * @enum {string}
  * @package
@@ -212,9 +205,8 @@ Action.Type = {
   POINTER_DOWN: 'pointerDown',
   POINTER_UP: 'pointerUp',
   POINTER_MOVE: 'pointerMove',
-  POINTER_CANCEL: 'pointerCancel'
-};
-
+  POINTER_CANCEL: 'pointerCancel',
+}
 
 /**
  * Represents a user input device.
@@ -227,17 +219,16 @@ class Device {
    * @param {string} id a unique ID for this device.
    */
   constructor(type, id) {
-    /** @private @const */ this.type_ = type;
-    /** @private @const */ this.id_ = id;
+    /** @private @const */ this.type_ = type
+    /** @private @const */ this.id_ = id
   }
 
   /** @return {!Object} the JSON encoding for this device. */
   toJSON() {
-    return {'type': this.type_, 'id': this.id_};
+    return { type: this.type_, id: this.id_ }
   }
 }
 
-
 /**
  * Device types supported by the WebDriver protocol.
  *
@@ -247,9 +238,8 @@ class Device {
 Device.Type = {
   KEY: 'key',
   NONE: 'none',
-  POINTER: 'pointer'
-};
-
+  POINTER: 'pointer',
+}
 
 /**
  * @param {(string|Key|number)} key
@@ -258,22 +248,22 @@ Device.Type = {
  */
 function checkCodePoint(key) {
   if (typeof key === 'number') {
-    return String.fromCodePoint(key);
+    return String.fromCodePoint(key)
   }
 
   if (typeof key !== 'string') {
-    throw new InvalidArgumentError(`key is not a string: ${key}`);
+    throw new InvalidArgumentError(`key is not a string: ${key}`)
   }
 
-  key = key.normalize();
+  key = key.normalize()
   if (Array.from(key).length != 1) {
     throw new InvalidArgumentError(
-        `key input is not a single code point: ${key}`);
+      `key input is not a single code point: ${key}`
+    )
   }
-  return key;
+  return key
 }
 
-
 /**
  * Keyboard input device.
  *
@@ -283,7 +273,7 @@ function checkCodePoint(key) {
 class Keyboard extends Device {
   /** @param {string} id the device ID. */
   constructor(id) {
-    super(Device.Type.KEY, id);
+    super(Device.Type.KEY, id)
   }
 
   /**
@@ -296,7 +286,7 @@ class Keyboard extends Device {
    * @package
    */
   keyDown(key) {
-    return {type: Action.Type.KEY_DOWN, value: checkCodePoint(key)};
+    return { type: Action.Type.KEY_DOWN, value: checkCodePoint(key) }
   }
 
   /**
@@ -309,11 +299,10 @@ class Keyboard extends Device {
    * @package
    */
   keyUp(key) {
-    return {type: Action.Type.KEY_UP, value: checkCodePoint(key)};
+    return { type: Action.Type.KEY_UP, value: checkCodePoint(key) }
   }
 }
 
-
 /**
  * Defines the reference point from which to compute offsets for
  * {@linkplain ./input.Pointer#move pointer move} actions.
@@ -324,9 +313,8 @@ const Origin = {
   /** Compute offsets relative to the pointer's current position. */
   POINTER: 'pointer',
   /** Compute offsets relative to the viewport. */
-  VIEWPORT: 'viewport'
-};
-
+  VIEWPORT: 'viewport',
+}
 
 /**
  * Pointer input device.
@@ -340,15 +328,16 @@ class Pointer extends Device {
    * @param {Pointer.Type} type the pointer type.
    */
   constructor(id, type) {
-    super(Device.Type.POINTER, id);
-    /** @private @const */ this.pointerType_ = type;
+    super(Device.Type.POINTER, id)
+    /** @private @const */ this.pointerType_ = type
   }
 
   /** @override */
   toJSON() {
     return Object.assign(
-        {'parameters': {'pointerType': this.pointerType_}},
-        super.toJSON());
+      { parameters: { pointerType: this.pointerType_ } },
+      super.toJSON()
+    )
   }
 
   /**
@@ -356,7 +345,7 @@ class Pointer extends Device {
    * @package
    */
   cancel() {
-    return {type: Action.Type.POINTER_CANCEL};
+    return { type: Action.Type.POINTER_CANCEL }
   }
 
   /**
@@ -365,7 +354,7 @@ class Pointer extends Device {
    * @package
    */
   press(button = Button.LEFT) {
-    return {type: Action.Type.POINTER_DOWN, button};
+    return { type: Action.Type.POINTER_DOWN, button }
   }
 
   /**
@@ -375,7 +364,7 @@ class Pointer extends Device {
    * @package
    */
   release(button = Button.LEFT) {
-    return {type: Action.Type.POINTER_UP, button};
+    return { type: Action.Type.POINTER_UP, button }
   }
 
   /**
@@ -394,12 +383,11 @@ class Pointer extends Device {
    * @return {!Action} The new action.
    * @package
    */
-  move({x = 0, y = 0, duration = 100, origin = Origin.VIEWPORT}) {
-    return {type: Action.Type.POINTER_MOVE, origin, duration, x, y};
+  move({ x = 0, y = 0, duration = 100, origin = Origin.VIEWPORT }) {
+    return { type: Action.Type.POINTER_MOVE, origin, duration, x, y }
   }
 }
 
-
 /**
  * The supported types of pointers.
  * @enum {string}
@@ -407,9 +395,8 @@ class Pointer extends Device {
 Pointer.Type = {
   MOUSE: 'mouse',
   PEN: 'pen',
-  TOUCH: 'touch'
-};
-
+  TOUCH: 'touch',
+}
 
 /**
  * User facing API for generating complex user gestures. This class should not
@@ -478,7 +465,7 @@ Pointer.Type = {
  *
  * The length of each action tick is however long it takes the remote end to
  * execute the actions for every device in that tick. Most actions are
- * "instaneous", however, {@linkplain #pause pause} and
+ * "instantaneous", however, {@linkplain #pause pause} and
  * {@linkplain #move pointer move} actions allow you to specify a duration for
  * how long that action should take. The remote end will always wait for all
  * actions within a tick to finish before starting the next tick, so a device
@@ -495,7 +482,7 @@ Pointer.Type = {
  *
  * This implicit waiting also applies to pauses. In the table below, even though
  * the keyboard only defines a pause of 100 ms, the remote end will wait an
- * additional 200 ms for the mouse mmove to finish before moving to Tick 2.
+ * additional 200 ms for the mouse move to finish before moving to Tick 2.
  *
  * | Device   | Tick 1                | Tick 2         |
  * | -------- | --------------------- | -------------- |
@@ -554,13 +541,13 @@ Pointer.Type = {
  *     when translating actions to the legacy protocol.
  *
  * 6.  For W3C actions, move offsets relative to a
- *     {@linkplain ./webdriver.WebElement WebElement} are interpretted relative
+ *     {@linkplain ./webdriver.WebElement WebElement} are interpreted relative
  *     to the center of an element's _first_ [client rect] in the viewport. For
  *     legacy actions, element offsets are relative to the top-left corner of
  *     the element's [bounding client rect]. When translating actions to the
  *     legacy protocol in bridge mode, an extra command must be inserted to
  *     translate move offsets from one frame of reference to the other. This
- *     extra command conributes to the overall latency issue outlined in
+ *     extra command contributes to the overall latency issue outlined in
  *     point 1.
  *
  * [client rect]: https://developer.mozilla.org/en-US/docs/Web/API/Element/getClientRects
@@ -577,43 +564,43 @@ class Actions {
    *          bridge: (boolean|undefined)}} options Options for this action
    *     sequence (see class description for details).
    */
-  constructor(executor, {async = false, bridge = false} = {}) {
+  constructor(executor, { async = false, bridge = false } = {}) {
     if (async && bridge) {
       throw new InvalidArgumentError(
-          'Async sequences not supported with bridge mode');
+        'Async sequences not supported with bridge mode'
+      )
     }
 
     /** @private @const */
-    this.executor_ = executor;
+    this.executor_ = executor
 
     /** @private @const */
-    this.sync_ = !async;
+    this.sync_ = !async
 
     /** @private @const */
-    this.bridge_ = !!bridge;
+    this.bridge_ = !!bridge
 
     /** @private @const */
-    this.keyboard_ = new Keyboard('default keyboard');
+    this.keyboard_ = new Keyboard('default keyboard')
 
     /** @private @const */
-    this.mouse_ = new Pointer('default mouse', Pointer.Type.MOUSE);
+    this.mouse_ = new Pointer('default mouse', Pointer.Type.MOUSE)
 
     /** @private @const {!Map<!Device, !Array<!Action>>} */
     this.sequences_ = new Map([
       [this.keyboard_, []],
       [this.mouse_, []],
-    ]);
+    ])
   }
 
-
   /** @return {!Keyboard} the keyboard device handle. */
   keyboard() {
-    return this.keyboard_;
+    return this.keyboard_
   }
 
   /** @return {!Pointer} the mouse pointer device handle. */
   mouse() {
-    return this.mouse_;
+    return this.mouse_
   }
 
   /**
@@ -622,12 +609,12 @@ class Actions {
    * @private
    */
   sequence_(device) {
-    let sequence = this.sequences_.get(device);
+    let sequence = this.sequences_.get(device)
     if (!sequence) {
-      sequence = [];
-      this.sequences_.set(device, sequence);
+      sequence = []
+      this.sequences_.set(device, sequence)
     }
-    return sequence;
+    return sequence
   }
 
   /**
@@ -641,8 +628,8 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   insert(device, ...actions) {
-    this.sequence_(device).push(...actions);
-    return this.sync_ ? this.synchronize() : this;
+    this.sequence_(device).push(...actions)
+    return this.sync_ ? this.synchronize() : this
   }
 
   /**
@@ -657,30 +644,30 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   synchronize(...devices) {
-    let sequences;
-    let max = 0;
+    let sequences
+    let max = 0
     if (devices.length === 0) {
       for (const s of this.sequences_.values()) {
-        max = Math.max(max, s.length);
+        max = Math.max(max, s.length)
       }
-      sequences = this.sequences_.values();
+      sequences = this.sequences_.values()
     } else {
-      sequences = [];
+      sequences = []
       for (const device of devices) {
-        const seq = this.sequence_(device);
-        max = Math.max(max, seq.length);
-        sequences.push(seq);
+        const seq = this.sequence_(device)
+        max = Math.max(max, seq.length)
+        sequences.push(seq)
       }
     }
 
-    const pause = {type: Action.Type.PAUSE, duration: 0};
+    const pause = { type: Action.Type.PAUSE, duration: 0 }
     for (const seq of sequences) {
       while (seq.length < max) {
-        seq.push(pause);
+        seq.push(pause)
       }
     }
 
-    return this;
+    return this
   }
 
   /**
@@ -692,7 +679,7 @@ class Actions {
    * If no devices are specified, a pause action will be created (using the same
    * duration) for every device.
    *
-   * When device synchroniation is enabled (the default for new {@link Actions}
+   * When device synchronization is enabled (the default for new {@link Actions}
    * objects), there is no need to specify devices as pausing one automatically
    * pauses the others for the same duration. In other words, the following are
    * all equivalent:
@@ -735,21 +722,21 @@ class Actions {
    */
   pause(duration, ...devices) {
     if (duration instanceof Device) {
-      devices.push(duration);
-      duration = 0;
+      devices.push(duration)
+      duration = 0
     } else if (!duration) {
-      duration = 0;
+      duration = 0
     }
 
-    const action = {type: Action.Type.PAUSE, duration};
+    const action = { type: Action.Type.PAUSE, duration }
 
     // NB: need a properly typed variable for type checking.
     /** @type {!Iterable<!Device>} */
-    const iterable = devices.length === 0 ? this.sequences_.keys() : devices;
+    const iterable = devices.length === 0 ? this.sequences_.keys() : devices
     for (const device of iterable) {
-      this.sequence_(device).push(action);
+      this.sequence_(device).push(action)
     }
-    return this.sync_ ? this.synchronize() : this;
+    return this.sync_ ? this.synchronize() : this
   }
 
   /**
@@ -761,7 +748,7 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   keyDown(key) {
-    return this.insert(this.keyboard_, this.keyboard_.keyDown(key));
+    return this.insert(this.keyboard_, this.keyboard_.keyDown(key))
   }
 
   /**
@@ -773,7 +760,7 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   keyUp(key) {
-    return this.insert(this.keyboard_, this.keyboard_.keyUp(key));
+    return this.insert(this.keyboard_, this.keyboard_.keyUp(key))
   }
 
   /**
@@ -788,21 +775,20 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   sendKeys(...keys) {
-    const actions = [];
+    const actions = []
     for (const key of keys) {
       if (typeof key === 'string') {
         for (const symbol of key) {
           actions.push(
-              this.keyboard_.keyDown(symbol),
-              this.keyboard_.keyUp(symbol));
+            this.keyboard_.keyDown(symbol),
+            this.keyboard_.keyUp(symbol)
+          )
         }
       } else {
-        actions.push(
-            this.keyboard_.keyDown(key),
-            this.keyboard_.keyUp(key));
+        actions.push(this.keyboard_.keyDown(key), this.keyboard_.keyUp(key))
       }
     }
-    return this.insert(this.keyboard_, ...actions);
+    return this.insert(this.keyboard_, ...actions)
   }
 
   /**
@@ -812,7 +798,7 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   press(button = Button.LEFT) {
-    return this.insert(this.mouse_, this.mouse_.press(button));
+    return this.insert(this.mouse_, this.mouse_.press(button))
   }
 
   /**
@@ -823,7 +809,7 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   release(button = Button.LEFT) {
-    return this.insert(this.mouse_, this.mouse_.release(button));
+    return this.insert(this.mouse_, this.mouse_.release(button))
   }
 
   /**
@@ -847,9 +833,11 @@ class Actions {
    *     corner of the viewport over 100ms.
    * @return {!Actions} a self reference.
    */
-  move({x = 0, y = 0, duration = 100, origin = Origin.VIEWPORT} = {}) {
+  move({ x = 0, y = 0, duration = 100, origin = Origin.VIEWPORT } = {}) {
     return this.insert(
-        this.mouse_, this.mouse_.move({x, y, duration, origin}));
+      this.mouse_,
+      this.mouse_.move({ x, y, duration, origin })
+    )
   }
 
   /**
@@ -862,9 +850,9 @@ class Actions {
    */
   click(element) {
     if (element) {
-      this.move({origin: element});
+      this.move({ origin: element })
     }
-    return this.press().release();
+    return this.press().release()
   }
 
   /**
@@ -877,9 +865,9 @@ class Actions {
    */
   contextClick(element) {
     if (element) {
-      this.move({origin: element});
+      this.move({ origin: element })
     }
-    return this.press(Button.RIGHT).release(Button.RIGHT);
+    return this.press(Button.RIGHT).release(Button.RIGHT)
   }
 
   /**
@@ -891,7 +879,7 @@ class Actions {
    * @return {!Actions} a self reference.
    */
   doubleClick(element) {
-    return this.click(element).press().release();
+    return this.click(element).press().release()
   }
 
   /**
@@ -913,20 +901,23 @@ class Actions {
    */
   dragAndDrop(from, to) {
     // Do not require up top to avoid a cycle that breaks static analysis.
-    const {WebElement} = require('./webdriver');
-    if (!(to instanceof WebElement)
-        && (!to || typeof to.x !== 'number' || typeof to.y !== 'number')) {
+    const { WebElement } = require('./webdriver')
+    if (
+      !(to instanceof WebElement) &&
+      (!to || typeof to.x !== 'number' || typeof to.y !== 'number')
+    ) {
       throw new InvalidArgumentError(
-          'Invalid drag target; must specify a WebElement or {x, y} offset');
+        'Invalid drag target; must specify a WebElement or {x, y} offset'
+      )
     }
 
-    this.move({origin: from}).press();
+    this.move({ origin: from }).press()
     if (to instanceof WebElement) {
-      this.move({origin: to});
+      this.move({ origin: to })
     } else {
-      this.move({x: to.x, y: to.y, origin: Origin.POINTER});
+      this.move({ x: to.x, y: to.y, origin: Origin.POINTER })
     }
-    return this.release();
+    return this.release()
   }
 
   /**
@@ -937,9 +928,9 @@ class Actions {
    */
   clear() {
     for (const s of this.sequences_.values()) {
-      s.length = 0;
+      s.length = 0
     }
-    return this.executor_.execute(new Command(Name.CLEAR_ACTIONS));
+    return this.executor_.execute(new Command(Name.CLEAR_ACTIONS))
   }
 
   /**
@@ -949,45 +940,47 @@ class Actions {
    *     been completed.
    */
   async perform() {
-    const _actions = [];
+    const _actions = []
     this.sequences_.forEach((actions, device) => {
       if (!isIdle(actions)) {
-        actions = actions.concat();  // Defensive copy.
-        _actions.push(Object.assign({actions}, device.toJSON()));
+        actions = actions.concat() // Defensive copy.
+        _actions.push(Object.assign({ actions }, device.toJSON()))
       }
-    });
+    })
 
     if (_actions.length === 0) {
-      return Promise.resolve();
+      return Promise.resolve()
     }
 
     try {
       await this.executor_.execute(
-          new Command(Name.ACTIONS).setParameter('actions', _actions));
+        new Command(Name.ACTIONS).setParameter('actions', _actions)
+      )
     } catch (ex) {
-      if (this.bridge_
-          && (ex instanceof UnknownCommandError
-              || ex instanceof UnsupportedOperationError)) {
-        return executeLegacy(this.executor_, this.sequences_);
+      if (
+        this.bridge_ &&
+        (ex instanceof UnknownCommandError ||
+          ex instanceof UnsupportedOperationError)
+      ) {
+        return executeLegacy(this.executor_, this.sequences_)
       }
-      throw ex;
+      throw ex
     }
   }
 }
 
-
 /**
  * @param {!Array<!Action>} actions
  * @return {boolean}
  */
 function isIdle(actions) {
-  return actions.length === 0
-      || actions.every(a => a.type === Action.Type.PAUSE && !a.duration);
+  return (
+    actions.length === 0 ||
+    actions.every((a) => a.type === Action.Type.PAUSE && !a.duration)
+  )
 }
 
-
-const MODIFIER_KEYS = new Set([Key.ALT, Key.CONTROL, Key.SHIFT, Key.COMMAND]);
-
+const MODIFIER_KEYS = new Set([Key.ALT, Key.CONTROL, Key.SHIFT, Key.COMMAND])
 
 /**
  * @param {!Executor} executor
@@ -996,24 +989,27 @@ const MODIFIER_KEYS = new Set([Key.ALT, Key.CONTROL, Key.SHIFT, Key.COMMAND]);
  * @suppress {deprecated} Ignore warnings about using LegacyActionSequence.
  */
 async function executeLegacy(executor, sequences) {
-  let maxLength = 0;
-  sequences.forEach(seq => maxLength = Math.max(maxLength, seq.length));
+  let maxLength = 0
+  sequences.forEach((seq) => (maxLength = Math.max(maxLength, seq.length)))
 
-  const actions = [];
+  const actions = []
   for (let i = 0; i < maxLength; i++) {
-    let next;
+    let next
     for (const device of sequences.keys()) {
-      const seq = sequences.get(device);
+      const seq = sequences.get(device)
 
-      if (device instanceof Pointer
-          && device.pointerType_ !== Pointer.Type.MOUSE) {
+      if (
+        device instanceof Pointer &&
+        device.pointerType_ !== Pointer.Type.MOUSE
+      ) {
         throw new UnsupportedOperationError(
-            `${device.pointerType_} pointer not supported in bridge mode`);
+          `${device.pointerType_} pointer not supported in bridge mode`
+        )
       }
 
-      const action = seq[i];
+      const action = seq[i]
       if (!action || (action.type === Action.Type.PAUSE && !action.duration)) {
-        continue;
+        continue
       }
 
       // -  If we've already found an action for this tick:
@@ -1024,16 +1020,17 @@ async function executeLegacy(executor, sequences) {
       if (next) {
         if (next.type === Action.Type.PAUSE) {
           if (action.type === Action.Type.PAUSE) {
-            next = next.duration > action.duration ? next : action;
+            next = next.duration > action.duration ? next : action
           } else {
-            next = action;
+            next = action
           }
         } else if (action.type !== Action.Type.PAUSE) {
           throw new UnsupportedOperationError(
-              'parallel actions not supported in bridge mode');
+            'parallel actions not supported in bridge mode'
+          )
         }
       } else {
-        next = action;
+        next = action
       }
 
       if (action.type === Action.Type.KEY_DOWN) {
@@ -1041,127 +1038,155 @@ async function executeLegacy(executor, sequences) {
         // must be a keyup for the same key, otherwise it cannot be translated
         // to the legacy action API.
         if (!MODIFIER_KEYS.has(action.value)) {
-          const nextAction = seq[i + 1];
-          if (!nextAction
-              || nextAction.type !== Action.Type.KEY_UP
-              || nextAction.value !== action.value) {
+          const nextAction = seq[i + 1]
+          if (
+            !nextAction ||
+            nextAction.type !== Action.Type.KEY_UP ||
+            nextAction.value !== action.value
+          ) {
             throw new UnsupportedOperationError(
-                `in bridge mode, keydown for <${action.value}> must be followed`
-                    + ' by a keyup for the same key');
+              `in bridge mode, keydown for <${action.value}> must be followed` +
+                ' by a keyup for the same key'
+            )
           }
         }
-      } else if (action.type === Action.Type.KEY_UP
-          && !MODIFIER_KEYS.has(action.value)) {
-        next = null;
+      } else if (
+        action.type === Action.Type.KEY_UP &&
+        !MODIFIER_KEYS.has(action.value)
+      ) {
+        next = null
       }
     }
 
     if (next) {
-      actions.push(next);
+      actions.push(next)
     }
   }
 
   for (let i = 0; i < actions.length; i++) {
-    const action = actions[i];
+    const action = actions[i]
     switch (action.type) {
-      case Action.Type.PAUSE:
-        await promise.delayed(action.duration || 0);
-        break;
-      case Action.Type.KEY_DOWN:
-        const keys = [action.value];
+      case Action.Type.PAUSE: {
+        await promise.delayed(action.duration || 0)
+        break
+      }
+      case Action.Type.KEY_DOWN: {
+        const keys = [action.value]
         if (!MODIFIER_KEYS.has(action.value)) {
+          // eslint-disable-next-line no-inner-declarations
           function nextIsKeyDown() {
-            const next = actions[i + 1];
-            return !!next
-                && next.type === Action.Type.KEY_DOWN
-                && !MODIFIER_KEYS.has(next.value);
+            const next = actions[i + 1]
+            return (
+              !!next &&
+              next.type === Action.Type.KEY_DOWN &&
+              !MODIFIER_KEYS.has(next.value)
+            )
           }
           for (; nextIsKeyDown(); i++) {
-            keys.push(actions[i + 1].value);
+            keys.push(actions[i + 1].value)
           }
         }
         await executor.execute(
-            new Command(Name.LEGACY_ACTION_SEND_KEYS)
-                .setParameter('value', keys));
-        break;
-      case Action.Type.KEY_UP:
+          new Command(Name.LEGACY_ACTION_SEND_KEYS).setParameter('value', keys)
+        )
+        break
+      }
+      case Action.Type.KEY_UP: {
         await executor.execute(
-            new Command(Name.LEGACY_ACTION_SEND_KEYS)
-                .setParameter('value', [action.value]));
-        break;
+          new Command(Name.LEGACY_ACTION_SEND_KEYS).setParameter('value', [
+            action.value,
+          ])
+        )
+        break
+      }
       case Action.Type.POINTER_DOWN: {
+        // eslint-disable-next-line no-inner-declarations
         function isClick(startAt) {
-          const first = actions[startAt];
-          const second = actions[startAt + 1];
-          return !!first && !!second
-              && first.type === Action.Type.POINTER_DOWN
-              && second.type === Action.Type.POINTER_UP
-              && first.button === second.button;
+          const first = actions[startAt]
+          const second = actions[startAt + 1]
+          return (
+            !!first &&
+            !!second &&
+            first.type === Action.Type.POINTER_DOWN &&
+            second.type === Action.Type.POINTER_UP &&
+            first.button === second.button
+          )
         }
 
+        // eslint-disable-next-line no-inner-declarations
         function isDoubleClick(startAt) {
-          return isClick(startAt)
-              && isClick(startAt + 2)
-              && actions[startAt].button === actions[startAt = 2].button;
+          return (
+            isClick(startAt) &&
+            isClick(startAt + 2) &&
+            actions[startAt].button === actions[(startAt = 2)].button
+          )
         }
 
-        let cmd;
+        let cmd
         if (isDoubleClick(i)) {
-          i += 3;  // Consume the pointer up/down/up.
-          cmd = Name.LEGACY_ACTION_DOUBLE_CLICK;
-        } else  if (isClick(i)) {
-          i++;  // Consume the pointer-up.
-          cmd = Name.LEGACY_ACTION_CLICK;
+          i += 3 // Consume the pointer up/down/up.
+          cmd = Name.LEGACY_ACTION_DOUBLE_CLICK
+        } else if (isClick(i)) {
+          i++ // Consume the pointer-up.
+          cmd = Name.LEGACY_ACTION_CLICK
         } else {
-          cmd = Name.LEGACY_ACTION_MOUSE_DOWN;
+          cmd = Name.LEGACY_ACTION_MOUSE_DOWN
         }
         await executor.execute(
-            new Command(cmd).setParameter('button', action.button));
-        break;
+          new Command(cmd).setParameter('button', action.button)
+        )
+        break
       }
-      case Action.Type.POINTER_UP:
+      case Action.Type.POINTER_UP: {
         await executor.execute(
-            new Command(Name.LEGACY_ACTION_MOUSE_UP)
-                .setParameter('button', action.button));
-        break;
-      case Action.Type.POINTER_MOVE:
+          new Command(Name.LEGACY_ACTION_MOUSE_UP).setParameter(
+            'button',
+            action.button
+          )
+        )
+        break
+      }
+      case Action.Type.POINTER_MOVE: {
         if (action.origin === Origin.VIEWPORT) {
           throw new UnsupportedOperationError(
-              `pointer movements relative to ${Origin.VIEWPORT} are not`
-                  + ' supported in bridge mode');
-
+            `pointer movements relative to ${Origin.VIEWPORT} are not` +
+              ' supported in bridge mode'
+          )
         }
 
-        let x = action.x;
-        let y = action.y;
-        const cmd = new Command(Name.LEGACY_ACTION_MOUSE_MOVE);
+        let x = action.x
+        let y = action.y
+        const cmd = new Command(Name.LEGACY_ACTION_MOUSE_MOVE)
         if (action.origin && action.origin !== Origin.POINTER) {
-          const el = /** @type {!./webdriver.WebElement} */(action.origin);
+          const el = /** @type {!./webdriver.WebElement} */ (action.origin)
 
           // Need to translate frame of reference from center of element's first
           // client rect to the top-left of its bounding client rect. See:
           // https://w3c.github.io/webdriver/webdriver-spec.html#dfn-center-point
           let diff = await executor.execute(
-              new Command(Name.EXECUTE_SCRIPT)
-                  .setParameter('script', INTERNAL_COMPUTE_OFFSET_SCRIPT)
-                  .setParameter('args', [el]));
-          x += diff[0];
-          y += diff[1];
-
-          const id = await el.getId();
-          cmd.setParameter('element', id);
+            new Command(Name.EXECUTE_SCRIPT)
+              .setParameter('script', INTERNAL_COMPUTE_OFFSET_SCRIPT)
+              .setParameter('args', [el])
+          )
+          x += diff[0]
+          y += diff[1]
+
+          const id = await el.getId()
+          cmd.setParameter('element', id)
         }
-        cmd.setParameter('xoffset', x).setParameter('yoffset', y);
-        await executor.execute(cmd);
-        break;
-      default:
+        cmd.setParameter('xoffset', x).setParameter('yoffset', y)
+        await executor.execute(cmd)
+        break
+      }
+      default: {
         throw new UnsupportedOperationError(
-            `${action.type} actions not supported in bridge mode`);
+          `${action.type} actions not supported in bridge mode`
+        )
+      }
     }
   }
 }
 
-
 /**
  * Script used to compute the offset from the center of a DOM element's first
  * client rect from the top-left corner of the element's bounding client rect.
@@ -1187,14 +1212,12 @@ function computeOffset(el) {
   var bbox = el.getBoundingClientRect();
   return [x - bbox.left, y - bbox.top];
 }
-return computeOffset(arguments[0]);`;
-
+return computeOffset(arguments[0]);`
 
 // PUBLIC API
 
-
 module.exports = {
-  Action,       // For documentation only.
+  Action, // For documentation only.
   Actions,
   Button,
   Device,
@@ -1204,4 +1227,4 @@ module.exports = {
   Origin,
   Pointer,
   INTERNAL_COMPUTE_OFFSET_SCRIPT,
-};
+}