@testim/testim-cli 3.274.0 → 3.278.0

package/player/services/tabServiceMock.js

@@ -114,6 +114,7 @@ class TabService {
     }
 
     getMainTabUtils(sessionId) {
+        return {};
     }
 
     removeTabInfo(sessionId, tabId) {

package/player/stepActions/dropFileStepAction.js

@@ -3,7 +3,6 @@
 const StepAction = require('./stepAction');
 const logger = require('../../commons/logger').getLogger('drop-file-step-action');
 const downloadFileAndFireDropEvent = require('./scripts/dropEvent');
-const createDropEventLegacy = require('./scripts/createDropEventLegacy');
 const { codeSnippets, utils } = require('../../commons/getSessionPlayerRequire');
 const featureFlagService = require('../../commons/featureFlags');
 
@@ -21,7 +20,7 @@ class DropFileStepAction extends StepAction {
 
         const dropFileCode = `
         var getLocatedElement = ${codeSnippets.getLocatedElementCode};
-        var createDropEvent = ${(codeSnippets.createDropEvent ? codeSnippets.createDropEvent : createDropEventLegacy).toString()};
+        var createDropEvent = ${codeSnippets.createDropEvent.toString()};
         var downloadFileAndFireDropEvent = ${downloadFileAndFireDropEvent.toString()};
         return downloadFileAndFireDropEvent.apply(null, arguments)
     `;

package/player/stepActions/scripts/dispatchEvents.js

@@ -1,56 +1,54 @@
-"use strict";
+'use strict';
 
-var dispatchEvents = function (eventData, done) {
+const dispatchEvents = function (eventData, done) {
     function getParents(el) {
         return el ? [el].concat(getParents(el.parentNode)) : [];
     }
 
     function handleReactSelectFocusQuirk(context, event) {
         function focusReactSelect(element) {
-
-            function getReactSelectRoot(element) {
-                return getParents(element).filter(function (el) {
-                    return Array.apply(null, el.classList || []).indexOf("Select-control") !== -1;
-                })[0];
+            function getReactSelectRoot(_element) {
+                // eslint-disable-next-line prefer-spread
+                return getParents(_element).find((el) => Array.apply(null, el.classList || []).includes('Select-control'));
             }
 
-            function getReactSelectInput(element) {
-                var root = getReactSelectRoot(element);
-                return root ? root.querySelector("INPUT") : null;
+            function getReactSelectInput(_element) {
+                const root = getReactSelectRoot(_element);
+                return root ? root.querySelector('INPUT') : null;
             }
 
-            var reactSelectInput = getReactSelectInput(element);
+            const reactSelectInput = getReactSelectInput(element);
             if (reactSelectInput) {
                 reactSelectInput.focus();
             }
         }
 
-        var isReactSelectElement = context.quirks && context.quirks.isReactSelect;
-        if (event.type === "mousedown" && isReactSelectElement) {
+        const isReactSelectElement = context.quirks?.isReactSelect;
+        if (event.type === 'mousedown' && isReactSelectElement) {
             focusReactSelect(context.element);
         }
     }
 
     function handleCKEditorQuirk(context, event) {
-        var isCKEditorFrame = context.quirks && context.quirks.isCKEditorFrame;
-        if (event.type === "click" && isCKEditorFrame) {
+        const isCKEditorFrame = context.quirks?.isCKEditorFrame;
+        if (event.type === 'click' && isCKEditorFrame) {
             document.body.focus();
         }
     }
 
     function dispatchMouseOver() {
-        var event = document.createEvent('Events');
+        const event = document.createEvent('Events');
         event.initEvent('mouseover', true, true);
         context.element.dispatchEvent(event);
     }
 
     function dispatchMouseMove() {
-        var userEvent = {
+        const userEvent = {
             event: 'mousemove',
             modifiers: {},
-            button: 0
+            button: 0,
         };
-        var event = createMouseEvent(userEvent);
+        const event = createMouseEvent(userEvent);
         context.element.dispatchEvent(event);
     }
 
@@ -59,20 +57,20 @@ var dispatchEvents = function (eventData, done) {
             return (point > start) && (point < end);
         }
 
-        var pointerPosition = userEvent.pointerPosition || {};
-        var rect = element.getBoundingClientRect();
-        var clientX = pointerPosition.originX && isWithinBounds(rect.left, rect.left + rect.width, pointerPosition.originX) ? pointerPosition.originX : rect.left + (rect.width / 2);
-        var clientY = pointerPosition.originY && isWithinBounds(rect.top, rect.top + rect.height, pointerPosition.originY) ? pointerPosition.originY : rect.top + (rect.height / 2);
-        return {x: clientX, y: clientY};
+        const pointerPosition = userEvent.pointerPosition || {};
+        const rect = element.getBoundingClientRect();
+        const clientX = pointerPosition.originX && isWithinBounds(rect.left, rect.left + rect.width, pointerPosition.originX) ? pointerPosition.originX : rect.left + (rect.width / 2);
+        const clientY = pointerPosition.originY && isWithinBounds(rect.top, rect.top + rect.height, pointerPosition.originY) ? pointerPosition.originY : rect.top + (rect.height / 2);
+        return { x: clientX, y: clientY };
     }
 
     function createMouseEvent(userEvent) {
-        var position = getEventPosition(userEvent, context.element);
-        var modifiers = userEvent.modifiers || context.modifiers || {};
-        var button = userEvent.button || context.button || 0;
-        var eventType = userEvent.event;
+        const position = getEventPosition(userEvent, context.element);
+        const modifiers = userEvent.modifiers || context.modifiers || {};
+        const button = userEvent.button || context.button || 0;
+        const eventType = userEvent.event;
 
-        var event = document.createEvent("MouseEvents");
+        const event = document.createEvent('MouseEvents');
         event.initMouseEvent(
             eventType,
             true, /* bubbles */
@@ -94,12 +92,12 @@ var dispatchEvents = function (eventData, done) {
     }
 
     function createPointerEvent(userEvent) {
-        var position = getEventPosition(userEvent, context.element);
-        var modifiers = userEvent.modifiers || context.modifiers || {};
-        var eventType = userEvent.event;
+        const position = getEventPosition(userEvent, context.element);
+        const modifiers = userEvent.modifiers || context.modifiers || {};
+        const eventType = userEvent.event;
 
         if (!window.PointerEvent) {
-            return;
+            return undefined;
         }
         return new window.PointerEvent(eventType, {
             screenX: 0,
@@ -113,13 +111,13 @@ var dispatchEvents = function (eventData, done) {
             bubbles: true,
             cancelable: true,
             composed: true,
-            pointerType: "mouse",
+            pointerType: 'mouse',
             isPrimary: true,
         });
     }
 
     function createFocusEvent(userEvent) {
-        var event = document.createEvent("FocusEvent");
+        const event = document.createEvent('FocusEvent');
         // TODO we want to use new Event, but mootools (used by zuora which is used by jfrog)
         //  overrides window.Event and throws an error
         event.initEvent(userEvent.event, true, false);
@@ -127,76 +125,74 @@ var dispatchEvents = function (eventData, done) {
     }
 
     function createEvent(userEvent) {
-        var eventType = userEvent.event;
-        var event = document.createEvent("HTMLEvents");
+        const eventType = userEvent.event;
+        const event = document.createEvent('HTMLEvents');
         event.initEvent(eventType, true, false);
         return event;
     }
 
-    function dispatchSyncEvent(event) {
-        console.log("dispatching: " + event.type);
-        console.log(event);
-
-        context.element.dispatchEvent(event);
-        handleReactSelectFocusQuirk(context, event);
-        handleCKEditorQuirk(context, event);
-    }
-
     function dispatchSyncEventSequence() {
         context.events
-            .map(function (userEvent) {
+            .map((userEvent) => {
                 try {
-                    if(MOUSE_EVENTS.includes(userEvent.event)) {
+                    if (MOUSE_EVENTS.includes(userEvent.event)) {
                         return createMouseEvent(userEvent);
-                    } else if (POINTER_EVENTS.includes(userEvent.event)) {
+                    } if (POINTER_EVENTS.includes(userEvent.event)) {
                         return createPointerEvent(userEvent);
-                    } else if(FOCUS_EVENTS.includes(userEvent.event)) {
+                    } if (FOCUS_EVENTS.includes(userEvent.event)) {
                         return createFocusEvent(userEvent);
-                    } else {
-                        return createEvent(userEvent);
                     }
+                    return createEvent(userEvent);
                 } catch (e) {
-                    // pointer events not supported in ie11
-                    return;
+                    // pointer events not supported :shrug:
+                    return undefined;
                 }
             })
             .filter(Boolean)
-            .forEach(function (event) {
-                dispatchSyncEvent(event);
+            .forEach((event) => {
+                // eslint-disable-next-line no-console
+                console.log(`dispatching: ${event.type}`);
+                // eslint-disable-next-line no-console
+                console.log(event);
+
+                context.element.dispatchEvent(event);
+                handleReactSelectFocusQuirk(context, event);
+                handleCKEditorQuirk(context, event);
             });
 
         if (window.__unloadNavigator) {
-            window.removeEventListener("unload", window.__unloadNavigator);
+            window.removeEventListener('unload', window.__unloadNavigator);
         }
     }
 
     function findEffectiveActiveElement() {
-        var activeElement = document.activeElement;
-        while (activeElement.shadowRoot && activeElement.shadowRoot.activeElement) {
+        let activeElement = document.activeElement;
+        while (activeElement.shadowRoot?.activeElement) {
             activeElement = activeElement.shadowRoot.activeElement;
         }
         return activeElement;
     }
 
     function handleFocus() {
-        var oldActiveElement = findEffectiveActiveElement();
-        var quirks = context.quirks;
-        var isReactSelectElement = quirks && quirks.isReactSelect;
-        var isCKEditorFrame = quirks && quirks.isCKEditorFrame;
+        const oldActiveElement = findEffectiveActiveElement();
+        const quirks = context.quirks;
+        const isReactSelectElement = quirks?.isReactSelect;
+        const isCKEditorFrame = quirks?.isCKEditorFrame;
         if (!isReactSelectElement && !isCKEditorFrame) {
+            // eslint-disable-next-line no-undef
             dispatchFocus(eventData.elementToFocusLocatedElement, oldActiveElement);
         }
     }
 
     function handleSelect() {
-        if(context.element.tagName !== OPTION_TAG_NAME) {
+        if (context.element.tagName !== OPTION_TAG_NAME) {
             return;
         }
 
-        var selectEl;
-        if(context.element.parentElement.tagName === SELECT_TAG_NAME) {
+        let selectEl;
+        if (context.element.parentElement.tagName === SELECT_TAG_NAME) {
             selectEl = context.element.parentElement;
-        } else if(context.element.parentElement.parentElement.tagName === SELECT_TAG_NAME) {
+        } else if (context.element.parentElement.parentElement.tagName === SELECT_TAG_NAME) {
             selectEl = context.element.parentElement.parentElement;
         }
         selectEl.blur();
@@ -206,13 +202,13 @@ var dispatchEvents = function (eventData, done) {
 
     function fulfill(success, status, result) {
         result = result || {};
-        var status = {
-            success: success,
-            status: status,
-            result: result,
+        status = {
+            success,
+            status,
+            result,
         };
 
-        if(isDoneFnSupplied) {
+        if (isDoneFnSupplied) {
             return done(status);
         }
 
@@ -227,35 +223,50 @@ var dispatchEvents = function (eventData, done) {
         return fulfill(false, 'failed', result);
     }
 
-    var OPTION_TAG_NAME = "OPTION";
-    var SELECT_TAG_NAME = "SELECT";
-
-    var MOUSE_EVENTS = ["auxclick", "click", "contextmenu", "dblclick", "mousedown", "mouseenter", "mouseleave", "mousemove", "mouseover", "mouseout", "mouseup", "pointerlockchange", "pointerlockerror", "select", "wheel",];
-    var POINTER_EVENTS = ["pointerover", "pointerenter", "pointerdown", "pointermove", "pointerup", "pointercancel", "pointerout", "pointerleave", "gotpointercapture", "lostpointercapture",];
-    var FOCUS_EVENTS = ["focus", "blur", "focusin", "focusout",];
-    var KEYBOARD_EVENTS = ["keydown", "keypress", "keyup",]; // future use
-
-    var isEventConstructorSupported = typeof Event === 'function';
-    var isDoneFnSupplied = typeof done !== 'undefined';
+    const OPTION_TAG_NAME = 'OPTION';
+    const SELECT_TAG_NAME = 'SELECT';
+
+    const MOUSE_EVENTS = [
+        'auxclick',
+        'click',
+        'contextmenu',
+        'dblclick',
+        'mousedown',
+        'mouseenter',
+        'mouseleave',
+        'mousemove',
+        'mouseover',
+        'mouseout',
+        'mouseup',
+        'pointerlockchange',
+        'pointerlockerror',
+        'select',
+        'wheel',
+    ];
+    const POINTER_EVENTS = ['pointerover', 'pointerenter', 'pointerdown', 'pointermove', 'pointerup', 'pointercancel', 'pointerout', 'pointerleave', 'gotpointercapture', 'lostpointercapture'];
+    const FOCUS_EVENTS = ['focus', 'blur', 'focusin', 'focusout'];
+
+    const isDoneFnSupplied = typeof done !== 'undefined';
 
     window.__unloadNavigator = resolve;
-    window.addEventListener("unload", window.__unloadNavigator);
+    window.addEventListener('unload', window.__unloadNavigator);
 
-    var element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
+    // eslint-disable-next-line no-undef
+    const element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
     if (!element) {
-        return reject("element not found");
+        return reject('element not found');
     }
 
-    var context = {
-        element: element,
+    const context = {
+        element,
         events: eventData.events,
         quirks: eventData.quirks,
         modifiers: eventData.modifiers,
     };
 
     try {
-        var doMousePreparation = eventData.withMousePreparation ? eventData.withMousePreparation : true;
-        if(doMousePreparation) {
+        const doMousePreparation = eventData.withMousePreparation ? eventData.withMousePreparation : true;
+        if (doMousePreparation) {
             dispatchMouseOver();
             dispatchMouseMove();
         }

package/player/stepActions/scripts/doClick.js

@@ -2,42 +2,40 @@
 
 'use strict';
 
-var doClick = function (eventData, done) {
-    var eventConstructorSupported = typeof Event === 'function';
+const doClick = (eventData, done) => {
+    const eventConstructorSupported = typeof Event === 'function';
 
     window.__unloadNavigator = resolve;
 
-    window.addEventListener("unload", window.__unloadNavigator);
+    window.addEventListener('unload', window.__unloadNavigator);
 
     function handleReactSelectFocusQuirk(context, event) {
         function focusReactSelect(element) {
-
-            function getReactSelectRoot(element) {
-                return getParents(element).filter(function (el) {
-                    return Array.apply(null, el.classList || []).indexOf("Select-control") !== -1;
-                })[0];
+            function getReactSelectRoot(_element) {
+                // eslint-disable-next-line prefer-spread
+                return getParents(_element).find((el) => Array.apply(null, el.classList || []).includes('Select-control'));
             }
 
-            function getReactSelectInput(element) {
-                var root = getReactSelectRoot(element);
-                return root ? root.querySelector("INPUT") : null;
+            function getReactSelectInput(_element) {
+                const root = getReactSelectRoot(_element);
+                return root ? root.querySelector('INPUT') : null;
             }
 
-            var reactSelectInput = getReactSelectInput(element);
+            const reactSelectInput = getReactSelectInput(element);
             if (reactSelectInput) {
                 reactSelectInput.focus();
             }
         }
 
-        var isReactSelectElement = context.quirks && context.quirks.isReactSelect;
-        if (event.type === "mousedown" && isReactSelectElement) {
+        const isReactSelectElement = context.quirks?.isReactSelect;
+        if (event.type === 'mousedown' && isReactSelectElement) {
             focusReactSelect(context.element);
         }
     }
 
     function handleCKEditorQuirk(context, event) {
-        var isCKEditorFrame = context.quirks && context.quirks.isCKEditorFrame;
-        if (event.type === "click" && isCKEditorFrame) {
+        const isCKEditorFrame = context.quirks?.isCKEditorFrame;
+        if (event.type === 'click' && isCKEditorFrame) {
             document.body.focus();
         }
     }
@@ -47,13 +45,13 @@ var doClick = function (eventData, done) {
     }
 
     function resolve(result) {
-        var status = {
+        const status = {
             status: 'done',
-            result: result,
-            success: true
+            result,
+            success: true,
         };
         if (context.isNonTextableElemnet) {
-            status.reason = "Set text on non input element";
+            status.reason = 'Set text on non input element';
         }
 
         done(status);
@@ -61,29 +59,29 @@ var doClick = function (eventData, done) {
 
     function reject(result) {
         result = result || {};
-        var status = {
+        const status = {
             status: 'failed',
-            result: result,
-            success: false
+            result,
+            success: false,
         };
 
         done(status);
     }
 
     function dispatchMouseOver(element) {
-        var event = eventConstructorSupported ? new Event("mouseover", { composed: true }) : document.createEvent('Events');
+        const event = eventConstructorSupported ? new Event('mouseover', { composed: true }) : document.createEvent('Events');
         event.initEvent('mouseover', true, true);
         element.dispatchEvent(event);
     }
 
     function dispatchMouseMove(element) {
-        var modifiers = {};
-        var rect = element.getBoundingClientRect();
-        var clientX = rect.left + (rect.width / 2);
-        var clientY = rect.top + (rect.height / 2);
-        var button = 0;
-        var eventType = 'mousemove';
-        var event = createMouseEvent(eventType, modifiers, clientX, clientY, button);
+        const modifiers = {};
+        const rect = element.getBoundingClientRect();
+        const clientX = rect.left + (rect.width / 2);
+        const clientY = rect.top + (rect.height / 2);
+        const button = 0;
+        const eventType = 'mousemove';
+        const event = createMouseEvent(eventType, modifiers, clientX, clientY, button);
         element.dispatchEvent(event);
     }
 
@@ -92,81 +90,75 @@ var doClick = function (eventData, done) {
             return (point > start) && (point < end);
         }
 
-        var pointerPosition = userEvent.pointerPosition || {};
-        var rect = element.getBoundingClientRect();
-        var clientX = pointerPosition.originX && isWithinBounds(rect.left, rect.left + rect.width, pointerPosition.originX) ? pointerPosition.originX : rect.left + (rect.width / 2);
-        var clientY = pointerPosition.originY && isWithinBounds(rect.top, rect.top + rect.height, pointerPosition.originY) ? pointerPosition.originY : rect.top + (rect.height / 2);
-        return {x: clientX, y: clientY};
+        const pointerPosition = userEvent.pointerPosition || {};
+        const rect = element.getBoundingClientRect();
+        const clientX = pointerPosition.originX && isWithinBounds(rect.left, rect.left + rect.width, pointerPosition.originX) ? pointerPosition.originX : rect.left + (rect.width / 2);
+        const clientY = pointerPosition.originY && isWithinBounds(rect.top, rect.top + rect.height, pointerPosition.originY) ? pointerPosition.originY : rect.top + (rect.height / 2);
+        return { x: clientX, y: clientY };
     }
 
     function getEventDictionary(modifiers, clientX, clientY) {
         return {
             screenX: 0,
             screenY: 0,
-            clientX: clientX,
-            clientY: clientY,
+            clientX,
+            clientY,
             ctrlKey: Boolean(modifiers.ctrl),
             altKey: Boolean(modifiers.alt),
             shiftKey: Boolean(modifiers.shift),
             metaKey: Boolean(modifiers.meta),
             bubbles: true,
             cancelable: true,
-            composed: true
+            composed: true,
         };
     }
 
     function createPointerEvent(eventType, modifiers, clientX, clientY) {
         if (!window.PointerEvent) {
-            return;
+            return undefined;
         }
-        var eventProperties = getEventDictionary(modifiers, clientX, clientY);
-        eventProperties.pointerType = "mouse";
+        const eventProperties = getEventDictionary(modifiers, clientX, clientY);
+        eventProperties.pointerType = 'mouse';
         eventProperties.isPrimary = true;
         return new window.PointerEvent(eventType, eventProperties);
     }
 
     function createMouseEvent(eventType, modifiers, clientX, clientY, button) {
-        var event = eventConstructorSupported ? new MouseEvent("click", { composed: true }) : document.createEvent("MouseEvents");
+        const event = eventConstructorSupported ? new MouseEvent('click', { composed: true }) : document.createEvent('MouseEvents');
         event.initMouseEvent(
             eventType,
-            true, /* bubbles */
-            true, /* cancelable */
-            document.defaultView, /* view */
-            1, /* detail */
-            0, /* screenX */
-            0, /* screenY */
-            clientX, /* clientX */
-            clientY, /* clientY */
-            Boolean(modifiers.ctrl), /* ctrl */
-            Boolean(modifiers.alt), /* alt */
-            Boolean(modifiers.shift), /* shift */
-            Boolean(modifiers.meta), /* meta */
-            button, /* button */
+            true,
+            true,
+            document.defaultView,
+            1,
+            0,
+            0,
+            clientX,
+            clientY,
+            Boolean(modifiers.ctrl),
+            Boolean(modifiers.alt),
+            Boolean(modifiers.shift),
+            Boolean(modifiers.meta),
+            button,
             document.body ? document.body.parentNode : document.documentElement);
         return event;
     }
 
     function getMouseEvent(userEvent, context) {
-        var pointerEvents = ["pointerup", "pointerdown", "pointermove"];
-        var modifiers = context.modifiers || {};
-        var pos = getEventPosition(userEvent, context.element);
-        var button = context.button || 0;
-        var eventType = userEvent.event;
-        if (pointerEvents.indexOf(eventType) > -1) {
+        const pointerEvents = ['pointerup', 'pointerdown', 'pointermove'];
+        const modifiers = context.modifiers || {};
+        const pos = getEventPosition(userEvent, context.element);
+        const button = context.button || 0;
+        const eventType = userEvent.event;
+        if (pointerEvents.includes(eventType)) {
             return createPointerEvent(eventType, modifiers, pos.x, pos.y);
         }
         return createMouseEvent(eventType, modifiers, pos.x, pos.y, button);
     }
 
-    function executeSyncEvent(event) {
-        context.element.dispatchEvent(event);
-        handleReactSelectFocusQuirk(context, event);
-        handleCKEditorQuirk(context, event);
-    }
-
     function findEffectiveActiveElement() {
-        var activeElement = document.activeElement;
-        while (activeElement.shadowRoot && activeElement.shadowRoot.activeElement) {
+        let activeElement = document.activeElement;
+        while (activeElement.shadowRoot?.activeElement) {
             activeElement = activeElement.shadowRoot.activeElement;
         }
         return activeElement;
@@ -174,49 +166,55 @@ var doClick = function (eventData, done) {
 
     function executeSynchronousEventSequence(context) {
         context.events
-            .map(function (userEvent) {
+            .map((userEvent) => {
                 try {
                     return getMouseEvent(userEvent, context);
                 } catch (e) {
-                    // pointer events not supported in ie11
-                    return;
+                    // pointer events not supported :shrug:
+                    return undefined;
                 }
             })
             .filter(Boolean)
-            .forEach(function (event) {executeSyncEvent(event);});
+            .forEach((event) => {
+                context.element.dispatchEvent(event);
+                handleReactSelectFocusQuirk(context, event);
+                handleCKEditorQuirk(context, event);
+            });
 
         if (window.__unloadNavigator) {
-            window.removeEventListener("unload", window.__unloadNavigator);
+            window.removeEventListener('unload', window.__unloadNavigator);
         }
     }
 
-    var element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
+    const element = eventData.isRoot ? document.documentElement : getLocatedElement(eventData.locatedElement);
+    // eslint-disable-next-line no-var
     var context = {
-        element: element,
+        element,
         events: eventData.events,
         quirks: eventData.quirks,
         modifiers: eventData.modifiers,
-        button: eventData.button
+        button: eventData.button,
     };
 
     if (!context.element) {
-        return reject("element not found");
+        reject('element not found');
+        return;
     }
 
     dispatchMouseOver(context.element);
     dispatchMouseMove(context.element);
     try {
         executeSynchronousEventSequence(context);
-        var oldActiveElement = findEffectiveActiveElement();
-        var quirks = context.quirks;
-        var isReactSelectElement = quirks && quirks.isReactSelect;
-        var isCKEditorFrame = quirks && quirks.isCKEditorFrame;
+        const oldActiveElement = findEffectiveActiveElement();
+        const quirks = context.quirks;
+        const isReactSelectElement = quirks?.isReactSelect;
+        const isCKEditorFrame = quirks?.isCKEditorFrame;
         if (!isReactSelectElement && !isCKEditorFrame) {
             dispatchFocus(eventData.elementToFocusLocatedElement, oldActiveElement);
         }
         resolve();
     } catch (e) {
-        return reject(e.toString());
+        reject(e.toString());
     }
 };