Innovenergy
/
Innovenergy_trunk
2
1
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity
Innovenergy_trunk/frontend/node_modules/testcafe/lib/client/automation/index.js

6725 lines
345 KiB
JavaScript
Raw Permalink Normal View History

adding untracked frontend and typescript files
2023-02-21 06:27:20 +00:00
window['%hammerhead%'].utils.removeInjectedScript();
// NOTE: We should have the capability to initialize scripts with different contexts.
// This is required for iframes without the src attribute because Hammerhead does not
// inject scripts into such iframes. So, we wrap all scripts in initialization functions.
(function () {
function initTestCafeAutomation(window, isIFrameWithoutSrc) {
var document = window.document;
(function (hammerhead, Promise$e, testCafeCore, testCafeUI) {
var hammerhead__default = 'default' in hammerhead ? hammerhead['default'] : hammerhead;
Promise$e = Promise$e && Object.prototype.hasOwnProperty.call(Promise$e, 'default') ? Promise$e['default'] : Promise$e;
var testCafeCore__default = 'default' in testCafeCore ? testCafeCore['default'] : testCafeCore;
testCafeUI = testCafeUI && Object.prototype.hasOwnProperty.call(testCafeUI, 'default') ? testCafeUI['default'] : testCafeUI;
var nativeMethods = hammerhead__default.nativeMethods;
var MOUSE_EVENT_NAME_RE = /^((mouse\w+)|((dbl)?click)|(contextmenu))$/;
var DRAG_EVENT_NAME_RE = /^((drag\w*)|(drop))$/;
var KEY_EVENT_NAME_RE = /^key\w+$/;
var INPUT_EVENT_NAME_RE = /^(before)?input$/;
var FOCUS_EVENT_NAME_RE = /^(blur|(focus(in|out)?))$/;
var POINTER_EVENT_NAME_RE = /^pointer\w+/;
var DEFAULT_MOUSE_EVENT_DETAIL_PROP_VALUE = {
click: 1,
dblclick: 2,
mousedown: 1,
mouseup: 1,
};
// NOTE: default e.buttons for left button pressed
var DEFAULT_BUTTONS_PARAMETER = 1;
var EVENT_CTORS = {
MouseEvent: 'MouseEvent',
PointerEvent: 'PointerEvent',
KeyboardEvent: 'KeyboardEvent',
InputEvent: 'InputEvent',
FocusEvent: 'FocusEvent',
};
var DispatchEventAutomation = /** @class */ (function () {
function DispatchEventAutomation(element, eventName, options) {
this.element = element;
this.eventName = eventName;
this.options = options;
}
DispatchEventAutomation.prototype.run = function () {
var _a = this.options, bubbles = _a.bubbles, cancelable = _a.cancelable, detail = _a.detail, view = _a.view, buttons = _a.buttons;
bubbles = bubbles !== false;
cancelable = cancelable !== false;
detail = detail || DEFAULT_MOUSE_EVENT_DETAIL_PROP_VALUE[this.eventName];
view = window;
buttons = buttons === void 0 ? DEFAULT_BUTTONS_PARAMETER : buttons;
// eslint-disable-next-line no-restricted-globals
Object.assign(this.options, { bubbles: bubbles, cancelable: cancelable, detail: detail, view: view, buttons: buttons });
var Ctor = DispatchEventAutomation._getEventCtorByEventType(this.eventName, this.options.eventConstructor);
if (Ctor) {
var event_1 = new Ctor(this.eventName, this.options);
this.element.dispatchEvent(event_1);
}
};
DispatchEventAutomation._getEventCtorByEventType = function (eventName, eventConstructor) {
if (eventConstructor && typeof DispatchEventAutomation._getEventCtorFromWindow(eventConstructor) === 'function') {
var Ctor = DispatchEventAutomation._getEventCtorFromNativeMethods(eventConstructor);
if (Ctor && typeof Ctor === 'function')
return Ctor;
}
if (MOUSE_EVENT_NAME_RE.test(eventName))
return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.MouseEvent);
if (DRAG_EVENT_NAME_RE.test(eventName))
return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.MouseEvent);
if (POINTER_EVENT_NAME_RE.test(eventName))
return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.PointerEvent);
if (KEY_EVENT_NAME_RE.test(eventName))
return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.KeyboardEvent);
if (INPUT_EVENT_NAME_RE.test(eventName))
return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.InputEvent);
if (FOCUS_EVENT_NAME_RE.test(eventName))
return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.FocusEvent);
return DispatchEventAutomation._getEventCtorFromNativeMethods('CustomEvent');
};
DispatchEventAutomation._getEventCtorFromNativeMethods = function (eventCtor) {
var ctor = nativeMethods['Window' + eventCtor] || DispatchEventAutomation._getEventCtorFromWindow(eventCtor);
return ctor;
};
DispatchEventAutomation._getEventCtorFromWindow = function (eventCtor) {
// @ts-ignore
return window[eventCtor];
};
return DispatchEventAutomation;
}());
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise$e))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var AxisValues = /** @class */ (function () {
function AxisValues(x, y) {
this.x = x;
this.y = y;
}
AxisValues.create = function (a) {
if ('left' in a)
return new AxisValues(a.left, a.top);
else if ('right' in a)
return new AxisValues(a.right, a.bottom);
return new AxisValues(a.x, a.y);
};
AxisValues.prototype.add = function (p) {
this.x += p.x;
this.y += p.y;
return this;
};
AxisValues.prototype.sub = function (p) {
this.x -= p.x;
this.y -= p.y;
return this;
};
AxisValues.prototype.round = function (fn) {
if (fn === void 0) { fn = Math.round; }
this.x = fn(this.x);
this.y = fn(this.y);
return this;
};
AxisValues.prototype.eql = function (p) {
return this.x === p.x && this.y === p.y;
};
AxisValues.prototype.mul = function (n) {
this.x *= n;
this.y *= n;
return this;
};
AxisValues.prototype.distance = function (p) {
return Math.sqrt(Math.pow(this.x - p.x, 2) + Math.pow(this.y - p.y, 2));
};
return AxisValues;
}());
var ARRAY_METHODS_PREFIX = 'array';
function createNativeMethodWrapper(methodName) {
var nativeMethodName = ARRAY_METHODS_PREFIX + methodName.charAt(0).toUpperCase() + methodName.slice(1);
var nativeMethod = hammerhead.nativeMethods[nativeMethodName];
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return nativeMethod.call.apply(nativeMethod, args);
};
}
var filter = createNativeMethodWrapper('filter');
var map = createNativeMethodWrapper('map');
var slice = createNativeMethodWrapper('slice');
var splice = createNativeMethodWrapper('splice');
var unshift = createNativeMethodWrapper('unshift');
var forEach = createNativeMethodWrapper('forEach');
var indexOf = createNativeMethodWrapper('indexOf');
var some = createNativeMethodWrapper('some');
var reverse = createNativeMethodWrapper('reverse');
var reduce = createNativeMethodWrapper('reduce');
var concat = createNativeMethodWrapper('concat');
var join = createNativeMethodWrapper('join');
var browserUtils = hammerhead__default.utils.browser;
var nativeMethods$1 = hammerhead__default.nativeMethods;
// NOTE: We have to retrieve styleUtils.get from hammerhead
// to avoid circular dependencies between domUtils and styleUtils
var getElementStyleProperty = hammerhead__default.utils.style.get;
var getActiveElement = hammerhead__default.utils.dom.getActiveElement;
var findDocument = hammerhead__default.utils.dom.findDocument;
var find = hammerhead__default.utils.dom.find;
var isElementInDocument = hammerhead__default.utils.dom.isElementInDocument;
var isElementInIframe = hammerhead__default.utils.dom.isElementInIframe;
var getIframeByElement = hammerhead__default.utils.dom.getIframeByElement;
var isCrossDomainWindows = hammerhead__default.utils.dom.isCrossDomainWindows;
var getSelectParent = hammerhead__default.utils.dom.getSelectParent;
var getChildVisibleIndex = hammerhead__default.utils.dom.getChildVisibleIndex;
var getSelectVisibleChildren = hammerhead__default.utils.dom.getSelectVisibleChildren;
var isElementNode = hammerhead__default.utils.dom.isElementNode;
var isTextNode = hammerhead__default.utils.dom.isTextNode;
var isRenderedNode = hammerhead__default.utils.dom.isRenderedNode;
var isIframeElement = hammerhead__default.utils.dom.isIframeElement;
var isInputElement = hammerhead__default.utils.dom.isInputElement;
var isButtonElement = hammerhead__default.utils.dom.isButtonElement;
var isFileInput = hammerhead__default.utils.dom.isFileInput;
var isTextAreaElement = hammerhead__default.utils.dom.isTextAreaElement;
var isAnchorElement = hammerhead__default.utils.dom.isAnchorElement;
var isImgElement = hammerhead__default.utils.dom.isImgElement;
var isFormElement = hammerhead__default.utils.dom.isFormElement;
var isLabelElement = hammerhead__default.utils.dom.isLabelElement;
var isSelectElement = hammerhead__default.utils.dom.isSelectElement;
var isRadioButtonElement = hammerhead__default.utils.dom.isRadioButtonElement;
var isColorInputElement = hammerhead__default.utils.dom.isColorInputElement;
var isCheckboxElement = hammerhead__default.utils.dom.isCheckboxElement;
var isOptionElement = hammerhead__default.utils.dom.isOptionElement;
var isSVGElement = hammerhead__default.utils.dom.isSVGElement;
var isMapElement = hammerhead__default.utils.dom.isMapElement;
var isBodyElement = hammerhead__default.utils.dom.isBodyElement;
var isHtmlElement = hammerhead__default.utils.dom.isHtmlElement;
var isDocument = hammerhead__default.utils.dom.isDocument;
var isWindow = hammerhead__default.utils.dom.isWindow;
var isTextEditableInput = hammerhead__default.utils.dom.isTextEditableInput;
var isTextEditableElement = hammerhead__default.utils.dom.isTextEditableElement;
var isTextEditableElementAndEditingAllowed = hammerhead__default.utils.dom.isTextEditableElementAndEditingAllowed;
var isContentEditableElement = hammerhead__default.utils.dom.isContentEditableElement;
var isDomElement = hammerhead__default.utils.dom.isDomElement;
var isShadowUIElement = hammerhead__default.utils.dom.isShadowUIElement;
var isShadowRoot = hammerhead__default.utils.dom.isShadowRoot;
var isElementFocusable = hammerhead__default.utils.dom.isElementFocusable;
var isHammerheadAttr = hammerhead__default.utils.dom.isHammerheadAttr;
var isElementReadOnly = hammerhead__default.utils.dom.isElementReadOnly;
var getScrollbarSize = hammerhead__default.utils.dom.getScrollbarSize;
var getMapContainer = hammerhead__default.utils.dom.getMapContainer;
var getTagName = hammerhead__default.utils.dom.getTagName;
var closest = hammerhead__default.utils.dom.closest;
var getParents = hammerhead__default.utils.dom.getParents;
var findParent = hammerhead__default.utils.dom.findParent;
var getTopSameDomainWindow = hammerhead__default.utils.dom.getTopSameDomainWindow;
var getParentExceptShadowRoot = hammerhead__default.utils.dom.getParentExceptShadowRoot;
function containsElement(elements, element) {
if (elements.contains)
return elements.contains(element);
return some(elements, function (parent) { return parent.contains(element); });
}
function findIframeByWindow(iframeWindow) {
var iframes = [];
find(document, '*', function (elem) {
if (elem.tagName === 'IFRAME')
iframes.push(elem);
if (elem.shadowRoot)
find(elem.shadowRoot, 'iframe', function (iframe) { return iframes.push(iframe); });
});
for (var i = 0; i < iframes.length; i++) {
if (nativeMethods$1.contentWindowGetter.call(iframes[i]) === iframeWindow)
return iframes[i];
}
return null;
}
function isShadowElement(element) {
return element && element.getRootNode && findDocument(element) !== element.getRootNode();
}
function isNodeEqual(el1, el2) {
return el1 === el2;
}
function getNodeText(el) {
return nativeMethods$1.nodeTextContentGetter.call(el);
}
function getImgMapName(img) {
return img.useMap.substring(1);
}
function getDocumentElement(win) {
return win.document.documentElement;
}
function isDocumentElement(el) {
return el === document.documentElement;
}
var BoundaryValues = /** @class */ (function () {
function BoundaryValues(top, right, bottom, left) {
if (top === void 0) { top = 0; }
if (right === void 0) { right = 0; }
if (bottom === void 0) { bottom = 0; }
if (left === void 0) { left = 0; }
this.top = top;
this.right = right;
this.bottom = bottom;
this.left = left;
}
BoundaryValues.create = function (v) {
return new BoundaryValues(v.top, v.right, v.bottom, v.left);
};
BoundaryValues.prototype.add = function (d) {
this.top += d.top;
this.right += d.right;
this.bottom += d.bottom;
this.left += d.left;
return this;
};
BoundaryValues.prototype.sub = function (d) {
if ('top' in d) {
this.top -= d.top;
this.left -= d.left;
}
this.bottom -= d.bottom;
this.right -= d.right;
return this;
};
BoundaryValues.prototype.round = function (leftTopRound, rightBottomRound) {
if (leftTopRound === void 0) { leftTopRound = Math.round; }
if (rightBottomRound === void 0) { rightBottomRound = leftTopRound; }
this.top = leftTopRound(this.top);
this.right = rightBottomRound(this.right);
this.bottom = rightBottomRound(this.bottom);
this.left = leftTopRound(this.left);
return this;
};
BoundaryValues.prototype.contains = function (point) {
return point.x >= this.left && point.x <= this.right && point.y >= this.top && point.y <= this.bottom;
};
return BoundaryValues;
}());
var styleUtils = hammerhead__default.utils.style;
var getBordersWidth = hammerhead__default.utils.style.getBordersWidth;
var getComputedStyle = hammerhead__default.utils.style.getComputedStyle;
var getElementMargin = hammerhead__default.utils.style.getElementMargin;
var getElementPadding = hammerhead__default.utils.style.getElementPadding;
var getElementScroll = hammerhead__default.utils.style.getElementScroll;
var getOptionHeight = hammerhead__default.utils.style.getOptionHeight;
var getSelectElementSize = hammerhead__default.utils.style.getSelectElementSize;
var isElementVisible = hammerhead__default.utils.style.isElementVisible;
var isSelectVisibleChild = hammerhead__default.utils.style.isVisibleChild;
var getWidth = hammerhead__default.utils.style.getWidth;
var getHeight = hammerhead__default.utils.style.getHeight;
var getInnerWidth = hammerhead__default.utils.style.getInnerWidth;
var getInnerHeight = hammerhead__default.utils.style.getInnerHeight;
var getScrollLeft = hammerhead__default.utils.style.getScrollLeft;
var getScrollTop = hammerhead__default.utils.style.getScrollTop;
var setScrollLeft = hammerhead__default.utils.style.setScrollLeft;
var setScrollTop = hammerhead__default.utils.style.setScrollTop;
var get = hammerhead__default.utils.style.get;
var getBordersWidthFloat = hammerhead__default.utils.style.getBordersWidthFloat;
var getElementPaddingFloat = hammerhead__default.utils.style.getElementPaddingFloat;
function getWindowDimensions(window) {
return new BoundaryValues(0, getWidth(window), getHeight(window), 0);
}
function isFixedElement(node) {
return isElementNode(node) && styleUtils.get(node, 'position') === 'fixed';
}
var shadowUI = hammerhead__default.shadowUI;
var nativeMethods$2 = hammerhead__default.nativeMethods;
var Dimensions = /** @class */ (function () {
function Dimensions(width, height, position, borders, elScroll, scrollbar) {
this.width = width;
this.height = height;
this.left = position.x;
this.top = position.y;
this.right = position.x + width;
this.bottom = position.y + height;
this.border = borders;
this.scrollbar = scrollbar;
this.scroll = elScroll;
}
return Dimensions;
}());
var hiddenReasons = {
notElementOrTextNode: function (targetType) { return "\n The ".concat(targetType, " is neither a DOM element nor a text node.\n "); },
elOutsideBounds: function (target, targetType) { return "\n The ".concat(targetType, " (").concat(target, ") is located outside the the layout viewport.\n "); },
elHasWidthOrHeightZero: function (target, targetType, width, height) { return "\n The ".concat(targetType, " (").concat(target, ") is too small to be visible: ").concat(width, "px x ").concat(height, "px.\n "); },
elHasDisplayNone: function (target, targetType) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible. \n The value of its 'display' property is 'none'.\n "); },
parentHasDisplayNone: function (target, targetType, parent) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible. \n It descends from an element that has the 'display: none' property (").concat(parent, ").\n "); },
elHasVisibilityHidden: function (target, targetType) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible.\n The value of its 'visibility' property is 'hidden'.\n "); },
parentHasVisibilityHidden: function (target, targetType, parent) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible.\n It descends from an element that has the 'visibility: hidden' property (").concat(parent, ").\n "); },
elHasVisibilityCollapse: function (target, targetType) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible.\n The value of its 'visibility' property is 'collapse'.\n "); },
parentHasVisibilityCollapse: function (target, targetType, parent) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible.\n It descends from an element that has the 'visibility: collapse' property (").concat(parent, ").\n "); },
elNotRendered: function (target, targetType) { return "\n The ".concat(targetType, " (").concat(target, ") has not been rendered.\n "); },
optionNotVisible: function (target, targetType, parent) { return "\n The ".concat(targetType, " (").concat(target, ") is invisible. \n The parent element (").concat(parent, ") is collapsed, and its length is shorter than 2.\n "); },
mapContainerNotVisible: function (target, containerHiddenReason) { return "\n The action target (".concat(target, ") is invisible because ").concat(containerHiddenReason, "\n "); },
};
var htmlUtils = hammerhead__default.utils.html;
var nativeMethods$3 = hammerhead__default.nativeMethods;
var MAX_TEXT_CONTENT_LENGTH = 10;
function truncateString(str, length, omission) {
if (omission === void 0) { omission = '...'; }
if (str.length < length)
return str;
return str.substring(0, length - omission.length) + omission;
}
function stringifyElement(element) {
if (!element)
return '';
var emptyElement = nativeMethods$3.cloneNode.call(element);
var outerHtml = htmlUtils.cleanUpHtml(nativeMethods$3.elementOuterHTMLGetter.call(emptyElement));
var text = truncateString(nativeMethods$3.nodeTextContentGetter.call(element), MAX_TEXT_CONTENT_LENGTH);
var children = nativeMethods$3.elementChildrenGetter.call(element);
if (nativeMethods$3.htmlCollectionLengthGetter.call(children) > 0)
return outerHtml.replace('></', '>...</');
if (text)
return outerHtml.replace('></', ">".concat(text, "</"));
return outerHtml;
}
var getElementRectangle = hammerhead__default.utils.position.getElementRectangle;
var getOffsetPosition = hammerhead__default.utils.position.getOffsetPosition;
var offsetToClientCoords = hammerhead__default.utils.position.offsetToClientCoords;
function getClientDimensions(target) {
var isHtmlElement$1 = isHtmlElement(target);
var body = isHtmlElement$1 ? target.getElementsByTagName('body')[0] : null;
var elementRect = target.getBoundingClientRect();
var elBorders = BoundaryValues.create(getBordersWidth(target));
var elScroll = getElementScroll(target);
var isElementInIframe$1 = isElementInIframe(target);
var isCompatMode = target.ownerDocument.compatMode === 'BackCompat';
var elPosition = isHtmlElement$1 ? new AxisValues(0, 0) : AxisValues.create(elementRect);
var elHeight = elementRect.height;
var elWidth = elementRect.width;
if (isHtmlElement$1) {
if (body && isCompatMode) {
elHeight = body.clientHeight;
elWidth = body.clientWidth;
}
else {
elHeight = target.clientHeight;
elWidth = target.clientWidth;
}
}
if (isElementInIframe$1) {
var iframeElement = getIframeByElement(target);
if (iframeElement) {
var iframeOffset = getOffsetPosition(iframeElement);
var clientOffset = offsetToClientCoords(AxisValues.create(iframeOffset));
var iframeBorders = getBordersWidth(iframeElement);
elPosition.add(clientOffset).add(AxisValues.create(iframeBorders));
if (isHtmlElement$1)
elBorders.add(iframeBorders);
}
}
var hasRightScrollbar = !isHtmlElement$1 && getInnerWidth(target) !== target.clientWidth;
var hasBottomScrollbar = !isHtmlElement$1 && getInnerHeight(target) !== target.clientHeight;
var scrollbar = {
right: hasRightScrollbar ? getScrollbarSize() : 0,
bottom: hasBottomScrollbar ? getScrollbarSize() : 0,
};
return new Dimensions(elWidth, elHeight, elPosition, elBorders, elScroll, scrollbar);
}
function getElementFromPoint(_a) {
var x = _a.x, y = _a.y;
// @ts-ignore
var ieFn = document.getElementFromPoint;
var func = ieFn || document.elementFromPoint;
var el = null;
try {
// Permission denied to access property 'getElementFromPoint' error in iframe
el = func.call(document, x, y);
}
catch (_b) {
return null;
}
//NOTE: elementFromPoint returns null when is's a border of an iframe
if (el === null)
el = func.call(document, x - 1, y - 1);
while (el && el.shadowRoot && el.shadowRoot.elementFromPoint) {
var shadowEl = el.shadowRoot.elementFromPoint(x, y);
if (!shadowEl || el === shadowEl)
break;
el = shadowEl;
}
return el;
}
function calcRelativePosition(dimensions, toDimensions) {
var pos = BoundaryValues.create({
top: dimensions.top - toDimensions.top,
left: dimensions.left - toDimensions.left,
right: toDimensions.right - dimensions.right,
bottom: toDimensions.bottom - dimensions.bottom,
});
return pos.sub(toDimensions.border).sub(toDimensions.scrollbar).round(Math.ceil, Math.floor);
}
function getIframeClientCoordinates(iframe) {
var _a = getOffsetPosition(iframe), left = _a.left, top = _a.top;
var clientPosition = offsetToClientCoords({ x: left, y: top });
var iframeBorders = getBordersWidth(iframe);
var iframePadding = getElementPadding(iframe);
var iframeRectangleLeft = clientPosition.x + iframeBorders.left + iframePadding.left;
var iframeRectangleTop = clientPosition.y + iframeBorders.top + iframePadding.top;
return new BoundaryValues(iframeRectangleTop, iframeRectangleLeft + getWidth(iframe), iframeRectangleTop + getHeight(iframe), iframeRectangleLeft);
}
function containsOffset(el, offsetX, offsetY) {
var dimensions = getClientDimensions(el);
var width = Math.max(el.scrollWidth, dimensions.width);
var height = Math.max(el.scrollHeight, dimensions.height);
var maxX = dimensions.scrollbar.right + dimensions.border.left + dimensions.border.right + width;
var maxY = dimensions.scrollbar.bottom + dimensions.border.top + dimensions.border.bottom + height;
return (typeof offsetX === 'undefined' || offsetX >= 0 && maxX >= offsetX) &&
(typeof offsetY === 'undefined' || offsetY >= 0 && maxY >= offsetY);
}
function getClientPosition(el) {
var _a = getOffsetPosition(el), left = _a.left, top = _a.top;
var clientCoords = offsetToClientCoords({ x: left, y: top });
clientCoords.x = Math.round(clientCoords.x);
clientCoords.y = Math.round(clientCoords.y);
return clientCoords;
}
function getWindowPosition() {
var x = window.screenLeft || window.screenX;
var y = window.screenTop || window.screenY;
return new AxisValues(x, y);
}
function getSubHiddenReason(reason) {
return reason.replace(/.*The/, 'its');
}
function getElOutsideBoundsReason(el, targetType) {
if (targetType === void 0) { targetType = 'action target'; }
var strEl = stringifyElement(el);
if (isMapElement(el)) {
var mapContainer = getMapContainer(closest(el, 'map'));
var containerHiddenReason = getElOutsideBoundsReason(mapContainer, 'container') || '';
var containerError = getSubHiddenReason(containerHiddenReason);
return hiddenReasons.mapContainerNotVisible(strEl, containerError);
}
return hiddenReasons.elOutsideBounds(strEl, targetType);
}
function getAutomationPoint(element, offset) {
return hammerhead.Promise.resolve(isDocumentElement(element))
.then(function (isDocEl) {
if (isDocEl)
return new AxisValues(0, 0);
var roundFn = hammerhead.utils.browser.isFirefox ? Math.ceil : Math.round;
return hammerhead.Promise.resolve(getOffsetPosition(element, roundFn))
.then(function (elementOffset) { return AxisValues.create(elementOffset); });
})
.then(function (point) { return point.add(offset); });
}
var SCROLLABLE_OVERFLOW_STYLE_RE = /auto|scroll|hidden/i;
var DEFAULT_IE_SCROLLABLE_OVERFLOW_STYLE_VALUE = 'visible';
function getScrollable(el) {
var overflowX = get(el, 'overflowX');
var overflowY = get(el, 'overflowY');
var scrollableHorizontally = SCROLLABLE_OVERFLOW_STYLE_RE.test(overflowX);
var scrollableVertically = SCROLLABLE_OVERFLOW_STYLE_RE.test(overflowY);
// IE11 and MS Edge bug: There are two properties: overflow-x and overflow-y.
// If one property is set so that the browser may show scrollbars (`auto` or `scroll`) and the second one is set to 'visible',
// then the second one will work as if it had the 'auto' value.
if (hammerhead.utils.browser.isIE) {
scrollableHorizontally = scrollableHorizontally || scrollableVertically && overflowX === DEFAULT_IE_SCROLLABLE_OVERFLOW_STYLE_VALUE;
scrollableVertically = scrollableVertically || scrollableHorizontally && overflowY === DEFAULT_IE_SCROLLABLE_OVERFLOW_STYLE_VALUE;
}
return new AxisValues(scrollableHorizontally, scrollableVertically);
}
function hasBodyScroll(el) {
var overflowX = get(el, 'overflowX');
var overflowY = get(el, 'overflowY');
var scrollableHorizontally = SCROLLABLE_OVERFLOW_STYLE_RE.test(overflowX);
var scrollableVertically = SCROLLABLE_OVERFLOW_STYLE_RE.test(overflowY);
var documentElement = findDocument(el).documentElement;
var bodyScrollHeight = el.scrollHeight;
if (hammerhead.utils.browser.isChrome || hammerhead.utils.browser.isFirefox || hammerhead.utils.browser.isSafari) {
var bodyTop = el.getBoundingClientRect().top;
var documentTop = documentElement.getBoundingClientRect().top;
bodyScrollHeight = bodyScrollHeight - documentTop + bodyTop;
}
return (scrollableHorizontally || scrollableVertically) &&
bodyScrollHeight > documentElement.scrollHeight;
}
function hasHTMLElementScroll(el) {
var overflowX = get(el, 'overflowX');
var overflowY = get(el, 'overflowY');
//T303226
if (overflowX === 'hidden' && overflowY === 'hidden')
return false;
var hasHorizontalScroll = el.scrollHeight > el.clientHeight;
var hasVerticalScroll = el.scrollWidth > el.clientWidth;
if (hasHorizontalScroll || hasVerticalScroll)
return true;
//T174562 - wrong scrolling in iframes without src and others iframes
var body = el.getElementsByTagName('body')[0];
if (!body)
return false;
if (hasBodyScroll(body))
return false;
var clientWidth = Math.min(el.clientWidth, body.clientWidth);
var clientHeight = Math.min(el.clientHeight, body.clientHeight);
return body.scrollHeight > clientHeight || body.scrollWidth > clientWidth;
}
function hasScroll(el) {
if (isBodyElement(el))
return hasBodyScroll(el);
if (isHtmlElement(el))
return hasHTMLElementScroll(el);
var scrollable = getScrollable(el);
if (!scrollable.x && !scrollable.y)
return false;
var hasVerticalScroll = scrollable.y && el.scrollHeight > el.clientHeight;
var hasHorizontalScroll = scrollable.x && el.scrollWidth > el.clientWidth;
return hasHorizontalScroll || hasVerticalScroll;
}
function getScrollableParents(element) {
var parentsArray = getParents(element);
if (isElementInIframe(element)) {
var iframe = getIframeByElement(element);
if (iframe) {
var iFrameParents = getParents(iframe);
parentsArray.concat(iFrameParents);
}
}
return hammerhead.nativeMethods.arrayFilter.call(parentsArray, hasScroll);
}
function convertToClient(element, point) {
return __awaiter(this, void 0, void 0, function () {
var elementScroll, hasScroll$1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, getElementScroll(element)];
case 1:
elementScroll = _a.sent();
hasScroll$1 = hasScroll(element);
if (!/html/i.test(element.tagName) && hasScroll$1) {
point.x -= elementScroll.left;
point.y -= elementScroll.top;
}
return [2 /*return*/, offsetToClientCoords(point)];
}
});
});
}
function getDevicePoint(clientPoint) {
if (!clientPoint)
return null;
var windowPosition = getWindowPosition();
var screenLeft = windowPosition.x;
var screenTop = windowPosition.y;
var x = screenLeft + clientPoint.x;
var y = screenTop + clientPoint.y;
return new AxisValues(x, y);
}
function calcOffset(size) {
var offset = size / 2;
return offset < 1 ? 0 : Math.round(offset);
}
function getDefaultAutomationOffsets(element) {
var rect = getElementRectangle(element);
var offsetX = calcOffset(rect.width);
var offsetY = calcOffset(rect.height);
return { offsetX: offsetX, offsetY: offsetY };
}
function getOffsetOptions(element, offsetX, offsetY) {
var defaultOffsets = getDefaultAutomationOffsets(element);
offsetX = typeof offsetX === 'number' ? Math.round(offsetX) : defaultOffsets.offsetX;
offsetY = typeof offsetY === 'number' ? Math.round(offsetY) : defaultOffsets.offsetY;
if (offsetX > 0 && offsetY > 0)
return { offsetX: offsetX, offsetY: offsetY };
var dimensions = getClientDimensions(element);
var width = Math.round(Math.max(element.scrollWidth, dimensions.width));
var height = Math.round(Math.max(element.scrollHeight, dimensions.height));
var maxX = dimensions.scrollbar.right + dimensions.border.left + dimensions.border.right + width;
var maxY = dimensions.scrollbar.bottom + dimensions.border.top + dimensions.border.bottom + height;
return {
offsetX: offsetX < 0 ? maxX + offsetX : offsetX,
offsetY: offsetY < 0 ? maxY + offsetY : offsetY,
};
}
var positionUtils = testCafeCore__default.positionUtils;
function getElementFromPoint$1(point, underTopShadowUIElement) {
if (underTopShadowUIElement === void 0) { underTopShadowUIElement = false; }
return testCafeUI.hide(underTopShadowUIElement)
.then(function () {
var topElement = positionUtils.getElementFromPoint(point);
return testCafeUI.show(underTopShadowUIElement)
.then(function () { return topElement; });
});
}
// @ts-ignore
function ensureImageMap(imgElement, areaElement) {
return hammerhead.Promise.resolve(closest(areaElement, 'map'))
.then(function (mapElement) {
return mapElement && mapElement.name === getImgMapName(imgElement) ? areaElement : imgElement;
});
}
function findElementOrNonEmptyChildFromPoint(point, element) {
return hammerhead.Promise.resolve(getElementFromPoint(point))
.then(function (topElement) {
return hammerhead.Promise.resolve(containsElement(element, topElement))
.then(function (containsEl) { return containsEl && getNodeText(topElement); })
.then(function (isNonEmptyChild) { return isNonEmptyChild || topElement && isNodeEqual(topElement, element) ? topElement : null; });
});
}
function correctTopElementByExpectedElement(topElement, expectedElement) {
if (!expectedElement || !topElement || isNodeEqual(topElement, expectedElement))
return topElement;
var isTREFElement = getTagName(expectedElement) === 'tref';
// NOTE: 'document.elementFromPoint' can't find these types of elements
if (isTREFElement)
return expectedElement;
// NOTE: T299665 - Incorrect click automation for images with an associated map element in Firefox
// All browsers return the <area> element from document.getElementFromPoint, but
// Firefox returns the <img> element. We should accomplish this for Firefox as well.
var isImageMapArea = getTagName(expectedElement) === 'area' && isImgElement(topElement);
if (hammerhead.utils.browser.isFirefox && isImageMapArea)
return ensureImageMap(topElement, expectedElement);
// NOTE: try to find a multi-line link by its rectangle (T163678)
return hammerhead.Promise.resolve(closest(expectedElement, 'a'))
.then(function (anchor) { return !!anchor; })
.then(function (isLinkOrChildExpected) {
if (!isLinkOrChildExpected)
return false;
return hammerhead.Promise.resolve(containsElement(expectedElement, topElement))
.then(function (containsElement) { return containsElement && getNodeText(topElement); })
.then(function (isTopElementChildOfLink) { return !isTopElementChildOfLink && getNodeText(expectedElement); });
})
.then(function (shouldSearchForMultilineLink) {
if (!shouldSearchForMultilineLink)
return topElement;
return hammerhead.Promise.resolve(getClientDimensions(expectedElement))
.then(function (linkRect) { return findElementOrNonEmptyChildFromPoint({ x: linkRect.right - 1, y: linkRect.top + 1 }, expectedElement)
.then(function (el) { return el || findElementOrNonEmptyChildFromPoint({ x: linkRect.left + 1, y: linkRect.bottom - 1 }, expectedElement); })
.then(function (el) { return el || topElement; }); });
});
}
function getElementFromPoint$2(point, win, expectedEl) {
return getElementFromPoint$1(point)
.then(function (topElement) {
// NOTE: when trying to get an element by elementFromPoint in iframe and the target
// element is under any of shadow-ui elements, you will get null (only in IE).
// In this case, you should hide a top window's shadow-ui root to obtain an element.
var resChain = hammerhead.Promise.resolve(topElement);
if (!topElement && hammerhead.utils.dom.isIframeWindow(win || window) && point.x > 0 && point.y > 0)
resChain = resChain.then(function () { return getElementFromPoint$1(point, true); });
return resChain.then(function (element) { return correctTopElementByExpectedElement(element, expectedEl); });
});
}
// -------------------------------------------------------------
// WARNING: this file is used by both the client and the server.
// Do not use any browser or node-specific API!
// -------------------------------------------------------------
var TEST_RUN_ERRORS = {
uncaughtErrorOnPage: 'E1',
uncaughtErrorInTestCode: 'E2',
uncaughtNonErrorObjectInTestCode: 'E3',
uncaughtErrorInClientFunctionCode: 'E4',
uncaughtErrorInCustomDOMPropertyCode: 'E5',
unhandledPromiseRejection: 'E6',
uncaughtException: 'E7',
missingAwaitError: 'E8',
actionIntegerOptionError: 'E9',
actionPositiveIntegerOptionError: 'E10',
actionBooleanOptionError: 'E11',
actionSpeedOptionError: 'E12',
actionOptionsTypeError: 'E14',
actionBooleanArgumentError: 'E15',
actionStringArgumentError: 'E16',
actionNullableStringArgumentError: 'E17',
actionStringOrStringArrayArgumentError: 'E18',
actionStringArrayElementError: 'E19',
actionIntegerArgumentError: 'E20',
actionRoleArgumentError: 'E21',
actionPositiveIntegerArgumentError: 'E22',
actionSelectorError: 'E23',
actionElementNotFoundError: 'E24',
actionElementIsInvisibleError: 'E26',
actionSelectorMatchesWrongNodeTypeError: 'E27',
actionAdditionalElementNotFoundError: 'E28',
actionAdditionalElementIsInvisibleError: 'E29',
actionAdditionalSelectorMatchesWrongNodeTypeError: 'E30',
actionElementNonEditableError: 'E31',
actionElementNotTextAreaError: 'E32',
actionElementNonContentEditableError: 'E33',
actionElementIsNotFileInputError: 'E34',
actionRootContainerNotFoundError: 'E35',
actionIncorrectKeysError: 'E36',
actionCannotFindFileToUploadError: 'E37',
actionUnsupportedDeviceTypeError: 'E38',
actionIframeIsNotLoadedError: 'E39',
actionElementNotIframeError: 'E40',
actionInvalidScrollTargetError: 'E41',
currentIframeIsNotLoadedError: 'E42',
currentIframeNotFoundError: 'E43',
currentIframeIsInvisibleError: 'E44',
nativeDialogNotHandledError: 'E45',
uncaughtErrorInNativeDialogHandler: 'E46',
setTestSpeedArgumentError: 'E47',
setNativeDialogHandlerCodeWrongTypeError: 'E48',
clientFunctionExecutionInterruptionError: 'E49',
domNodeClientFunctionResultError: 'E50',
invalidSelectorResultError: 'E51',
cannotObtainInfoForElementSpecifiedBySelectorError: 'E52',
externalAssertionLibraryError: 'E53',
pageLoadError: 'E54',
windowDimensionsOverflowError: 'E55',
forbiddenCharactersInScreenshotPathError: 'E56',
invalidElementScreenshotDimensionsError: 'E57',
roleSwitchInRoleInitializerError: 'E58',
assertionExecutableArgumentError: 'E59',
assertionWithoutMethodCallError: 'E60',
assertionUnawaitedPromiseError: 'E61',
requestHookNotImplementedError: 'E62',
requestHookUnhandledError: 'E63',
uncaughtErrorInCustomClientScriptCode: 'E64',
uncaughtErrorInCustomClientScriptCodeLoadedFromModule: 'E65',
uncaughtErrorInCustomScript: 'E66',
uncaughtTestCafeErrorInCustomScript: 'E67',
childWindowIsNotLoadedError: 'E68',
childWindowNotFoundError: 'E69',
cannotSwitchToWindowError: 'E70',
closeChildWindowError: 'E71',
childWindowClosedBeforeSwitchingError: 'E72',
cannotCloseWindowWithChildrenError: 'E73',
targetWindowNotFoundError: 'E74',
parentWindowNotFoundError: 'E76',
previousWindowNotFoundError: 'E77',
switchToWindowPredicateError: 'E78',
actionFunctionArgumentError: 'E79',
multipleWindowsModeIsDisabledError: 'E80',
multipleWindowsModeIsNotSupportedInRemoteBrowserError: 'E81',
cannotCloseWindowWithoutParent: 'E82',
cannotRestoreChildWindowError: 'E83',
executionTimeoutExceeded: 'E84',
actionRequiredCookieArguments: 'E85',
actionCookieArgumentError: 'E86',
actionCookieArgumentsError: 'E87',
actionUrlCookieArgumentError: 'E88',
actionUrlsCookieArgumentError: 'E89',
actionStringOptionError: 'E90',
actionDateOptionError: 'E91',
actionNumberOptionError: 'E92',
actionUrlOptionError: 'E93',
actionUrlSearchParamsOptionError: 'E94',
actionObjectOptionError: 'E95',
actionUrlArgumentError: 'E96',
actionStringOrRegexOptionError: 'E97',
actionSkipJsErrorsArgumentError: 'E98',
actionFunctionOptionError: 'E99',
actionInvalidObjectPropertyError: 'E100',
actionElementIsNotTargetError: 'E101',
};
// Base
//--------------------------------------------------------------------
var TestRunErrorBase = /** @class */ (function () {
function TestRunErrorBase(code, callsite) {
this.code = code;
this.isTestCafeError = true;
this.callsite = callsite || null;
}
return TestRunErrorBase;
}());
var ActionOptionErrorBase = /** @class */ (function (_super) {
__extends(ActionOptionErrorBase, _super);
function ActionOptionErrorBase(code, optionName, actualValue) {
var _this = _super.call(this, code) || this;
_this.optionName = optionName;
_this.actualValue = actualValue;
return _this;
}
return ActionOptionErrorBase;
}(TestRunErrorBase));
// Client function errors
//--------------------------------------------------------------------
var ClientFunctionExecutionInterruptionError = /** @class */ (function (_super) {
__extends(ClientFunctionExecutionInterruptionError, _super);
function ClientFunctionExecutionInterruptionError(instantiationCallsiteName, callsite) {
var _this = _super.call(this, TEST_RUN_ERRORS.clientFunctionExecutionInterruptionError, callsite) || this;
_this.instantiationCallsiteName = instantiationCallsiteName;
return _this;
}
return ClientFunctionExecutionInterruptionError;
}(TestRunErrorBase));
var DomNodeClientFunctionResultError = /** @class */ (function (_super) {
__extends(DomNodeClientFunctionResultError, _super);
function DomNodeClientFunctionResultError(instantiationCallsiteName, callsite) {
var _this = _super.call(this, TEST_RUN_ERRORS.domNodeClientFunctionResultError, callsite) || this;
_this.instantiationCallsiteName = instantiationCallsiteName;
return _this;
}
return DomNodeClientFunctionResultError;
}(TestRunErrorBase));
// Selector errors
//--------------------------------------------------------------------
var SelectorErrorBase = /** @class */ (function (_super) {
__extends(SelectorErrorBase, _super);
function SelectorErrorBase(code, _a, callsite) {
var _b = _a === void 0 ? {} : _a, apiFnChain = _b.apiFnChain, apiFnIndex = _b.apiFnIndex, reason = _b.reason;
var _this = _super.call(this, code, callsite) || this;
_this.apiFnChain = apiFnChain;
_this.apiFnIndex = apiFnIndex;
_this.reason = reason;
return _this;
}
return SelectorErrorBase;
}(TestRunErrorBase));
var InvalidSelectorResultError = /** @class */ (function (_super) {
__extends(InvalidSelectorResultError, _super);
function InvalidSelectorResultError(callsite) {
return _super.call(this, TEST_RUN_ERRORS.invalidSelectorResultError, callsite) || this;
}
return InvalidSelectorResultError;
}(TestRunErrorBase));
var CannotObtainInfoForElementSpecifiedBySelectorError = /** @class */ (function (_super) {
__extends(CannotObtainInfoForElementSpecifiedBySelectorError, _super);
function CannotObtainInfoForElementSpecifiedBySelectorError(callsite, apiFnArgs) {
return _super.call(this, TEST_RUN_ERRORS.cannotObtainInfoForElementSpecifiedBySelectorError, apiFnArgs, callsite) || this;
}
return CannotObtainInfoForElementSpecifiedBySelectorError;
}(SelectorErrorBase));
// Uncaught errors
//--------------------------------------------------------------------
var UncaughtErrorOnPage = /** @class */ (function (_super) {
__extends(UncaughtErrorOnPage, _super);
function UncaughtErrorOnPage(errStack, pageDestUrl) {
var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorOnPage) || this;
_this.errStack = errStack;
_this.pageDestUrl = pageDestUrl;
return _this;
}
return UncaughtErrorOnPage;
}(TestRunErrorBase));
var UncaughtErrorInClientFunctionCode = /** @class */ (function (_super) {
__extends(UncaughtErrorInClientFunctionCode, _super);
function UncaughtErrorInClientFunctionCode(instantiationCallsiteName, err, callsite) {
var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInClientFunctionCode, callsite) || this;
_this.errMsg = String(err);
_this.instantiationCallsiteName = instantiationCallsiteName;
return _this;
}
return UncaughtErrorInClientFunctionCode;
}(TestRunErrorBase));
var UncaughtErrorInCustomDOMPropertyCode = /** @class */ (function (_super) {
__extends(UncaughtErrorInCustomDOMPropertyCode, _super);
function UncaughtErrorInCustomDOMPropertyCode(instantiationCallsiteName, err, prop, callsite) {
var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInCustomDOMPropertyCode, callsite) || this;
_this.errMsg = String(err);
_this.property = prop;
_this.instantiationCallsiteName = instantiationCallsiteName;
return _this;
}
return UncaughtErrorInCustomDOMPropertyCode;
}(TestRunErrorBase));
var UncaughtErrorInCustomClientScriptCode = /** @class */ (function (_super) {
__extends(UncaughtErrorInCustomClientScriptCode, _super);
function UncaughtErrorInCustomClientScriptCode(err) {
var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInCustomClientScriptCode) || this;
_this.errMsg = String(err);
return _this;
}
return UncaughtErrorInCustomClientScriptCode;
}(TestRunErrorBase));
var UncaughtErrorInCustomClientScriptLoadedFromModule = /** @class */ (function (_super) {
__extends(UncaughtErrorInCustomClientScriptLoadedFromModule, _super);
function UncaughtErrorInCustomClientScriptLoadedFromModule(err, moduleName) {
var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInCustomClientScriptCodeLoadedFromModule) || this;
_this.errMsg = String(err);
_this.moduleName = moduleName;
return _this;
}
return UncaughtErrorInCustomClientScriptLoadedFromModule;
}(TestRunErrorBase));
// Action parameters errors
//--------------------------------------------------------------------
// Options errors
//--------------------------------------------------------------------
var ActionIntegerOptionError = /** @class */ (function (_super) {
__extends(ActionIntegerOptionError, _super);
function ActionIntegerOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionIntegerOptionError, optionName, actualValue) || this;
}
return ActionIntegerOptionError;
}(ActionOptionErrorBase));
var ActionPositiveIntegerOptionError = /** @class */ (function (_super) {
__extends(ActionPositiveIntegerOptionError, _super);
function ActionPositiveIntegerOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionPositiveIntegerOptionError, optionName, actualValue) || this;
}
return ActionPositiveIntegerOptionError;
}(ActionOptionErrorBase));
var ActionBooleanOptionError = /** @class */ (function (_super) {
__extends(ActionBooleanOptionError, _super);
function ActionBooleanOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionBooleanOptionError, optionName, actualValue) || this;
}
return ActionBooleanOptionError;
}(ActionOptionErrorBase));
var ActionSpeedOptionError = /** @class */ (function (_super) {
__extends(ActionSpeedOptionError, _super);
function ActionSpeedOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionSpeedOptionError, optionName, actualValue) || this;
}
return ActionSpeedOptionError;
}(ActionOptionErrorBase));
var ActionStringOptionError = /** @class */ (function (_super) {
__extends(ActionStringOptionError, _super);
function ActionStringOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionStringOptionError, optionName, actualValue) || this;
}
return ActionStringOptionError;
}(ActionOptionErrorBase));
var ActionStringOrRegexOptionError = /** @class */ (function (_super) {
__extends(ActionStringOrRegexOptionError, _super);
function ActionStringOrRegexOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionStringOrRegexOptionError, optionName, actualValue) || this;
}
return ActionStringOrRegexOptionError;
}(ActionOptionErrorBase));
var ActionDateOptionError = /** @class */ (function (_super) {
__extends(ActionDateOptionError, _super);
function ActionDateOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionDateOptionError, optionName, actualValue) || this;
}
return ActionDateOptionError;
}(ActionOptionErrorBase));
var ActionNumberOptionError = /** @class */ (function (_super) {
__extends(ActionNumberOptionError, _super);
function ActionNumberOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionNumberOptionError, optionName, actualValue) || this;
}
return ActionNumberOptionError;
}(ActionOptionErrorBase));
var ActionUrlOptionError = /** @class */ (function (_super) {
__extends(ActionUrlOptionError, _super);
function ActionUrlOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionUrlOptionError, optionName, actualValue) || this;
}
return ActionUrlOptionError;
}(ActionOptionErrorBase));
var ActionUrlSearchParamsOptionError = /** @class */ (function (_super) {
__extends(ActionUrlSearchParamsOptionError, _super);
function ActionUrlSearchParamsOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionUrlSearchParamsOptionError, optionName, actualValue) || this;
}
return ActionUrlSearchParamsOptionError;
}(ActionOptionErrorBase));
var ActionObjectOptionError = /** @class */ (function (_super) {
__extends(ActionObjectOptionError, _super);
function ActionObjectOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionObjectOptionError, optionName, actualValue) || this;
}
return ActionObjectOptionError;
}(ActionOptionErrorBase));
var ActionFunctionOptionError = /** @class */ (function (_super) {
__extends(ActionFunctionOptionError, _super);
function ActionFunctionOptionError(optionName, actualValue) {
return _super.call(this, TEST_RUN_ERRORS.actionFunctionOptionError, optionName, actualValue) || this;
}
return ActionFunctionOptionError;
}(ActionOptionErrorBase));
var ActionInvalidObjectPropertyError = /** @class */ (function (_super) {
__extends(ActionInvalidObjectPropertyError, _super);
function ActionInvalidObjectPropertyError(objectName, propertyName, availableProperties) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionInvalidObjectPropertyError) || this;
_this.objectName = objectName;
_this.propertyName = propertyName;
_this.availableProperties = availableProperties;
return _this;
}
return ActionInvalidObjectPropertyError;
}(TestRunErrorBase));
// Action execution errors
//--------------------------------------------------------------------
var ActionElementNotFoundError = /** @class */ (function (_super) {
__extends(ActionElementNotFoundError, _super);
function ActionElementNotFoundError(callsite, apiFnArgs) {
return _super.call(this, TEST_RUN_ERRORS.actionElementNotFoundError, apiFnArgs, callsite) || this;
}
return ActionElementNotFoundError;
}(SelectorErrorBase));
var ActionElementIsInvisibleError = /** @class */ (function (_super) {
__extends(ActionElementIsInvisibleError, _super);
function ActionElementIsInvisibleError(callsite, apiFnArgs) {
return _super.call(this, TEST_RUN_ERRORS.actionElementIsInvisibleError, apiFnArgs, callsite) || this;
}
return ActionElementIsInvisibleError;
}(SelectorErrorBase));
var ActionSelectorMatchesWrongNodeTypeError = /** @class */ (function (_super) {
__extends(ActionSelectorMatchesWrongNodeTypeError, _super);
function ActionSelectorMatchesWrongNodeTypeError(nodeDescription) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionSelectorMatchesWrongNodeTypeError) || this;
_this.nodeDescription = nodeDescription;
return _this;
}
return ActionSelectorMatchesWrongNodeTypeError;
}(TestRunErrorBase));
var ActionAdditionalElementNotFoundError = /** @class */ (function (_super) {
__extends(ActionAdditionalElementNotFoundError, _super);
function ActionAdditionalElementNotFoundError(argumentName, apiFnArgs) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionAdditionalElementNotFoundError, apiFnArgs) || this;
_this.argumentName = argumentName;
return _this;
}
return ActionAdditionalElementNotFoundError;
}(SelectorErrorBase));
var ActionElementIsNotTargetError = /** @class */ (function (_super) {
__extends(ActionElementIsNotTargetError, _super);
function ActionElementIsNotTargetError(callsite) {
return _super.call(this, TEST_RUN_ERRORS.actionElementIsNotTargetError, callsite) || this;
}
return ActionElementIsNotTargetError;
}(TestRunErrorBase));
var ActionAdditionalElementIsInvisibleError = /** @class */ (function (_super) {
__extends(ActionAdditionalElementIsInvisibleError, _super);
function ActionAdditionalElementIsInvisibleError(argumentName, apiFnArgs) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionAdditionalElementIsInvisibleError, apiFnArgs) || this;
_this.argumentName = argumentName;
return _this;
}
return ActionAdditionalElementIsInvisibleError;
}(SelectorErrorBase));
var ActionAdditionalSelectorMatchesWrongNodeTypeError = /** @class */ (function (_super) {
__extends(ActionAdditionalSelectorMatchesWrongNodeTypeError, _super);
function ActionAdditionalSelectorMatchesWrongNodeTypeError(argumentName, nodeDescription) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionAdditionalSelectorMatchesWrongNodeTypeError) || this;
_this.argumentName = argumentName;
_this.nodeDescription = nodeDescription;
return _this;
}
return ActionAdditionalSelectorMatchesWrongNodeTypeError;
}(TestRunErrorBase));
var ActionElementNonEditableError = /** @class */ (function (_super) {
__extends(ActionElementNonEditableError, _super);
function ActionElementNonEditableError() {
return _super.call(this, TEST_RUN_ERRORS.actionElementNonEditableError) || this;
}
return ActionElementNonEditableError;
}(TestRunErrorBase));
var ActionElementNotTextAreaError = /** @class */ (function (_super) {
__extends(ActionElementNotTextAreaError, _super);
function ActionElementNotTextAreaError() {
return _super.call(this, TEST_RUN_ERRORS.actionElementNotTextAreaError) || this;
}
return ActionElementNotTextAreaError;
}(TestRunErrorBase));
var ActionElementNonContentEditableError = /** @class */ (function (_super) {
__extends(ActionElementNonContentEditableError, _super);
function ActionElementNonContentEditableError(argumentName) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionElementNonContentEditableError) || this;
_this.argumentName = argumentName;
return _this;
}
return ActionElementNonContentEditableError;
}(TestRunErrorBase));
var ActionRootContainerNotFoundError = /** @class */ (function (_super) {
__extends(ActionRootContainerNotFoundError, _super);
function ActionRootContainerNotFoundError() {
return _super.call(this, TEST_RUN_ERRORS.actionRootContainerNotFoundError) || this;
}
return ActionRootContainerNotFoundError;
}(TestRunErrorBase));
var ActionIncorrectKeysError = /** @class */ (function (_super) {
__extends(ActionIncorrectKeysError, _super);
function ActionIncorrectKeysError(argumentName) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionIncorrectKeysError) || this;
_this.argumentName = argumentName;
return _this;
}
return ActionIncorrectKeysError;
}(TestRunErrorBase));
var ActionCannotFindFileToUploadError = /** @class */ (function (_super) {
__extends(ActionCannotFindFileToUploadError, _super);
function ActionCannotFindFileToUploadError(filePaths, scannedFilePaths) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionCannotFindFileToUploadError) || this;
_this.filePaths = filePaths;
_this.scannedFilePaths = scannedFilePaths;
return _this;
}
return ActionCannotFindFileToUploadError;
}(TestRunErrorBase));
var ActionElementIsNotFileInputError = /** @class */ (function (_super) {
__extends(ActionElementIsNotFileInputError, _super);
function ActionElementIsNotFileInputError() {
return _super.call(this, TEST_RUN_ERRORS.actionElementIsNotFileInputError) || this;
}
return ActionElementIsNotFileInputError;
}(TestRunErrorBase));
var ActionInvalidScrollTargetError = /** @class */ (function (_super) {
__extends(ActionInvalidScrollTargetError, _super);
function ActionInvalidScrollTargetError(scrollTargetXValid, scrollTargetYValid) {
var _this = _super.call(this, TEST_RUN_ERRORS.actionInvalidScrollTargetError) || this;
if (!scrollTargetXValid) {
if (!scrollTargetYValid)
_this.properties = 'scrollTargetX and scrollTargetY properties';
else
_this.properties = 'scrollTargetX property';
}
else
_this.properties = 'scrollTargetY property';
return _this;
}
return ActionInvalidScrollTargetError;
}(TestRunErrorBase));
var InvalidElementScreenshotDimensionsError = /** @class */ (function (_super) {
__extends(InvalidElementScreenshotDimensionsError, _super);
function InvalidElementScreenshotDimensionsError(width, height) {
var _this = _super.call(this, TEST_RUN_ERRORS.invalidElementScreenshotDimensionsError) || this;
var widthIsInvalid = width <= 0;
var heightIsInvalid = height <= 0;
if (widthIsInvalid) {
if (heightIsInvalid) {
_this.verb = 'are';
_this.dimensions = 'width and height';
}
else {
_this.verb = 'is';
_this.dimensions = 'width';
}
}
else {
_this.verb = 'is';
_this.dimensions = 'height';
}
return _this;
}
return InvalidElementScreenshotDimensionsError;
}(TestRunErrorBase));
// Iframe errors
//--------------------------------------------------------------------
var ActionElementNotIframeError = /** @class */ (function (_super) {
__extends(ActionElementNotIframeError, _super);
function ActionElementNotIframeError(callsite) {
return _super.call(this, TEST_RUN_ERRORS.actionElementNotIframeError, callsite) || this;
}
return ActionElementNotIframeError;
}(TestRunErrorBase));
var ActionIframeIsNotLoadedError = /** @class */ (function (_super) {
__extends(ActionIframeIsNotLoadedError, _super);
function ActionIframeIsNotLoadedError() {
return _super.call(this, TEST_RUN_ERRORS.actionIframeIsNotLoadedError) || this;
}
return ActionIframeIsNotLoadedError;
}(TestRunErrorBase));
var CurrentIframeIsNotLoadedError = /** @class */ (function (_super) {
__extends(CurrentIframeIsNotLoadedError, _super);
function CurrentIframeIsNotLoadedError() {
return _super.call(this, TEST_RUN_ERRORS.currentIframeIsNotLoadedError) || this;
}
return CurrentIframeIsNotLoadedError;
}(TestRunErrorBase));
var ChildWindowNotFoundError = /** @class */ (function (_super) {
__extends(ChildWindowNotFoundError, _super);
function ChildWindowNotFoundError() {
return _super.call(this, TEST_RUN_ERRORS.childWindowNotFoundError) || this;
}
return ChildWindowNotFoundError;
}(TestRunErrorBase));
var ChildWindowIsNotLoadedError = /** @class */ (function (_super) {
__extends(ChildWindowIsNotLoadedError, _super);
function ChildWindowIsNotLoadedError() {
return _super.call(this, TEST_RUN_ERRORS.childWindowIsNotLoadedError) || this;
}
return ChildWindowIsNotLoadedError;
}(TestRunErrorBase));
var CannotSwitchToWindowError = /** @class */ (function (_super) {
__extends(CannotSwitchToWindowError, _super);
function CannotSwitchToWindowError() {
return _super.call(this, TEST_RUN_ERRORS.cannotSwitchToWindowError) || this;
}
return CannotSwitchToWindowError;
}(TestRunErrorBase));
var CloseChildWindowError = /** @class */ (function (_super) {
__extends(CloseChildWindowError, _super);
function CloseChildWindowError() {
return _super.call(this, TEST_RUN_ERRORS.closeChildWindowError) || this;
}
return CloseChildWindowError;
}(TestRunErrorBase));
var CannotCloseWindowWithChildrenError = /** @class */ (function (_super) {
__extends(CannotCloseWindowWithChildrenError, _super);
function CannotCloseWindowWithChildrenError() {
return _super.call(this, TEST_RUN_ERRORS.cannotCloseWindowWithChildrenError) || this;
}
return CannotCloseWindowWithChildrenError;
}(TestRunErrorBase));
var CannotCloseWindowWithoutParentError = /** @class */ (function (_super) {
__extends(CannotCloseWindowWithoutParentError, _super);
function CannotCloseWindowWithoutParentError() {
return _super.call(this, TEST_RUN_ERRORS.cannotCloseWindowWithoutParent) || this;
}
return CannotCloseWindowWithoutParentError;
}(TestRunErrorBase));
var SwitchToWindowPredicateError = /** @class */ (function (_super) {
__extends(SwitchToWindowPredicateError, _super);
function SwitchToWindowPredicateError(errMsg) {
var _this = _super.call(this, TEST_RUN_ERRORS.switchToWindowPredicateError) || this;
_this.errMsg = errMsg;
return _this;
}
return SwitchToWindowPredicateError;
}(TestRunErrorBase));
var WindowNotFoundError = /** @class */ (function (_super) {
__extends(WindowNotFoundError, _super);
function WindowNotFoundError() {
return _super.call(this, TEST_RUN_ERRORS.targetWindowNotFoundError) || this;
}
return WindowNotFoundError;
}(TestRunErrorBase));
var ParentWindowNotFoundError = /** @class */ (function (_super) {
__extends(ParentWindowNotFoundError, _super);
function ParentWindowNotFoundError() {
return _super.call(this, TEST_RUN_ERRORS.parentWindowNotFoundError) || this;
}
return ParentWindowNotFoundError;
}(TestRunErrorBase));
var PreviousWindowNotFoundError = /** @class */ (function (_super) {
__extends(PreviousWindowNotFoundError, _super);
function PreviousWindowNotFoundError() {
return _super.call(this, TEST_RUN_ERRORS.previousWindowNotFoundError) || this;
}
return PreviousWindowNotFoundError;
}(TestRunErrorBase));
var ChildWindowClosedBeforeSwitchingError = /** @class */ (function (_super) {
__extends(ChildWindowClosedBeforeSwitchingError, _super);
function ChildWindowClosedBeforeSwitchingError() {
return _super.call(this, TEST_RUN_ERRORS.childWindowClosedBeforeSwitchingError) || this;
}
return ChildWindowClosedBeforeSwitchingError;
}(TestRunErrorBase));
var CannotRestoreChildWindowError = /** @class */ (function (_super) {
__extends(CannotRestoreChildWindowError, _super);
function CannotRestoreChildWindowError() {
return _super.call(this, TEST_RUN_ERRORS.cannotRestoreChildWindowError) || this;
}
return CannotRestoreChildWindowError;
}(TestRunErrorBase));
var CurrentIframeNotFoundError = /** @class */ (function (_super) {
__extends(CurrentIframeNotFoundError, _super);
function CurrentIframeNotFoundError() {
return _super.call(this, TEST_RUN_ERRORS.currentIframeNotFoundError) || this;
}
return CurrentIframeNotFoundError;
}(TestRunErrorBase));
var CurrentIframeIsInvisibleError = /** @class */ (function (_super) {
__extends(CurrentIframeIsInvisibleError, _super);
function CurrentIframeIsInvisibleError() {
return _super.call(this, TEST_RUN_ERRORS.currentIframeIsInvisibleError) || this;
}
return CurrentIframeIsInvisibleError;
}(TestRunErrorBase));
// Native dialog errors
//--------------------------------------------------------------------
var NativeDialogNotHandledError = /** @class */ (function (_super) {
__extends(NativeDialogNotHandledError, _super);
function NativeDialogNotHandledError(dialogType, url) {
var _this = _super.call(this, TEST_RUN_ERRORS.nativeDialogNotHandledError) || this;
_this.dialogType = dialogType;
_this.pageUrl = url;
return _this;
}
return NativeDialogNotHandledError;
}(TestRunErrorBase));
var UncaughtErrorInNativeDialogHandler = /** @class */ (function (_super) {
__extends(UncaughtErrorInNativeDialogHandler, _super);
function UncaughtErrorInNativeDialogHandler(dialogType, errMsg, url) {
var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInNativeDialogHandler) || this;
_this.dialogType = dialogType;
_this.errMsg = errMsg;
_this.pageUrl = url;
return _this;
}
return UncaughtErrorInNativeDialogHandler;
}(TestRunErrorBase));
var ACTION_STEP_DELAY_DEFAULT = 10;
var MAX_MOUSE_ACTION_STEP_DELAY = 400;
var MAX_KEY_ACTION_STEP_DELAY = 200;
// We use an exponential function to calculate the cursor
// speed according to general test speed
// cursorSpeed = (maxSpeed * k) ^ speed / k
var MAX_CURSOR_SPEED = 100; // pixels/ms
var MAX_DRAGGING_SPEED = 4; // pixels/ms
var CURSOR_FACTOR = 4;
var AutomationSettings = /** @class */ (function () {
function AutomationSettings(speed) {
this._speedFactor = speed || 1;
}
Object.defineProperty(AutomationSettings.prototype, "mouseActionStepDelay", {
get: function () {
return this._speedFactor === 1 ? ACTION_STEP_DELAY_DEFAULT : (1 - this._speedFactor) * MAX_MOUSE_ACTION_STEP_DELAY;
},
enumerable: false,
configurable: true
});
Object.defineProperty(AutomationSettings.prototype, "keyActionStepDelay", {
get: function () {
return this._speedFactor === 1 ? ACTION_STEP_DELAY_DEFAULT : (1 - this._speedFactor) * MAX_KEY_ACTION_STEP_DELAY;
},
enumerable: false,
configurable: true
});
Object.defineProperty(AutomationSettings.prototype, "cursorSpeed", {
get: function () {
return Math.pow(MAX_CURSOR_SPEED * CURSOR_FACTOR, this._speedFactor) / CURSOR_FACTOR;
},
enumerable: false,
configurable: true
});
Object.defineProperty(AutomationSettings.prototype, "draggingSpeed", {
get: function () {
return Math.pow(MAX_DRAGGING_SPEED * CURSOR_FACTOR, this._speedFactor) / CURSOR_FACTOR;
},
enumerable: false,
configurable: true
});
return AutomationSettings;
}());
var Promise = hammerhead__default.Promise;
var nativeMethods$4 = hammerhead__default.nativeMethods;
function delay (ms) {
return new Promise(function (resolve) { return nativeMethods$4.setTimeout.call(window, resolve, ms); });
}
function nextTick() {
return delay(0);
}
// -------------------------------------------------------------
// WARNING: this file is used by both the client and the server.
// Do not use any browser or node-specific API!
// -------------------------------------------------------------
var objectToString = Object.prototype.toString;
var stringIndexOf = String.prototype.indexOf;
var stringEndsWith = String.prototype.endsWith
|| function (searchString, position) {
var subjectString = objectToString.call(this);
if (position === void 0 || position > subjectString.length)
position = subjectString.length;
position -= searchString.length;
var lastIndex = stringIndexOf.call(subjectString, searchString, position);
return lastIndex !== -1 && lastIndex === position;
};
// -------------------------------------------------------------
var arrayIndexOf = Array.prototype.indexOf;
var arrayMap = Array.prototype.map;
var arraySort = Array.prototype.sort;
var arrayFilter = Array.prototype.filter;
var arrayConcat = Array.prototype.concat;
var COMMAND_NAME_SUFFIX = 'Command';
function validateObjectProps(obj, dest) {
var objectName = dest.constructor.name;
var validKeys = arrayMap.call(dest.getAllAssignableProperties(), function (p) { return p.name; });
var reportedProperties = arraySort.call(dest.getReportedProperties());
for (var key in obj) {
if (!(arrayIndexOf.call(validKeys, key) > -1 || key in dest))
throw new ActionInvalidObjectPropertyError(objectName, key, reportedProperties);
}
}
function getDisplayTypeName(constructorName, propName) {
if (stringEndsWith.call(constructorName, COMMAND_NAME_SUFFIX))
return propName;
return "".concat(constructorName, ".").concat(propName);
}
var Assignable = /** @class */ (function () {
function Assignable() {
}
Assignable.prototype.getAssignableProperties = function () {
return [];
};
Assignable.prototype.getAllAssignableProperties = function () {
var parent = Object.getPrototypeOf(this);
var result = [];
while (parent && parent.getAssignableProperties) {
result = arrayConcat.call(result, parent.getAssignableProperties());
parent = Object.getPrototypeOf(parent);
}
return result;
};
Assignable.prototype.getNonReportedProperties = function () {
return [];
};
Assignable.prototype.getReportedProperties = function () {
var props = arrayMap.call(this.getAllAssignableProperties(), function (prop) { return prop.name; });
var nonReportedProps = this.getNonReportedProperties();
return arrayFilter.call(props, function (name) { return !(arrayIndexOf.call(nonReportedProps, name) > -1); });
};
Assignable.prototype._assignFrom = function (obj, validate, initOptions) {
if (initOptions === void 0) { initOptions = {}; }
if (!obj)
return;
if (validate)
validateObjectProps(obj, this);
var props = this.getAllAssignableProperties();
for (var i = 0; i < props.length; i++) {
var _a = props[i], name_1 = _a.name, type = _a.type, required = _a.required, init = _a.init, defaultValue = _a.defaultValue;
if (defaultValue !== void 0)
this[name_1] = defaultValue;
var srcVal = obj[name_1];
if (srcVal === void 0 && !required)
continue;
if (validate && type) {
var typeName = getDisplayTypeName(this.constructor.name, name_1);
type(typeName, srcVal);
}
this[name_1] = init ? init(name_1, srcVal, initOptions, validate) : srcVal;
}
};
return Assignable;
}());
// -------------------------------------------------------------
// WARNING: this file is used by both the client and the server.
// Do not use any browser or node-specific API!
// -------------------------------------------------------------
function createIntegerValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'number')
throw new ErrorCtor(name, valType);
var isInteger = !isNaN(val) &&
isFinite(val) &&
val === Math.floor(val);
if (!isInteger)
throw new ErrorCtor(name, val);
};
}
function createPositiveIntegerValidator(ErrorCtor) {
var integerValidator = createIntegerValidator(ErrorCtor);
return function (name, val) {
integerValidator(name, val);
if (val < 0)
throw new ErrorCtor(name, val);
};
}
function createBooleanValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'boolean')
throw new ErrorCtor(name, valType);
};
}
function createSpeedValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'number')
throw new ErrorCtor(name, valType);
if (isNaN(val) || val < 0.01 || val > 1)
throw new ErrorCtor(name, val);
};
}
function createStringValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'string')
throw new ErrorCtor(name, valType);
};
}
function createStringOrRegexValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'string' && !(val instanceof RegExp))
throw new ErrorCtor(name, valType);
};
}
function createDateValidator(ErrorCtor) {
return function (name, val) {
if (!(val instanceof Date))
throw new ErrorCtor(name, val);
};
}
function createNumberValidator(ErrorCtor) {
return function (name, val) {
if (isNaN(Number(val)))
throw new ErrorCtor(name, typeof val);
};
}
function createUrlValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'string' && !(val instanceof URL))
throw new ErrorCtor(name, valType);
};
}
function createUrlSearchParamsValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'object' && !(val instanceof URLSearchParams))
throw new ErrorCtor(name, valType);
};
}
function createObjectValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'object')
throw new ErrorCtor(name, valType);
};
}
function createFunctionValidator(ErrorCtor) {
return function (name, val) {
var valType = typeof val;
if (valType !== 'function')
throw new ErrorCtor(name, valType);
};
}
// -------------------------------------------------------------
var integerOption = createIntegerValidator(ActionIntegerOptionError);
var positiveIntegerOption = createPositiveIntegerValidator(ActionPositiveIntegerOptionError);
var booleanOption = createBooleanValidator(ActionBooleanOptionError);
var speedOption = createSpeedValidator(ActionSpeedOptionError);
var stringOption = createStringValidator(ActionStringOptionError);
var stringOrRegexOption = createStringOrRegexValidator(ActionStringOrRegexOptionError);
var dateOption = createDateValidator(ActionDateOptionError);
var numberOption = createNumberValidator(ActionNumberOptionError);
var urlOption = createUrlValidator(ActionUrlOptionError);
var urlSearchParamsOption = createUrlSearchParamsValidator(ActionUrlSearchParamsOptionError);
var objectOption = createObjectValidator(ActionObjectOptionError);
var functionOption = createFunctionValidator(ActionFunctionOptionError);
// Actions
var ActionOptions = /** @class */ (function (_super) {
__extends(ActionOptions, _super);
function ActionOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.speed = null;
_this._assignFrom(obj, validate);
return _this;
}
ActionOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'speed', type: speedOption },
];
};
return ActionOptions;
}(Assignable));
// Offset
var OffsetOptions = /** @class */ (function (_super) {
__extends(OffsetOptions, _super);
function OffsetOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.offsetX = null;
_this.offsetY = null;
_this._assignFrom(obj, validate);
return _this;
}
OffsetOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'offsetX', type: integerOption },
{ name: 'offsetY', type: integerOption },
{ name: 'isDefaultOffset', type: booleanOption },
];
};
return OffsetOptions;
}(ActionOptions));
var ScrollOptions = /** @class */ (function (_super) {
__extends(ScrollOptions, _super);
function ScrollOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.scrollToCenter = false;
_this.skipParentFrames = false;
_this._assignFrom(obj, validate);
return _this;
}
ScrollOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'scrollToCenter', type: booleanOption },
{ name: 'skipParentFrames', type: booleanOption },
];
};
return ScrollOptions;
}(OffsetOptions));
var CropOptions = /** @class */ (function (_super) {
__extends(CropOptions, _super);
function CropOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
CropOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'left', type: integerOption, defaultValue: null },
{ name: 'right', type: integerOption, defaultValue: null },
{ name: 'top', type: integerOption, defaultValue: null },
{ name: 'bottom', type: integerOption, defaultValue: null },
];
};
return CropOptions;
}(Assignable));
// Element Screenshot
var ElementScreenshotOptions = /** @class */ (function (_super) {
__extends(ElementScreenshotOptions, _super);
function ElementScreenshotOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.scrollTargetX = null;
_this.scrollTargetY = null;
_this.includeMargins = false;
_this.includeBorders = true;
_this.includePaddings = true;
_this.crop = {
left: null,
right: null,
top: null,
bottom: null,
};
_this._assignFrom(obj, validate);
return _this;
}
ElementScreenshotOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'scrollTargetX', type: integerOption },
{ name: 'scrollTargetY', type: integerOption },
{ name: 'crop', type: objectOption, init: initCropOptions },
{ name: 'includeMargins', type: booleanOption },
{ name: 'includeBorders', type: booleanOption },
{ name: 'includePaddings', type: booleanOption },
];
};
return ElementScreenshotOptions;
}(ActionOptions));
var ModifiersOptions = /** @class */ (function (_super) {
__extends(ModifiersOptions, _super);
function ModifiersOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
ModifiersOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'ctrl', type: booleanOption, defaultValue: false },
{ name: 'alt', type: booleanOption, defaultValue: false },
{ name: 'shift', type: booleanOption, defaultValue: false },
{ name: 'meta', type: booleanOption, defaultValue: false },
];
};
return ModifiersOptions;
}(Assignable));
// Mouse
var MouseOptions = /** @class */ (function (_super) {
__extends(MouseOptions, _super);
function MouseOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.modifiers = {
ctrl: false,
alt: false,
shift: false,
meta: false,
};
_this._assignFrom(obj, validate);
return _this;
}
MouseOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'modifiers', type: objectOption, init: initModifiersOptions },
];
};
return MouseOptions;
}(OffsetOptions));
// Click
var ClickOptions = /** @class */ (function (_super) {
__extends(ClickOptions, _super);
function ClickOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.caretPos = null;
_this._assignFrom(obj, validate);
return _this;
}
ClickOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'caretPos', type: positiveIntegerOption },
];
};
return ClickOptions;
}(MouseOptions));
// Move
var MoveOptions = /** @class */ (function (_super) {
__extends(MoveOptions, _super);
function MoveOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.speed = null;
_this.minMovingTime = null;
_this.holdLeftButton = false;
_this.skipScrolling = false;
_this.skipDefaultDragBehavior = false;
_this._assignFrom(obj, validate);
return _this;
}
MoveOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'speed' },
{ name: 'minMovingTime' },
{ name: 'holdLeftButton' },
{ name: 'skipScrolling', type: booleanOption },
{ name: 'skipDefaultDragBehavior', type: booleanOption },
];
};
return MoveOptions;
}(MouseOptions));
// Type
var TypeOptions = /** @class */ (function (_super) {
__extends(TypeOptions, _super);
function TypeOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.replace = false;
_this.paste = false;
_this.confidential = void 0;
_this._assignFrom(obj, validate);
return _this;
}
TypeOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'replace', type: booleanOption },
{ name: 'paste', type: booleanOption },
{ name: 'confidential', type: booleanOption },
];
};
return TypeOptions;
}(ClickOptions));
// DragToElement
var DragToElementOptions = /** @class */ (function (_super) {
__extends(DragToElementOptions, _super);
function DragToElementOptions(obj, validate) {
var _this = _super.call(this, obj, validate) || this;
_this.destinationOffsetX = null;
_this.destinationOffsetY = null;
_this._assignFrom(obj, validate);
return _this;
}
DragToElementOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'destinationOffsetX', type: integerOption },
{ name: 'destinationOffsetY', type: integerOption },
];
};
return DragToElementOptions;
}(MouseOptions));
//ResizeToFitDevice
var ResizeToFitDeviceOptions = /** @class */ (function (_super) {
__extends(ResizeToFitDeviceOptions, _super);
function ResizeToFitDeviceOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.portraitOrientation = false;
_this._assignFrom(obj, validate);
return _this;
}
ResizeToFitDeviceOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'portraitOrientation', type: booleanOption },
];
};
return ResizeToFitDeviceOptions;
}(Assignable));
//Assertion
var AssertionOptions = /** @class */ (function (_super) {
__extends(AssertionOptions, _super);
function AssertionOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.timeout = void 0;
_this.allowUnawaitedPromise = false;
_this._assignFrom(obj, validate);
return _this;
}
AssertionOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'timeout', type: positiveIntegerOption },
{ name: 'allowUnawaitedPromise', type: booleanOption },
];
};
return AssertionOptions;
}(Assignable));
// Press
var PressOptions = /** @class */ (function (_super) {
__extends(PressOptions, _super);
function PressOptions(obj, validate) {
var _this = _super.call(this) || this;
_this.confidential = void 0;
_this._assignFrom(obj, validate);
return _this;
}
PressOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'confidential', type: booleanOption },
];
};
return PressOptions;
}(ActionOptions));
// Cookie
var CookieOptions = /** @class */ (function (_super) {
__extends(CookieOptions, _super);
function CookieOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
CookieOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'name', type: stringOption },
{ name: 'value', type: stringOption },
{ name: 'domain', type: stringOption },
{ name: 'path', type: stringOption },
{ name: 'expires', type: dateOption },
{ name: 'maxAge', type: numberOption },
{ name: 'secure', type: booleanOption },
{ name: 'httpOnly', type: booleanOption },
{ name: 'sameSite', type: stringOption },
];
};
return CookieOptions;
}(Assignable));
var RequestAuthOptions = /** @class */ (function (_super) {
__extends(RequestAuthOptions, _super);
function RequestAuthOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
RequestAuthOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'username', type: stringOption, required: true },
{ name: 'password', type: stringOption },
];
};
return RequestAuthOptions;
}(Assignable));
var RequestProxyOptions = /** @class */ (function (_super) {
__extends(RequestProxyOptions, _super);
function RequestProxyOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
RequestProxyOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'protocol', type: stringOption },
{ name: 'host', type: stringOption, required: true },
{ name: 'port', type: numberOption, required: true },
{ name: 'auth', type: objectOption, init: initRequestAuthOption },
];
};
return RequestProxyOptions;
}(Assignable));
var RequestOptions = /** @class */ (function (_super) {
__extends(RequestOptions, _super);
function RequestOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
RequestOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'url', type: urlOption },
{ name: 'method', type: stringOption },
{ name: 'headers', type: objectOption },
{ name: 'params', type: urlSearchParamsOption },
{ name: 'body' },
{ name: 'timeout', type: numberOption },
{ name: 'withCredentials', type: booleanOption },
{ name: 'auth', type: objectOption, init: initRequestAuthOption },
{ name: 'proxy', type: objectOption, init: initRequestProxyOptions },
{ name: 'rawResponse', type: booleanOption },
];
};
return RequestOptions;
}(Assignable));
var GetProxyUrlOptions = /** @class */ (function (_super) {
__extends(GetProxyUrlOptions, _super);
function GetProxyUrlOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
GetProxyUrlOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'credentials', type: numberOption },
];
};
return GetProxyUrlOptions;
}(Assignable));
var SkipJsErrorsOptions = /** @class */ (function (_super) {
__extends(SkipJsErrorsOptions, _super);
function SkipJsErrorsOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
SkipJsErrorsOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'stack', type: stringOrRegexOption, required: false },
{ name: 'message', type: stringOrRegexOption, required: false },
{ name: 'pageUrl', type: stringOrRegexOption, required: false },
];
};
return SkipJsErrorsOptions;
}(Assignable));
var SkipJsErrorsCallbackWithOptions = /** @class */ (function (_super) {
__extends(SkipJsErrorsCallbackWithOptions, _super);
function SkipJsErrorsCallbackWithOptions(obj, validate) {
var _this = _super.call(this) || this;
_this._assignFrom(obj, validate);
return _this;
}
SkipJsErrorsCallbackWithOptions.prototype.getAssignableProperties = function () {
return [
{ name: 'fn', type: functionOption, required: true },
{ name: 'dependencies', type: objectOption, required: false },
];
};
return SkipJsErrorsCallbackWithOptions;
}(Assignable));
// Initializers
function initRequestAuthOption(name, val, initOptions, validate) {
if (validate === void 0) { validate = true; }
return new RequestAuthOptions(val, validate);
}
function initRequestProxyOptions(name, val, initOptions, validate) {
if (validate === void 0) { validate = true; }
return new RequestProxyOptions(val, validate);
}
function initCropOptions(name, val, initOptions, validate) {
if (validate === void 0) { validate = true; }
return new CropOptions(val, validate);
}
function initModifiersOptions(name, val, initOptions, validate) {
if (validate === void 0) { validate = true; }
return new ModifiersOptions(val, validate);
}
var lastHoveredElement = null;
var lastHoveredElementHolder = {
get: function () {
return lastHoveredElement;
},
set: function (element) {
lastHoveredElement = element;
},
};
var Promise$1 = hammerhead__default.Promise;
var nativeMethods$5 = hammerhead__default.nativeMethods;
var listeners = hammerhead__default.eventSandbox.listeners;
var browserUtils$1 = hammerhead__default.utils.browser;
// Imported form the hammerhead
var BUTTON = hammerhead__default.utils.event.BUTTON;
var BUTTONS_PARAMETER = hammerhead__default.utils.event.BUTTONS_PARAMETER;
var DOM_EVENTS = hammerhead__default.utils.event.DOM_EVENTS;
var WHICH_PARAMETER = hammerhead__default.utils.event.WHICH_PARAMETER;
var preventDefault = hammerhead__default.utils.event.preventDefault;
function whilst(condition, iterator) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!condition()) return [3 /*break*/, 2];
return [4 /*yield*/, iterator()];
case 1:
_a.sent();
return [3 /*break*/, 0];
case 2: return [2 /*return*/];
}
});
});
}
function times(n, iterator) {
return __awaiter(this, void 0, void 0, function () {
var i;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
i = 0;
_a.label = 1;
case 1:
if (!(i < n)) return [3 /*break*/, 4];
return [4 /*yield*/, iterator(i)];
case 2:
_a.sent();
_a.label = 3;
case 3:
i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/];
}
});
});
}
function isIframeWindow(window) {
return window.top !== window;
}
var Promise$2 = hammerhead__default.Promise;
var messageSandbox = hammerhead__default.eventSandbox.message;
function sendRequestToFrame(msg, responseCmd, receiverWindow) {
return new Promise$2(function (resolve) {
function onMessage(e) {
if (e.message.cmd === responseCmd) {
messageSandbox.off(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, onMessage);
resolve(e.message);
}
}
messageSandbox.on(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, onMessage);
messageSandbox.sendServiceMsg(msg, receiverWindow);
});
}
// @ts-ignore
var EventEmitter = /** @class */ (function () {
function EventEmitter() {
this._eventsListeners = {};
}
EventEmitter.prototype.on = function (evt, listener) {
if (!this._eventsListeners[evt])
this._eventsListeners[evt] = [];
this._eventsListeners[evt].push(listener);
};
EventEmitter.prototype.once = function (evt, listener) {
var _this = this;
this.on(evt, function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
_this.off(evt, listener);
return listener.apply(void 0, args);
});
};
EventEmitter.prototype.off = function (evt, listener) {
var listeners = this._eventsListeners[evt];
if (listeners)
this._eventsListeners[evt] = hammerhead.nativeMethods.arrayFilter.call(listeners, function (item) { return item !== listener; });
};
EventEmitter.prototype.offAll = function (evt) {
if (evt)
this._eventsListeners[evt] = [];
else
this._eventsListeners = {};
};
EventEmitter.prototype.emit = function (evt) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var listeners = this._eventsListeners[evt];
if (!listeners)
return;
for (var i = 0; i < listeners.length; i++) {
try {
listeners[i].apply(this, args);
}
catch (e) {
// Hack for IE: after document.write calling IFrameSandbox event handlers
// rises 'Can't execute code from a freed script' exception because document has been
// recreated
if (e.message && e.message.indexOf('freed script') > -1)
this.off(evt, listeners[i]);
else
throw e;
}
}
};
return EventEmitter;
}());
var EventEmitter$1 = EventEmitter;
var listeners$1 = hammerhead.eventSandbox.listeners;
var ScrollController = /** @class */ (function () {
function ScrollController() {
this.initialized = false;
this.stopPropagationFlag = false;
this.events = new EventEmitter$1();
}
ScrollController.prototype._internalListener = function (event, dispatched, preventEvent, cancelHandlers, stopPropagation) {
this.events.emit('scroll', event);
if (this.stopPropagationFlag) {
cancelHandlers();
stopPropagation();
}
};
ScrollController.prototype.init = function () {
var _this = this;
if (this.initialized)
return;
this.initialized = true;
listeners$1.initElementListening(window, ['scroll']);
listeners$1.addFirstInternalEventBeforeListener(window, ['scroll'], function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return _this._internalListener.apply(_this, args);
});
};
ScrollController.prototype.waitForScroll = function (scrollElement) {
var _this = this;
var promiseResolver = null;
var promise = new hammerhead.Promise(function (resolve) {
promiseResolver = resolve;
});
promise.cancel = function () { return _this.events.off('scroll', promiseResolver); };
if (this.initialized)
this.handleScrollEvents(scrollElement, promiseResolver);
else
promiseResolver();
return promise;
};
ScrollController.prototype.handleScrollEvents = function (el, handler) {
var _this = this;
this.events.once('scroll', handler);
if (isShadowElement(el)) {
listeners$1.initElementListening(el, ['scroll']);
listeners$1.addFirstInternalEventBeforeListener(el, ['scroll'], function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
_this._internalListener.apply(_this, args);
listeners$1.cancelElementListening(el);
});
}
};
ScrollController.prototype.stopPropagation = function () {
this.stopPropagationFlag = true;
};
ScrollController.prototype.enablePropagation = function () {
this.stopPropagationFlag = false;
};
return ScrollController;
}());
var scrollController = new ScrollController();
var DEFAULT_MAX_SCROLL_MARGIN = 50;
var SCROLL_MARGIN_INCREASE_STEP = 20;
var ScrollAutomation = /** @class */ (function () {
function ScrollAutomation(element, scrollOptions, maxScrollMargin) {
this._element = element;
this._offsets = new AxisValues(scrollOptions.offsetX, scrollOptions.offsetY);
this._scrollToCenter = !!scrollOptions.scrollToCenter;
this._skipParentFrames = !!scrollOptions.skipParentFrames;
this._maxScrollMargin = maxScrollMargin || { left: DEFAULT_MAX_SCROLL_MARGIN, top: DEFAULT_MAX_SCROLL_MARGIN };
this._scrollWasPerformed = false;
}
ScrollAutomation._isScrollValuesChanged = function (scrollElement, originalScroll) {
return getScrollLeft(scrollElement) !== originalScroll.left ||
getScrollTop(scrollElement) !== originalScroll.top;
};
ScrollAutomation.prototype._setScroll = function (element, _a) {
var _this = this;
var left = _a.left, top = _a.top;
var scrollElement = isHtmlElement(element) ? findDocument(element) : element;
var originalScroll = {
left: getScrollLeft(scrollElement),
top: getScrollTop(scrollElement),
};
left = Math.max(left, 0);
top = Math.max(top, 0);
var scrollPromise = scrollController.waitForScroll(scrollElement);
setScrollLeft(scrollElement, left);
setScrollTop(scrollElement, top);
if (!ScrollAutomation._isScrollValuesChanged(scrollElement, originalScroll)) {
// @ts-ignore
scrollPromise.cancel();
return hammerhead.Promise.resolve();
}
scrollPromise = scrollPromise.then(function () {
if (!_this._scrollWasPerformed)
_this._scrollWasPerformed = ScrollAutomation._isScrollValuesChanged(scrollElement, originalScroll);
});
return scrollPromise;
};
ScrollAutomation.prototype._getScrollToPoint = function (dimensions, point, maxScrollMargin) {
var horizontalCenter = Math.floor(dimensions.width / 2);
var verticalCenter = Math.floor(dimensions.height / 2);
var leftScrollMargin = this._scrollToCenter ? horizontalCenter : Math.min(maxScrollMargin.left, horizontalCenter);
var topScrollMargin = this._scrollToCenter ? verticalCenter : Math.min(maxScrollMargin.top, verticalCenter);
var _a = dimensions.scroll, left = _a.left, top = _a.top;
var needForwardScrollLeft = point.x >= left + dimensions.width - leftScrollMargin;
var needBackwardScrollLeft = point.x <= left + leftScrollMargin;
var needForwardScrollTop = point.y >= top + dimensions.height - topScrollMargin;
var needBackwardScrollTop = point.y <= top + topScrollMargin;
if (needForwardScrollLeft)
left = point.x - dimensions.width + leftScrollMargin;
else if (needBackwardScrollLeft)
left = point.x - leftScrollMargin;
if (needForwardScrollTop)
top = point.y - dimensions.height + topScrollMargin;
else if (needBackwardScrollTop)
top = point.y - topScrollMargin;
return { left: left, top: top };
};
ScrollAutomation.prototype._getScrollToFullChildView = function (parentDimensions, childDimensions, maxScrollMargin) {
var fullViewScroll = { left: null, top: null };
var canShowFullElementWidth = parentDimensions.width >= childDimensions.width;
var canShowFullElementHeight = parentDimensions.height >= childDimensions.height;
var relativePosition = calcRelativePosition(childDimensions, parentDimensions);
if (canShowFullElementWidth) {
var availableLeftScrollMargin = parentDimensions.width - childDimensions.width;
var leftScrollMargin = Math.min(maxScrollMargin.left, availableLeftScrollMargin);
if (this._scrollToCenter)
leftScrollMargin = availableLeftScrollMargin / 2;
if (relativePosition.left < leftScrollMargin)
fullViewScroll.left = Math.round(parentDimensions.scroll.left + relativePosition.left - leftScrollMargin);
else if (relativePosition.right < leftScrollMargin) {
fullViewScroll.left = Math.round(parentDimensions.scroll.left +
Math.min(relativePosition.left, -relativePosition.right) +
leftScrollMargin);
}
}
if (canShowFullElementHeight) {
var availableTopScrollMargin = parentDimensions.height - childDimensions.height;
var topScrollMargin = Math.min(maxScrollMargin.top, availableTopScrollMargin);
if (this._scrollToCenter)
topScrollMargin = availableTopScrollMargin / 2;
if (relativePosition.top < topScrollMargin)
fullViewScroll.top = Math.round(parentDimensions.scroll.top + relativePosition.top - topScrollMargin);
else if (relativePosition.bottom < topScrollMargin) {
fullViewScroll.top = Math.round(parentDimensions.scroll.top +
Math.min(relativePosition.top, -relativePosition.bottom) +
topScrollMargin);
}
}
return fullViewScroll;
};
ScrollAutomation._getChildPoint = function (parentDimensions, childDimensions, offsets) {
return AxisValues.create(childDimensions)
.sub(AxisValues.create(parentDimensions))
.add(AxisValues.create(parentDimensions.scroll))
.add(AxisValues.create(childDimensions.border))
.add(offsets);
};
ScrollAutomation.prototype._getScrollPosition = function (parentDimensions, childDimensions, offsets, maxScrollMargin) {
var childPoint = ScrollAutomation._getChildPoint(parentDimensions, childDimensions, offsets);
var scrollToPoint = this._getScrollToPoint(parentDimensions, childPoint, maxScrollMargin);
var scrollToFullView = this._getScrollToFullChildView(parentDimensions, childDimensions, maxScrollMargin);
return {
left: Math.max(scrollToFullView.left === null ? scrollToPoint.left : scrollToFullView.left, 0),
top: Math.max(scrollToFullView.top === null ? scrollToPoint.top : scrollToFullView.top, 0),
};
};
ScrollAutomation._getChildPointAfterScroll = function (parentDimensions, childDimensions, currentScroll, offsets) {
return AxisValues.create(childDimensions)
.add(AxisValues.create(parentDimensions.scroll))
.sub(AxisValues.create(currentScroll))
.add(offsets);
};
ScrollAutomation.prototype._isChildFullyVisible = function (parentDimensions, childDimensions, offsets) {
var childPoint = ScrollAutomation._getChildPointAfterScroll(parentDimensions, childDimensions, parentDimensions.scroll, offsets);
var zeroMargin = { left: 0, top: 0 };
var _a = this._getScrollPosition(parentDimensions, childDimensions, offsets, zeroMargin), left = _a.left, top = _a.top;
return !this._isTargetElementObscuredInPoint(childPoint) &&
left === parentDimensions.scroll.left && top === parentDimensions.scroll.top;
};
ScrollAutomation.prototype._scrollToChild = function (parent, child, offsets) {
var parentDimensions = getClientDimensions(parent);
var childDimensions = getClientDimensions(child);
var windowWidth = getInnerWidth(window);
var windowHeight = getInnerHeight(window);
var scrollPos = parentDimensions.scroll;
var needScroll = !this._isChildFullyVisible(parentDimensions, childDimensions, offsets);
while (needScroll) {
scrollPos = this._getScrollPosition(parentDimensions, childDimensions, offsets, this._maxScrollMargin);
var childPoint = ScrollAutomation._getChildPointAfterScroll(parentDimensions, childDimensions, scrollPos, offsets);
var isTargetObscured = this._isTargetElementObscuredInPoint(childPoint);
this._maxScrollMargin.left += SCROLL_MARGIN_INCREASE_STEP;
if (this._maxScrollMargin.left >= windowWidth) {
this._maxScrollMargin.left = DEFAULT_MAX_SCROLL_MARGIN;
this._maxScrollMargin.top += SCROLL_MARGIN_INCREASE_STEP;
}
needScroll = isTargetObscured && this._maxScrollMargin.top < windowHeight;
}
this._maxScrollMargin = { left: DEFAULT_MAX_SCROLL_MARGIN, top: DEFAULT_MAX_SCROLL_MARGIN };
return this._setScroll(parent, scrollPos);
};
ScrollAutomation.prototype._scrollElement = function () {
if (!hasScroll(this._element))
return hammerhead.Promise.resolve();
var elementDimensions = getClientDimensions(this._element);
var scroll = this._getScrollToPoint(elementDimensions, this._offsets, this._maxScrollMargin);
return this._setScroll(this._element, scroll);
};
ScrollAutomation.prototype._scrollParents = function () {
var _this = this;
var parents = getScrollableParents(this._element);
var currentChild = this._element;
var scrollLeft = getScrollLeft(currentChild);
var scrollTop = getScrollTop(currentChild);
var currentOffset = AxisValues.create(this._offsets).sub(new AxisValues(scrollLeft, scrollTop).round());
var childDimensions = null;
var parentDimensions = null;
var scrollParentsPromise = times(parents.length, function (i) {
return _this._scrollToChild(parents[i], currentChild, currentOffset)
.then(function () {
childDimensions = getClientDimensions(currentChild);
parentDimensions = getClientDimensions(parents[i]);
currentOffset.add(AxisValues.create(childDimensions))
.sub(AxisValues.create(parentDimensions))
.add(AxisValues.create(parentDimensions.border));
currentChild = parents[i];
});
});
var state = {
scrollWasPerformed: this._scrollWasPerformed,
offsetX: currentOffset.x,
offsetY: currentOffset.y,
maxScrollMargin: this._maxScrollMargin,
};
if (!sendRequestToFrame)
return scrollParentsPromise.then(function () { return state; });
return scrollParentsPromise
.then(function () {
if (_this._skipParentFrames || !isIframeWindow(window))
return;
state.cmd = ScrollAutomation.SCROLL_REQUEST_CMD;
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion, consistent-return
return sendRequestToFrame(state, ScrollAutomation.SCROLL_RESPONSE_CMD, window.parent);
})
.then(function () { return _this._scrollWasPerformed; });
};
ScrollAutomation._getFixedAncestorOrSelf = function (element) {
return findParent(element, true, isFixedElement);
};
ScrollAutomation.prototype._isTargetElementObscuredInPoint = function (point) {
var elementInPoint = getElementFromPoint(point);
if (!elementInPoint)
return false;
var fixedElement = ScrollAutomation._getFixedAncestorOrSelf(elementInPoint);
return !!fixedElement && !fixedElement.contains(this._element);
};
ScrollAutomation.prototype.run = function () {
var _this = this;
return this._scrollElement()
.then(function () { return _this._scrollParents(); });
};
ScrollAutomation.SCROLL_REQUEST_CMD = 'automation|scroll|request';
ScrollAutomation.SCROLL_RESPONSE_CMD = 'automation|scroll|response';
return ScrollAutomation;
}());
var browserUtils$2 = hammerhead__default.utils.browser;
var MoveEventSequenceBase = /** @class */ (function () {
function MoveEventSequenceBase(_a) {
var moveEvent = _a.moveEvent;
this.dragAndDropMode = false;
this.dropAllowed = false;
this.moveEvent = moveEvent;
}
MoveEventSequenceBase.prototype.setup = function () {
this.dragAndDropMode = false;
this.dropAllowed = false;
};
MoveEventSequenceBase.prototype.leaveElement = function ( /* currentElement, prevElement, commonAncestor, options */) {
};
MoveEventSequenceBase.prototype.move = function ( /* element, options */) {
};
MoveEventSequenceBase.prototype.enterElement = function ( /* currentElement, prevElement, commonAncestor, options */) {
};
MoveEventSequenceBase.prototype.dragAndDrop = function ( /* dragElement, currentElement, prevElement, options, dragDataStore */) {
};
MoveEventSequenceBase.prototype.teardown = function ( /* currentElement, eventOptions, prevElement */) {
};
MoveEventSequenceBase.prototype.run = function (currentElement, prevElement, options, dragElement, dragDataStore) {
// NOTE: if last hovered element was in an iframe that has been removed, IE
// raises an exception when we try to compare it with the current element
var prevElementInDocument = prevElement && testCafeCore.domUtils.isElementInDocument(prevElement);
var prevElementInRemovedIframe = prevElement && testCafeCore.domUtils.isElementInIframe(prevElement) &&
!testCafeCore.domUtils.getIframeByElement(prevElement);
if (!prevElementInDocument || prevElementInRemovedIframe)
prevElement = null;
var elementChanged = currentElement !== prevElement;
var commonAncestor = elementChanged ? testCafeCore.domUtils.getCommonAncestor(currentElement, prevElement) : null;
this.setup();
if (elementChanged && !!prevElement)
this.leaveElement(currentElement, prevElement, commonAncestor, options);
if (browserUtils$2.isIE)
this.move(currentElement, options);
if (elementChanged && testCafeCore.domUtils.isElementInDocument(currentElement))
this.enterElement(currentElement, prevElement, commonAncestor, options);
if (!browserUtils$2.isIE)
this.move(currentElement, options);
this.dragAndDrop(dragElement, currentElement, prevElement, options, dragDataStore);
this.teardown(currentElement, options, prevElement);
var dragAndDropMode = this.dragAndDropMode;
var dropAllowed = this.dropAllowed;
this.dragAndDropMode = false;
this.dropAllowed = false;
return { dragAndDropMode: dragAndDropMode, dropAllowed: dropAllowed };
};
return MoveEventSequenceBase;
}());
var eventSimulator = hammerhead__default.eventSandbox.eventSimulator;
var extend = hammerhead__default.utils.extend;
var nativeMethods$6 = hammerhead__default.nativeMethods;
var MoveBehaviour = /** @class */ (function () {
function MoveBehaviour() {
}
MoveBehaviour.leaveElement = function (currentElement, prevElement, commonAncestor, options) {
eventSimulator.mouseout(prevElement, extend({ relatedTarget: currentElement }, options));
var currentParent = prevElement;
while (currentParent && currentParent !== commonAncestor) {
eventSimulator.mouseleave(currentParent, extend({ relatedTarget: currentElement }, options));
currentParent = nativeMethods$6.nodeParentNodeGetter.call(currentParent);
}
};
MoveBehaviour.enterElement = function (currentElement, prevElement, commonAncestor, options) {
eventSimulator.mouseover(currentElement, extend({ relatedTarget: prevElement }, options));
var currentParent = currentElement;
var mouseenterElements = [];
while (currentParent && currentParent !== commonAncestor) {
mouseenterElements.push(currentParent);
currentParent = testCafeCore.domUtils.getParentExceptShadowRoot(currentParent);
}
for (var i = mouseenterElements.length - 1; i > -1; i--)
eventSimulator.mouseenter(mouseenterElements[i], extend({ relatedTarget: prevElement }, options));
};
MoveBehaviour.move = function (moveEvent, element, options) {
eventSimulator[moveEvent](element, options);
};
return MoveBehaviour;
}());
var DragAndDropBehavior = /** @class */ (function () {
function DragAndDropBehavior() {
}
DragAndDropBehavior.dragAndDrop = function (dragElement, currentElement, prevElement, options) {
eventSimulator.drag(dragElement, options);
var currentElementChanged = currentElement !== prevElement;
if (currentElementChanged) {
if (testCafeCore.domUtils.isElementInDocument(currentElement)) {
options.relatedTarget = prevElement;
eventSimulator.dragenter(currentElement, options);
}
if (prevElement) {
options.relatedTarget = currentElement;
eventSimulator.dragleave(prevElement, options);
}
}
return !eventSimulator.dragover(currentElement, options);
};
return DragAndDropBehavior;
}());
var eventSimulator$1 = hammerhead__default.eventSandbox.eventSimulator;
var TOUCH_MOVE_EVENT_NAME = 'touchmove';
var MoveEventSequence = /** @class */ (function (_super) {
__extends(MoveEventSequence, _super);
function MoveEventSequence(options) {
var _this = _super.call(this, options) || this;
_this.holdLeftButton = options.holdLeftButton;
return _this;
}
MoveEventSequence.prototype.leaveElement = function (currentElement, prevElement, commonAncestor, options) {
MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
};
MoveEventSequence.prototype.enterElement = function (currentElement, prevElement, commonAncestor, options) {
MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
};
MoveEventSequence.prototype.move = function (element, options) {
if (this._needEmulateMoveEvent())
MoveBehaviour.move(this.moveEvent, element, options);
};
MoveEventSequence.prototype.teardown = function (currentElement, eventOptions, prevElement) {
// NOTE: we need to add an extra 'mousemove' if the element was changed because sometimes
// the client script requires several 'mousemove' events for an element (T246904)
if (this._needEmulateMoveEvent() && testCafeCore.domUtils.isElementInDocument(currentElement) && currentElement !== prevElement)
eventSimulator$1[this.moveEvent](currentElement, eventOptions);
};
MoveEventSequence.prototype._needEmulateMoveEvent = function () {
return this.moveEvent !== TOUCH_MOVE_EVENT_NAME || this.holdLeftButton;
};
return MoveEventSequence;
}(MoveEventSequenceBase));
var DragAndDropMoveEventSequence = /** @class */ (function (_super) {
__extends(DragAndDropMoveEventSequence, _super);
function DragAndDropMoveEventSequence() {
return _super !== null && _super.apply(this, arguments) || this;
}
DragAndDropMoveEventSequence.prototype.setup = function () {
_super.prototype.setup.call(this);
this.dragAndDropMode = true;
};
DragAndDropMoveEventSequence.prototype.dragAndDrop = function (dragElement, currentElement, prevElement, options) {
this.dropAllowed = DragAndDropBehavior.dragAndDrop(dragElement, currentElement, prevElement, options);
};
return DragAndDropMoveEventSequence;
}(MoveEventSequenceBase));
var eventSimulator$2 = hammerhead__default.eventSandbox.eventSimulator;
var DragAndDropFirstMoveEventSequence = /** @class */ (function (_super) {
__extends(DragAndDropFirstMoveEventSequence, _super);
function DragAndDropFirstMoveEventSequence() {
return _super !== null && _super.apply(this, arguments) || this;
}
DragAndDropFirstMoveEventSequence.prototype.setup = function () {
_super.prototype.setup.call(this);
this.dragAndDropMode = true;
};
DragAndDropFirstMoveEventSequence.prototype.leaveElement = function (currentElement, prevElement, commonAncestor, options) {
MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
};
DragAndDropFirstMoveEventSequence.prototype.move = function (element, option) {
MoveBehaviour.move(this.moveEvent, element, option);
};
DragAndDropFirstMoveEventSequence.prototype.enterElement = function (currentElement, prevElement, commonAncestor, options) {
MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
};
DragAndDropFirstMoveEventSequence.prototype.dragAndDrop = function (dragElement, currentElement, prevElement, options, dragDataStore) {
var dragAllowed = eventSimulator$2.dragstart(dragElement, options);
dragDataStore.setReadOnlyMode();
if (!dragAllowed) {
this.dragAndDropMode = false;
return;
}
this.dropAllowed = DragAndDropBehavior.dragAndDrop(dragElement, currentElement, prevElement, options);
};
DragAndDropFirstMoveEventSequence.prototype.run = function (currentElement, prevElement, options, dragElement, dragDataStore) {
return _super.prototype.run.call(this, currentElement, null, options, dragElement, dragDataStore);
};
return DragAndDropFirstMoveEventSequence;
}(MoveEventSequenceBase));
function createEventSequence(dragAndDropEnabled, firstMovingStepOccured, options) {
if (!dragAndDropEnabled)
return new MoveEventSequence(options);
if (firstMovingStepOccured)
return new DragAndDropMoveEventSequence(options);
return new DragAndDropFirstMoveEventSequence(options);
}
var MOVE_REQUEST_CMD = 'automation|move|request';
var MOVE_RESPONSE_CMD = 'automation|move|response';
var MoveAutomation = /** @class */ (function () {
function MoveAutomation(el, offset, moveOptions, win, cursor) {
this.touchMode = hammerhead.utils.featureDetection.isTouchDevice;
this.moveEvent = this.touchMode ? 'touchmove' : 'mousemove';
this.automationSettings = new AutomationSettings(moveOptions.speed);
this.cursorSpeed = this._getCursorSpeed();
this.element = el;
this.window = win;
this.offset = offset;
this.cursor = cursor;
this.minMovingTime = moveOptions.minMovingTime || 0;
this.modifiers = moveOptions.modifiers || {};
this.skipScrolling = moveOptions.skipScrolling;
this.skipDefaultDragBehavior = moveOptions.skipDefaultDragBehavior;
this.speed = moveOptions.speed;
this.firstMovingStepOccured = false;
}
MoveAutomation.create = function (el, moveOptions, win, cursor) {
return __awaiter(this, void 0, hammerhead.Promise, function () {
var _a, element, offset;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, MoveAutomation.getTarget(el, win, new AxisValues(moveOptions.offsetX, moveOptions.offsetY))];
case 1:
_a = _b.sent(), element = _a.element, offset = _a.offset;
return [2 /*return*/, new MoveAutomation(element, offset, moveOptions, win, cursor)];
}
});
});
};
MoveAutomation.getTarget = function (element, window, offset) {
// NOTE: if the target point (considering offsets) is out of
// the element change the target element to the document element
return hammerhead.Promise.resolve(containsOffset(element, offset.x, offset.y))
.then(function (containsOffset) {
if (!containsOffset) {
return hammerhead.Promise.all([
getAutomationPoint(element, offset),
getDocumentElement(window),
])
.then(function (_a) {
var point = _a[0], docEl = _a[1];
return ({ element: docEl, offset: point });
});
}
return { element: element, offset: offset };
});
};
MoveAutomation.prototype._getCursorSpeed = function () {
return this.automationSettings.cursorSpeed;
};
MoveAutomation.prototype._getTargetClientPoint = function () {
var _this = this;
return hammerhead.Promise.resolve(getElementScroll(this.element))
.then(function (scroll) {
if (isHtmlElement(_this.element)) {
return AxisValues.create(_this.offset)
.sub(AxisValues.create(scroll))
.round(Math.round);
}
return hammerhead.Promise.resolve(getClientPosition(_this.element))
.then(function (clientPosition) {
var isDocumentBody = isBodyElement(_this.element);
// @ts-ignore
var clientPoint = AxisValues.create(clientPosition).add(_this.offset);
if (!isDocumentBody)
clientPoint.sub(AxisValues.create(scroll));
return clientPoint.round(Math.floor);
});
});
};
MoveAutomation.prototype._getEventSequenceOptions = function (currPosition) {
var button = BUTTONS_PARAMETER.noButton;
var devicePoint = getDevicePoint(currPosition);
var eventOptions = {
clientX: currPosition.x,
clientY: currPosition.y,
screenX: devicePoint === null || devicePoint === void 0 ? void 0 : devicePoint.x,
screenY: devicePoint === null || devicePoint === void 0 ? void 0 : devicePoint.y,
buttons: button,
ctrl: this.modifiers.ctrl,
alt: this.modifiers.alt,
shift: this.modifiers.shift,
meta: this.modifiers.meta,
};
return { eventOptions: eventOptions, eventSequenceOptions: { moveEvent: this.moveEvent } };
};
MoveAutomation.prototype._runEventSequence = function (currentElement, _a) {
var eventOptions = _a.eventOptions, eventSequenceOptions = _a.eventSequenceOptions;
var eventSequence = createEventSequence(false, this.firstMovingStepOccured, eventSequenceOptions);
return eventSequence.run(currentElement, lastHoveredElementHolder.get(), eventOptions, null, null);
};
MoveAutomation.prototype._emulateEvents = function (currentElement, currPosition) {
var options = this._getEventSequenceOptions(currPosition);
this._runEventSequence(currentElement, options);
this.firstMovingStepOccured = true;
lastHoveredElementHolder.set(currentElement);
};
MoveAutomation.prototype._movingStep = function (currPosition) {
var _this = this;
return this.cursor.move(currPosition)
.then(function () { return getElementFromPoint$1(_this.cursor.getPosition()); })
// NOTE: in touch mode, events are simulated for the element for which mousedown was simulated (GH-372)
.then(function (topElement) {
var currentElement = _this._getCorrectedTopElement(topElement);
// NOTE: it can be null in IE
if (!currentElement)
return null;
return _this._emulateEvents(currentElement, currPosition);
})
.then(nextTick);
};
MoveAutomation.prototype._getCorrectedTopElement = function (topElement) {
return topElement;
};
MoveAutomation.prototype._move = function (endPoint) {
var _this = this;
var startPoint = this.cursor.getPosition();
var distance = AxisValues.create(endPoint).sub(startPoint);
var startTime = hammerhead.nativeMethods.dateNow();
var movingTime = Math.max(Math.max(Math.abs(distance.x), Math.abs(distance.y)) / this.cursorSpeed, this.minMovingTime);
var currPosition = AxisValues.create(startPoint);
var isFirstStep = true;
return whilst(function () { return !currPosition.eql(endPoint); }, function () {
if (_this._needMoveCursorImmediately())
currPosition = AxisValues.create(endPoint);
else if (isFirstStep) {
isFirstStep = false;
// NOTE: the mousemove event can't be simulated at the point where the cursor
// was located at the start. Therefore, we add a minimal distance 1 px.
currPosition.add({
x: distance.x > 0 ? 1 : -1,
y: distance.y > 0 ? 1 : -1,
});
}
else {
var progress = Math.min((hammerhead.nativeMethods.dateNow() - startTime) / movingTime, 1);
currPosition = AxisValues.create(distance).mul(progress).add(startPoint).round(Math.floor);
}
return _this._movingStep(currPosition);
});
};
//
MoveAutomation.prototype._needMoveCursorImmediately = function () {
return this.touchMode;
};
MoveAutomation.prototype._scroll = function () {
if (this.skipScrolling)
return hammerhead.Promise.resolve(false);
var scrollOptions = new ScrollOptions({ offsetX: this.offset.x, offsetY: this.offset.y }, false);
var scrollAutomation = new ScrollAutomation(this.element, scrollOptions);
return scrollAutomation.run();
};
MoveAutomation.prototype._moveToCurrentFrame = function (endPoint) {
var _this = this;
if (this.cursor.isActive(this.window))
return hammerhead.Promise.resolve();
var _a = this.cursor.getPosition(), x = _a.x, y = _a.y;
var activeWindow = this.cursor.getActiveWindow(this.window);
var iframe = null;
var iframeUnderCursor = null;
var msg = {
cmd: MOVE_REQUEST_CMD,
startX: x,
startY: y,
endX: endPoint.x,
endY: endPoint.y,
modifiers: this.modifiers,
speed: this.speed,
shouldRender: this.cursor.shouldRender,
};
return hammerhead.Promise.resolve()
.then(function () {
if (activeWindow.parent === _this.window) {
return hammerhead.Promise.resolve(findIframeByWindow(activeWindow))
.then(function (frame) {
iframe = frame;
return hammerhead.Promise.resolve(getIframeClientCoordinates(frame))
.then(function (rect) {
msg.left = rect.left;
msg.top = rect.top;
msg.right = rect.right;
msg.bottom = rect.bottom;
});
});
}
return void 0;
})
.then(function () {
return getElementFromPoint$1(_this.cursor.getPosition());
})
.then(function (topElement) {
iframeUnderCursor = topElement === iframe;
if (activeWindow.parent === _this.window)
msg.iframeUnderCursor = iframeUnderCursor;
return sendRequestToFrame(msg, MOVE_RESPONSE_CMD, activeWindow);
})
.then(function (message) {
_this.cursor.setActiveWindow(_this.window);
if (iframeUnderCursor || hammerhead.utils.dom.isIframeWindow(_this.window))
return _this.cursor.move(message);
return void 0;
});
};
MoveAutomation.prototype.run = function () {
var _this = this;
return this._scroll()
.then(function () { return hammerhead.Promise.all([
_this._getTargetClientPoint(),
getWindowDimensions(_this.window),
]); })
.then(function (_a) {
var endPoint = _a[0], boundary = _a[1];
if (!boundary.contains(endPoint))
return void 0;
return _this._moveToCurrentFrame(endPoint)
.then(function () { return _this._move(endPoint); });
});
};
return MoveAutomation;
}());
var Cursor = /** @class */ (function () {
function Cursor(activeWin, ui) {
this._ui = ui;
// NOTE: the default position should be outside the page (GH-794)
this._x = -1;
this._y = -1;
this._activeWindow = activeWin;
}
Cursor.prototype._ensureActiveWindow = function (win) {
if (this._activeWindow === win || this._activeWindow === win.parent)
return;
if (this._activeWindow.parent !== win)
this._activeWindow = win;
};
Cursor.prototype.isActive = function (currWin) {
this._ensureActiveWindow(currWin);
return this._activeWindow === currWin;
};
Cursor.prototype.setActiveWindow = function (win) {
this._activeWindow = win;
};
Cursor.prototype.getActiveWindow = function (currWin) {
this._ensureActiveWindow(currWin);
return this._activeWindow;
};
Cursor.prototype.getPosition = function () {
return new AxisValues(this._x, this._y);
};
Object.defineProperty(Cursor.prototype, "shouldRender", {
get: function () {
return this._ui.shouldRender;
},
set: function (val) {
this._ui.shouldRender = val;
},
enumerable: false,
configurable: true
});
Cursor.prototype.move = function (point) {
this._x = point.x;
this._y = point.y;
return this._ui.move(point);
};
Cursor.prototype.hide = function () {
if (this._ui.hide)
return this._ui.hide();
return hammerhead.Promise.resolve();
};
Cursor.prototype.show = function () {
if (this._ui.show)
return this._ui.show();
return hammerhead.Promise.resolve();
};
Cursor.prototype.leftButtonDown = function () {
return this._ui.leftButtonDown();
};
Cursor.prototype.rightButtonDown = function () {
return this._ui.rightButtonDown();
};
Cursor.prototype.buttonUp = function () {
return this._ui.buttonUp();
};
return Cursor;
}());
var cursorUI = !isIframeWindow(window) ? testCafeUI.cursorUI : testCafeUI.iframeCursorUI;
var cursor = new Cursor(window.top, cursorUI);
var positionUtils$1 = testCafeCore__default.positionUtils, domUtils = testCafeCore__default.domUtils, eventUtils = testCafeCore__default.eventUtils;
function ensureMouseEventAfterScroll(currentElement, element, wasScrolled) {
return __awaiter(this, void 0, hammerhead__default.Promise, function () {
var elementUnderCursorContainsTarget, prevElement, commonAncestor, clientPosition, devicePoint, options;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
elementUnderCursorContainsTarget = !!currentElement && domUtils.contains(element, currentElement);
if (!elementUnderCursorContainsTarget || !wasScrolled)
return [2 /*return*/];
prevElement = lastHoveredElementHolder.get();
commonAncestor = domUtils.getCommonAncestor(currentElement, prevElement);
return [4 /*yield*/, positionUtils$1.getClientPosition(currentElement)];
case 1:
clientPosition = _a.sent();
return [4 /*yield*/, getDevicePoint(clientPosition)];
case 2:
devicePoint = _a.sent();
if (!devicePoint)
return [2 /*return*/];
options = {
clientX: clientPosition.x,
clientY: clientPosition.y,
screenX: devicePoint.x,
screenY: devicePoint.y,
ctrl: false,
alt: false,
shift: false,
meta: false,
buttons: eventUtils.BUTTONS_PARAMETER.leftButton,
};
MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
lastHoveredElementHolder.set(currentElement);
return [2 /*return*/];
}
});
});
}
var WARNING_TYPES = {
elementOverlapped: 'elementOverlapped',
};
var EventType;
(function (EventType) {
EventType[EventType["Mouse"] = 0] = "Mouse";
EventType[EventType["Key"] = 1] = "Key";
EventType[EventType["Touch"] = 2] = "Touch";
})(EventType || (EventType = {}));
var KeyModifierValues;
(function (KeyModifierValues) {
KeyModifierValues[KeyModifierValues["alt"] = 1] = "alt";
KeyModifierValues[KeyModifierValues["ctrl"] = 2] = "ctrl";
KeyModifierValues[KeyModifierValues["meta"] = 4] = "meta";
KeyModifierValues[KeyModifierValues["shift"] = 8] = "shift";
})(KeyModifierValues || (KeyModifierValues = {}));
function calculateKeyModifiersValue(modifiers) {
var result = 0;
if (modifiers.ctrl)
result |= KeyModifierValues.ctrl;
if (modifiers.alt)
result |= KeyModifierValues.alt;
if (modifiers.shift)
result |= KeyModifierValues.shift;
if (modifiers.meta)
result |= KeyModifierValues.meta;
return result;
}
function calculateMouseButtonValue(options) {
if (!options.button)
return 'left';
return 'right';
}
var MOUSE_EVENT_OPTIONS = {
clickCount: 1,
button: 'left',
};
var ProxylessEventSimulator = /** @class */ (function () {
function ProxylessEventSimulator(dispatchEventFn, leftTopPoint) {
this._dispatchEventFn = dispatchEventFn;
this._leftTopPoint = leftTopPoint || new AxisValues(0, 0);
}
ProxylessEventSimulator.prototype._createMouseEventOptions = function (type, options) {
return hammerhead.utils.extend({
x: options.options.clientX + this._leftTopPoint.x,
y: options.options.clientY + this._leftTopPoint.y,
modifiers: calculateKeyModifiersValue(options.options),
button: calculateMouseButtonValue(options.options),
type: type,
}, MOUSE_EVENT_OPTIONS);
};
ProxylessEventSimulator.prototype.mouseDown = function (options) {
var eventOptions = this._createMouseEventOptions('mousePressed', options);
return this._dispatchEventFn(EventType.Mouse, eventOptions);
};
ProxylessEventSimulator.prototype.mouseUp = function (options) {
var eventOptions = this._createMouseEventOptions('mouseReleased', options);
return this._dispatchEventFn(EventType.Mouse, eventOptions);
};
return ProxylessEventSimulator;
}());
var AVAILABLE_OFFSET_DEEP = 2;
var ElementState = /** @class */ (function () {
function ElementState(_a) {
var _b = _a.element, element = _b === void 0 ? null : _b, _c = _a.clientPoint, clientPoint = _c === void 0 ? null : _c, _d = _a.screenPoint, screenPoint = _d === void 0 ? null : _d, _e = _a.isTarget, isTarget = _e === void 0 ? false : _e, _f = _a.inMoving, inMoving = _f === void 0 ? false : _f, _g = _a.devicePoint, devicePoint = _g === void 0 ? null : _g;
this.element = element;
this.clientPoint = clientPoint;
this.screenPoint = screenPoint;
this.devicePoint = devicePoint;
this.isTarget = isTarget;
this.inMoving = inMoving;
}
ElementState.create = function (_a) {
var element = _a.element, clientPoint = _a.clientPoint, screenPoint = _a.screenPoint, isTarget = _a.isTarget, inMoving = _a.inMoving;
return __awaiter(this, void 0, void 0, function () {
var devicePoint, state;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
devicePoint = null;
if (!clientPoint) return [3 /*break*/, 2];
return [4 /*yield*/, getDevicePoint(clientPoint)];
case 1:
devicePoint = _b.sent();
_b.label = 2;
case 2:
state = new ElementState({ element: element, clientPoint: clientPoint, screenPoint: screenPoint, isTarget: isTarget, inMoving: inMoving, devicePoint: devicePoint });
return [2 /*return*/, state];
}
});
});
};
return ElementState;
}());
var VisibleElementAutomation = /** @class */ (function (_super) {
__extends(VisibleElementAutomation, _super);
function VisibleElementAutomation(element, offsetOptions, win, cursor, dispatchProxylessEventFn, topLeftPoint) {
var _this = _super.call(this) || this;
_this.TARGET_ELEMENT_FOUND_EVENT = 'automation|target-element-found-event';
_this.WARNING_EVENT = 'automation|warning-event';
_this.element = element;
_this.options = offsetOptions;
_this.automationSettings = new AutomationSettings(offsetOptions.speed || 1);
_this.window = win;
_this.cursor = cursor;
_this.proxylessEventSimulator = dispatchProxylessEventFn ? new ProxylessEventSimulator(dispatchProxylessEventFn, topLeftPoint) : null;
// NOTE: only for legacy API
_this._ensureWindowAndCursorForLegacyTests(_this);
return _this;
}
VisibleElementAutomation.prototype._ensureWindowAndCursorForLegacyTests = function (automation) {
automation.window = automation.window || window; // eslint-disable-line no-undef
automation.cursor = cursor;
};
VisibleElementAutomation.prototype.canUseProxylessEventSimulator = function (element) {
return !!this.proxylessEventSimulator
&& !!element
&& getTagName(element) !== 'select';
};
VisibleElementAutomation.prototype._getElementForEvent = function (eventArgs) {
return __awaiter(this, void 0, void 0, function () {
var expectedElement;
return __generator(this, function (_a) {
expectedElement = containsOffset(this.element, this.options.offsetX, this.options.offsetY) ? this.element : null;
return [2 /*return*/, getElementFromPoint$2(eventArgs.point, this.window, expectedElement)];
});
});
};
VisibleElementAutomation.prototype._moveToElement = function () {
return __awaiter(this, void 0, void 0, function () {
var moveOptions, moveAutomation;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
moveOptions = new MoveOptions(hammerhead.utils.extend({ skipScrolling: true }, this.options), false);
return [4 /*yield*/, MoveAutomation.create(this.element, moveOptions, this.window, this.cursor)];
case 1:
moveAutomation = _a.sent();
return [2 /*return*/, moveAutomation // eslint-disable-line consistent-return
.run()
.then(function () { return delay(_this.automationSettings.mouseActionStepDelay); })];
}
});
});
};
VisibleElementAutomation.prototype._scrollToElement = function () {
var _this = this;
var wasScrolled = false;
var scrollOptions = new ScrollOptions(this.options, false);
var scrollAutomation = new ScrollAutomation(this.element, scrollOptions);
return scrollAutomation.run()
.then(function (scrollWasPerformed) {
wasScrolled = !!scrollWasPerformed;
return delay(_this.automationSettings.mouseActionStepDelay);
})
.then(function () { return getElementFromPoint$2(_this.cursor.getPosition(), _this.window); })
.then(function (currentElement) {
return ensureMouseEventAfterScroll(currentElement, _this.element, wasScrolled);
})
.then(function () {
return wasScrolled;
});
};
VisibleElementAutomation.prototype._getElementOffset = function () {
var defaultOffsets = getOffsetOptions(this.element);
var _a = this.options, offsetX = _a.offsetX, offsetY = _a.offsetY;
var y = offsetY || offsetY === 0 ? offsetY : defaultOffsets.offsetY;
var x = offsetX || offsetX === 0 ? offsetX : defaultOffsets.offsetX;
return AxisValues.create({ x: x, y: y });
};
VisibleElementAutomation.prototype._isTargetElement = function (element, expectedElement) {
return __awaiter(this, void 0, void 0, function () {
var isTarget;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
isTarget = !expectedElement || element === expectedElement || element === this.element;
if (!(!isTarget && element)) return [3 /*break*/, 2];
return [4 /*yield*/, this._contains(this.element, element)];
case 1:
// NOTE: perform an operation with searching in dom only if necessary
isTarget = _a.sent();
_a.label = 2;
case 2: return [2 /*return*/, isTarget];
}
});
});
};
VisibleElementAutomation.prototype._getCheckedPoints = function (centerPoint) {
var points = [centerPoint];
var stepX = centerPoint.x / AVAILABLE_OFFSET_DEEP;
var stepY = centerPoint.y / AVAILABLE_OFFSET_DEEP;
var maxX = centerPoint.x * 2;
var maxY = centerPoint.y * 2;
for (var y = stepY; y < maxY; y += stepY) {
for (var x = stepX; x < maxX; x += stepX)
points.push(AxisValues.create({ x: x, y: y }));
}
return points;
};
VisibleElementAutomation.prototype._getAvailableOffset = function (expectedElement, centerPoint) {
return __awaiter(this, void 0, void 0, function () {
var checkedPoints, screenPoint, clientPoint, element, i;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
checkedPoints = this._getCheckedPoints(centerPoint);
screenPoint = null;
clientPoint = null;
element = null;
i = 0;
_a.label = 1;
case 1:
if (!(i < checkedPoints.length)) return [3 /*break*/, 7];
return [4 /*yield*/, getAutomationPoint(this.element, checkedPoints[i])];
case 2:
screenPoint = _a.sent();
return [4 /*yield*/, convertToClient(this.element, screenPoint)];
case 3:
clientPoint = _a.sent();
return [4 /*yield*/, getElementFromPoint$2(clientPoint, this.window, expectedElement)];
case 4:
element = _a.sent();
return [4 /*yield*/, this._isTargetElement(element, expectedElement)];
case 5:
if (_a.sent())
return [2 /*return*/, checkedPoints[i]];
_a.label = 6;
case 6:
i++;
return [3 /*break*/, 1];
case 7: return [2 /*return*/, null];
}
});
});
};
VisibleElementAutomation.prototype._wrapAction = function (action) {
return __awaiter(this, void 0, void 0, function () {
var elementOffset, expectedElement, screenPointBeforeAction, clientPositionBeforeAction, availableOffset, screenPointAfterAction, clientPositionAfterAction, clientPoint, element, isTarget, offsetPositionChanged, clientPositionChanged, targetElementIsMoving;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
elementOffset = this._getElementOffset();
return [4 /*yield*/, containsOffset(this.element, elementOffset.x, elementOffset.y)];
case 1:
expectedElement = (_a.sent()) ? this.element : null;
return [4 /*yield*/, getAutomationPoint(this.element, elementOffset)];
case 2:
screenPointBeforeAction = _a.sent();
return [4 /*yield*/, getClientPosition(this.element)];
case 3:
clientPositionBeforeAction = _a.sent();
return [4 /*yield*/, action()];
case 4:
_a.sent();
if (!this.options.isDefaultOffset) return [3 /*break*/, 6];
return [4 /*yield*/, this._getAvailableOffset(expectedElement, elementOffset)];
case 5:
availableOffset = _a.sent();
elementOffset.x = (availableOffset === null || availableOffset === void 0 ? void 0 : availableOffset.x) || elementOffset.x;
elementOffset.y = (availableOffset === null || availableOffset === void 0 ? void 0 : availableOffset.y) || elementOffset.y;
this.options.offsetX = elementOffset.x;
this.options.offsetY = elementOffset.y;
_a.label = 6;
case 6: return [4 /*yield*/, getAutomationPoint(this.element, elementOffset)];
case 7:
screenPointAfterAction = _a.sent();
return [4 /*yield*/, getClientPosition(this.element)];
case 8:
clientPositionAfterAction = _a.sent();
return [4 /*yield*/, convertToClient(this.element, screenPointAfterAction)];
case 9:
clientPoint = _a.sent();
return [4 /*yield*/, getElementFromPoint$2(clientPoint, this.window, expectedElement)];
case 10:
element = _a.sent();
if (!element) {
return [2 /*return*/, ElementState.create({
element: null,
clientPoint: null,
screenPoint: null,
isTarget: false,
inMoving: false,
})];
}
return [4 /*yield*/, this._isTargetElement(element, expectedElement)];
case 11:
isTarget = _a.sent();
offsetPositionChanged = screenPointBeforeAction.x !== screenPointAfterAction.x ||
screenPointBeforeAction.y !== screenPointAfterAction.y;
clientPositionChanged = clientPositionBeforeAction.x !== clientPositionAfterAction.x ||
clientPositionBeforeAction.y !== clientPositionAfterAction.y;
targetElementIsMoving = offsetPositionChanged && clientPositionChanged;
return [2 /*return*/, ElementState.create({
element: element,
clientPoint: clientPoint,
screenPoint: screenPointAfterAction,
isTarget: isTarget,
inMoving: targetElementIsMoving,
})];
}
});
});
};
VisibleElementAutomation.prototype._checkElementState = function (state, useStrictElementCheck) {
if (!state.element) {
throw new ActionElementIsInvisibleError(null, {
reason: getElOutsideBoundsReason(this.element),
});
}
if (useStrictElementCheck && (!state.isTarget || state.inMoving))
throw new ActionElementIsNotTargetError();
return state;
};
VisibleElementAutomation.prototype._ensureElement = function (useStrictElementCheck, skipCheckAfterMoving, skipMoving) {
var _this = this;
if (skipCheckAfterMoving === void 0) { skipCheckAfterMoving = false; }
if (skipMoving === void 0) { skipMoving = false; }
return this
._wrapAction(function () { return _this._scrollToElement(); })
.then(function (state) { return _this._checkElementState(state, useStrictElementCheck); })
.then(function (state) {
return skipMoving ? state : _this._wrapAction(function () { return _this._moveToElement(); });
})
.then(function (state) {
if (!skipCheckAfterMoving)
_this._checkElementState(state, useStrictElementCheck);
return state;
})
.then(function (state) {
var element = state === null || state === void 0 ? void 0 : state.element;
_this.emit(_this.TARGET_ELEMENT_FOUND_EVENT, { element: element || null });
if (!useStrictElementCheck && element && !state.isTarget) {
var expectedElementStr = stringifyElement(_this.element);
var actualElementStr = stringifyElement(element);
_this.emit(_this.WARNING_EVENT, {
type: WARNING_TYPES.elementOverlapped,
args: [expectedElementStr, actualElementStr],
});
}
return {
element: (state === null || state === void 0 ? void 0 : state.element) || null,
clientPoint: (state === null || state === void 0 ? void 0 : state.clientPoint) || null,
screenPoint: (state === null || state === void 0 ? void 0 : state.screenPoint) || null,
devicePoint: (state === null || state === void 0 ? void 0 : state.devicePoint) || null,
};
});
};
VisibleElementAutomation.prototype._contains = function (parent, child) {
return __awaiter(this, void 0, void 0, function () {
var parents, _i, parents_1, el;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, getParents(child)];
case 1:
parents = _a.sent();
for (_i = 0, parents_1 = parents; _i < parents_1.length; _i++) {
el = parents_1[_i];
if (el === parent)
return [2 /*return*/, true];
}
return [2 /*return*/, false];
}
});
});
};
return VisibleElementAutomation;
}(EventEmitter));
var Promise$3 = hammerhead__default.Promise;
function calculatePosition(el, position) {
var centerX = Math.floor(el.scrollWidth / 2 - el.clientWidth / 2);
var centerY = Math.floor(el.scrollHeight / 2 - el.clientHeight / 2);
var positions = {
'top': [centerX, 0],
'right': [el.scrollWidth, centerY],
'bottom': [centerX, el.scrollHeight],
'left': [0, centerY],
'topRight': [el.scrollWidth, 0],
'topLeft': [0, 0],
'bottomRight': [el.scrollWidth, el.scrollHeight],
'bottomLeft': [0, el.scrollHeight],
'center': [centerX, centerY],
};
return positions[position];
}
var SetScrollAutomation = /** @class */ (function (_super) {
__extends(SetScrollAutomation, _super);
function SetScrollAutomation(element, _a, offsetOptions) {
var _b;
var x = _a.x, y = _a.y, position = _a.position, byX = _a.byX, byY = _a.byY;
var _this = _super.call(this, element, offsetOptions, window, cursor) || this;
if (position)
_b = calculatePosition(element, position), x = _b[0], y = _b[1];
_this.scrollLeft = typeof x === 'number' ? x : element.scrollLeft;
_this.scrollTop = typeof y === 'number' ? y : element.scrollTop;
if (byX)
_this.scrollLeft += byX;
if (byY)
_this.scrollTop += byY;
return _this;
}
SetScrollAutomation.prototype.run = function (useStrictElementCheck) {
var _this = this;
var promise = Promise$3.resolve();
if (this.element !== document.scrollingElement && this.element !== document.documentElement)
promise = this._ensureElement(useStrictElementCheck, true, true);
return promise
.then(function () {
_this.element.scrollLeft = _this.scrollLeft;
_this.element.scrollTop = _this.scrollTop;
});
};
return SetScrollAutomation;
}(VisibleElementAutomation));
var ScrollIntoViewAutomation = /** @class */ (function (_super) {
__extends(ScrollIntoViewAutomation, _super);
function ScrollIntoViewAutomation(element, offsetOptions) {
return _super.call(this, element, offsetOptions, window, cursor) || this;
}
ScrollIntoViewAutomation.prototype.run = function (useStrictElementCheck) {
return this._ensureElement(useStrictElementCheck, true, true);
};
return ScrollIntoViewAutomation;
}(VisibleElementAutomation));
var Promise$4 = hammerhead__default.Promise;
var nativeMethods$7 = hammerhead__default.nativeMethods;
var browserUtils$3 = hammerhead__default.utils.browser;
var focusBlurSandbox = hammerhead__default.eventSandbox.focusBlur;
var contentEditable = testCafeCore__default.contentEditable;
var textSelection = testCafeCore__default.textSelection;
var domUtils$1 = testCafeCore__default.domUtils;
var styleUtils$1 = testCafeCore__default.styleUtils;
var messageSandbox$1 = hammerhead__default.eventSandbox.message;
var GET_IFRAME_REQUEST_CMD = 'automation|iframe|request';
var GET_IFRAME_RESPONSE_CMD = 'automation|iframe|response';
messageSandbox$1.on(messageSandbox$1.SERVICE_MSG_RECEIVED_EVENT, function (e) {
if (e.message.cmd === GET_IFRAME_REQUEST_CMD) {
var iframeElement = domUtils$1.findIframeByWindow(e.source);
focusBlurSandbox.focus(iframeElement, function () {
messageSandbox$1.sendServiceMsg({ cmd: GET_IFRAME_RESPONSE_CMD }, e.source);
}, false);
}
});
function setCaretPosition(element, caretPos) {
var isTextEditable = domUtils$1.isTextEditableElement(element);
var isContentEditable = domUtils$1.isContentEditableElement(element);
if (isTextEditable || isContentEditable) {
if (isContentEditable && isNaN(parseInt(caretPos, 10)))
textSelection.setCursorToLastVisiblePosition(element);
else {
var position = isNaN(parseInt(caretPos, 10)) ? domUtils$1.getElementValue(element).length : caretPos;
textSelection.select(element, position, position);
}
}
else {
// NOTE: if focus is called for a non-contentEditable element (like 'img' or 'button') inside
// a contentEditable parent, we should try to set the right window selection. Generally, we can't
// set the right window selection object because after the selection setup, the window.getSelection
// method returns a different object, which depends on the browser.
var contentEditableParent = contentEditable.findContentEditableParent(element);
if (contentEditableParent)
textSelection.setCursorToLastVisiblePosition(contentEditable.findContentEditableParent(contentEditableParent));
}
}
function focusAndSetSelection(element, simulateFocus, caretPos) {
var _this = this;
return new Promise$4(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
var activeElement, isTextEditable, labelWithForAttr, isElementFocusable, shouldFocusByRelatedElement, isContentEditable, elementForFocus, focusWithSilentMode, focusForMouseEvent, preventScrolling, curDocument, curActiveElement, isActiveElementBody, focusableParent, elementChildOfActiveElement;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!isIframeWindow(window)) return [3 /*break*/, 2];
return [4 /*yield*/, sendRequestToFrame({ cmd: GET_IFRAME_REQUEST_CMD }, GET_IFRAME_RESPONSE_CMD, window.parent)];
case 1:
_a.sent();
_a.label = 2;
case 2:
activeElement = domUtils$1.getActiveElement();
isTextEditable = domUtils$1.isTextEditableElement(element);
labelWithForAttr = domUtils$1.closest(element, 'label[for]');
isElementFocusable = domUtils$1.isElementFocusable(element);
shouldFocusByRelatedElement = !isElementFocusable && labelWithForAttr;
isContentEditable = domUtils$1.isContentEditableElement(element);
elementForFocus = isContentEditable ? contentEditable.findContentEditableParent(element) : element;
// NOTE: in WebKit, if selection was never set in an input element, the focus method selects all the
// text in this element. So, we should call select before focus to set the caret to the first symbol.
if (simulateFocus && browserUtils$3.isWebKit && isTextEditable)
textSelection.select(element, 0, 0);
// NOTE: we should call focus for the element related with a 'label' that has the 'for' attribute
if (shouldFocusByRelatedElement) {
if (simulateFocus)
focusByLabel(labelWithForAttr);
resolve();
return [2 /*return*/];
}
focusWithSilentMode = !simulateFocus;
focusForMouseEvent = true;
preventScrolling = false;
if (!isElementFocusable && !isContentEditable) {
curDocument = domUtils$1.findDocument(elementForFocus);
curActiveElement = nativeMethods$7.documentActiveElementGetter.call(curDocument);
isActiveElementBody = domUtils$1.isBodyElement(curActiveElement);
focusableParent = domUtils$1.isBodyElement(elementForFocus) ?
elementForFocus : domUtils$1.getFocusableParent(elementForFocus);
elementChildOfActiveElement = curActiveElement && !isActiveElementBody &&
domUtils$1.containsElement(curActiveElement, elementForFocus);
if (elementChildOfActiveElement || isActiveElementBody && domUtils$1.isBodyElement(focusableParent)) {
resolve();
return [2 /*return*/];
}
elementForFocus = focusableParent || curDocument.body;
preventScrolling = true;
}
focusBlurSandbox.focus(elementForFocus, function () {
// NOTE: if a different element was focused in the focus event handler, we should not set selection
if (simulateFocus && !isContentEditable && element !== domUtils$1.getActiveElement()) {
resolve();
return;
}
setCaretPosition(element, caretPos);
// NOTE: we can't avoid the element being focused because the setSelection method leads to focusing.
// So, we just focus the previous active element without handlers if we don't need focus here
if (!simulateFocus && domUtils$1.getActiveElement() !== activeElement)
focusBlurSandbox.focus(activeElement, resolve, true, true);
else
resolve();
}, focusWithSilentMode, focusForMouseEvent, false, preventScrolling);
return [2 /*return*/];
}
});
}); });
}
function getElementBoundToLabel(element) {
var labelWithForAttr = domUtils$1.closest(element, 'label[for]');
var control = labelWithForAttr && (labelWithForAttr.control || document.getElementById(labelWithForAttr.htmlFor));
var isControlVisible = control && styleUtils$1.isElementVisible(control);
return isControlVisible ? control : null;
}
function focusByLabel(label) {
if (domUtils$1.isElementFocusable(label))
focusBlurSandbox.focus(label, testCafeCore__default.noop, false, true);
else
focusByRelatedElement(label);
}
function focusByRelatedElement(element) {
var elementForFocus = getElementBoundToLabel(element);
if (!elementForFocus || domUtils$1.getActiveElement() === elementForFocus)
return;
focusBlurSandbox.focus(elementForFocus, testCafeCore__default.noop, false, true);
}
var browserUtils$4 = hammerhead__default.utils.browser;
var eventSimulator$3 = hammerhead__default.eventSandbox.eventSimulator;
var listeners$2 = hammerhead__default.eventSandbox.listeners;
var nativeMethods$8 = hammerhead__default.nativeMethods;
var domUtils$2 = testCafeCore__default.domUtils;
var styleUtils$2 = testCafeCore__default.styleUtils;
var selectController = testCafeCore__default.selectController;
var selectElementUI = testCafeUI.selectElement;
var ElementClickCommand = /** @class */ (function () {
function ElementClickCommand(eventState, eventArgs) {
this.eventState = eventState;
this.eventArgs = eventArgs;
}
ElementClickCommand.prototype.run = function () {
if (this.eventState.clickElement)
eventSimulator$3.click(this.eventState.clickElement, this.eventArgs.options);
if (!domUtils$2.isElementFocusable(this.eventArgs.element))
focusByRelatedElement(this.eventArgs.element);
};
return ElementClickCommand;
}());
var LabelElementClickCommand = /** @class */ (function (_super) {
__extends(LabelElementClickCommand, _super);
function LabelElementClickCommand(eventState, eventArgs) {
var _this = _super.call(this, eventState, eventArgs) || this;
_this.targetElement = _this.eventArgs.element;
_this.input = getElementBoundToLabel(_this.eventArgs.element);
return _this;
}
LabelElementClickCommand.prototype.run = function () {
var _this = this;
var focusRaised = false;
var ensureFocusRaised = function (e) {
focusRaised = nativeMethods$8.eventTargetGetter.call(e) === _this.input;
};
listeners$2.addInternalEventBeforeListener(window, ['focus'], ensureFocusRaised);
_super.prototype.run.call(this);
listeners$2.removeInternalEventBeforeListener(window, ['focus'], ensureFocusRaised);
if (domUtils$2.isElementFocusable(this.targetElement) && !focusRaised)
this._ensureBoundElementFocusRaised();
};
LabelElementClickCommand.prototype._ensureBoundElementFocusRaised = function () {
eventSimulator$3.focus(this.input);
};
return LabelElementClickCommand;
}(ElementClickCommand));
var SelectElementClickCommand = /** @class */ (function (_super) {
__extends(SelectElementClickCommand, _super);
function SelectElementClickCommand(eventState, eventArgs) {
return _super.call(this, eventState, eventArgs) || this;
}
SelectElementClickCommand.prototype.run = function () {
_super.prototype.run.call(this);
this._toggleSelectOptionList();
};
SelectElementClickCommand.prototype._toggleSelectOptionList = function () {
// NOTE: Emulating the click event on the 'select' element doesn't expand the
// dropdown with options (except chrome), therefore we should emulate it.
var element = this.eventArgs.element;
var isSelectWithDropDown = styleUtils$2.getSelectElementSize(element) === 1;
if (isSelectWithDropDown && this.eventState.simulateDefaultBehavior !== false) {
if (selectController.isOptionListExpanded(element))
selectElementUI.collapseOptionList();
else
selectElementUI.expandOptionList(element);
}
};
return SelectElementClickCommand;
}(ElementClickCommand));
var OptionElementClickCommand = /** @class */ (function (_super) {
__extends(OptionElementClickCommand, _super);
function OptionElementClickCommand(eventState, eventArgs) {
return _super.call(this, eventState, eventArgs) || this;
}
OptionElementClickCommand.prototype.run = function () {
return this.eventArgs.element;
};
return OptionElementClickCommand;
}(ElementClickCommand));
var LabelledCheckboxElementClickCommand = /** @class */ (function (_super) {
__extends(LabelledCheckboxElementClickCommand, _super);
function LabelledCheckboxElementClickCommand(eventState, eventArgs) {
var _this = _super.call(this, eventState, eventArgs) || this;
_this.checkbox = _this.input;
return _this;
}
LabelledCheckboxElementClickCommand.prototype.run = function () {
var changed = false;
var onChange = function () {
changed = true;
};
listeners$2.addInternalEventBeforeListener(window, ['change'], onChange);
_super.prototype.run.call(this);
listeners$2.removeInternalEventBeforeListener(window, ['change'], onChange);
// NOTE: Two overlapping issues: https://github.com/DevExpress/testcafe/issues/3348 and https://github.com/DevExpress/testcafe/issues/6949
// When label contains <a href=any> or <button> element, clicking these elements should prevent checkbox from changing checked state.
// Also, checkbox state should not be changed if it is disabled.
// We should to leave the code for fixing .focus issue and add additional check for the clickable elements inside the label:
if (browserUtils$4.isChrome && !changed && !this.checkbox.disabled && !this._isClickableElementInsideLabel(this.targetElement))
this._ensureCheckboxStateChanged();
};
LabelledCheckboxElementClickCommand.prototype._ensureCheckboxStateChanged = function () {
this.checkbox.checked = !this.checkbox.checked;
eventSimulator$3.change(this.checkbox);
};
LabelledCheckboxElementClickCommand.prototype._isClickableElementInsideLabel = function (element) {
var isClickableLink = domUtils$2.isAnchorElement(element) && element.getAttribute('href');
var isButton = domUtils$2.isButtonElement(element);
return isClickableLink || isButton;
};
return LabelledCheckboxElementClickCommand;
}(LabelElementClickCommand));
function createClickCommand (eventState, eventArgs) {
var elementBoundToLabel = getElementBoundToLabel(eventArgs.element);
var isSelectElement = domUtils$2.isSelectElement(eventArgs.element);
var isOptionElement = domUtils$2.isOptionElement(eventArgs.element);
var isLabelElement = domUtils$2.isLabelElement(eventArgs.element) && elementBoundToLabel;
var isLabelledCheckbox = elementBoundToLabel && domUtils$2.isCheckboxElement(elementBoundToLabel);
if (isSelectElement)
return new SelectElementClickCommand(eventState, eventArgs);
if (isOptionElement)
return new OptionElementClickCommand(eventState, eventArgs);
if (isLabelledCheckbox)
return new LabelledCheckboxElementClickCommand(eventState, eventArgs);
if (isLabelElement)
return new LabelElementClickCommand(eventState, eventArgs);
return new ElementClickCommand(eventState, eventArgs);
}
// @ts-ignore
var Promise$5 = hammerhead__default.Promise;
var browserUtils$5 = hammerhead__default.utils.browser;
var featureDetection = hammerhead__default.utils.featureDetection;
var eventSimulator$4 = hammerhead__default.eventSandbox.eventSimulator;
var listeners$3 = hammerhead__default.eventSandbox.listeners;
var domUtils$3 = testCafeCore__default.domUtils;
var eventUtils$1 = testCafeCore__default.eventUtils;
var arrayUtils = testCafeCore__default.arrayUtils;
function _getElementForClick(mouseDownElement, topElement, mouseDownElementParentNodes) {
var topElementParentNodes = domUtils$3.getParents(topElement);
var areElementsSame = domUtils$3.isTheSameNode(topElement, mouseDownElement);
// NOTE: Mozilla Firefox always skips click, if an element under cursor has been changed after mousedown.
if (browserUtils$5.isFirefox)
return areElementsSame ? mouseDownElement : null;
if (!areElementsSame) {
// @ts-ignore
if (mouseDownElement.contains(topElement) && !domUtils$3.isEditableFormElement(topElement))
return mouseDownElement;
// @ts-ignore
if (topElement.contains(mouseDownElement))
return topElement;
// NOTE: If elements are not in the parent-child relationships,
// non-ff browsers raise the `click` event for their common parent.
return arrayUtils.getCommonElement(topElementParentNodes, mouseDownElementParentNodes);
}
// NOTE: In case the target element and the top element are the same,
// non-FF browsers are dispatching the `click` event if the target
// element hasn't changed its position in the DOM after mousedown.
return arrayUtils.equals(mouseDownElementParentNodes, topElementParentNodes) ? mouseDownElement : null;
}
var MouseClickStrategy = /** @class */ (function () {
function MouseClickStrategy(element, caretPos) {
this.element = element;
this.caretPos = caretPos;
this.targetElementParentNodes = [];
this.activeElementBeforeMouseDown = null;
this.mouseDownElement = null;
this.eventState = {
mousedownPrevented: false,
blurRaised: false,
simulateDefaultBehavior: true,
clickElement: null,
touchStartCancelled: false,
touchEndCancelled: false,
};
}
MouseClickStrategy.prototype.mousedown = function (eventArgs) {
var _this = this;
this.targetElementParentNodes = domUtils$3.getParents(eventArgs.element);
this.mouseDownElement = eventArgs.element;
this._raiseTouchEvents(eventArgs);
var activeElement = domUtils$3.getActiveElement();
this.activeElementBeforeMouseDown = activeElement;
// NOTE: In WebKit and IE, the mousedown event opens the select element's dropdown;
// therefore, we should prevent mousedown and hide the dropdown (B236416).
var needCloseSelectDropDown = (browserUtils$5.isWebKit || browserUtils$5.isIE) &&
domUtils$3.isSelectElement(this.mouseDownElement);
if (needCloseSelectDropDown)
this._bindMousedownHandler();
this._bindBlurHandler(activeElement);
if (!this._isTouchEventWasCancelled())
this.eventState.simulateDefaultBehavior = eventSimulator$4.mousedown(eventArgs.element, eventArgs.options);
if (this.eventState.simulateDefaultBehavior === false)
this.eventState.simulateDefaultBehavior = needCloseSelectDropDown && !this.eventState.mousedownPrevented;
return this._ensureActiveElementBlur(activeElement)
.then(function () { return _this._focus(eventArgs); });
};
MouseClickStrategy.prototype.mouseup = function (element, eventArgs) {
eventArgs.element = element;
this.eventState.clickElement = _getElementForClick(this.mouseDownElement, element, this.targetElementParentNodes);
var timeStamp = {};
var getTimeStamp = function (e) {
timeStamp = e.timeStamp;
listeners$3.removeInternalEventBeforeListener(window, ['mouseup'], getTimeStamp);
};
if (!browserUtils$5.isIE)
listeners$3.addInternalEventBeforeListener(window, ['mouseup'], getTimeStamp);
if (!this._isTouchEventWasCancelled())
eventSimulator$4.mouseup(element, eventArgs.options);
if (eventArgs.options)
eventArgs.options.timeStamp = timeStamp;
return this._click(eventArgs);
};
MouseClickStrategy.prototype._click = function (eventArgs) {
return __awaiter(this, void 0, hammerhead__default.Promise, function () {
var clickCommand;
return __generator(this, function (_a) {
clickCommand = createClickCommand(this.eventState, eventArgs);
if (!this._isTouchEventWasCancelled())
clickCommand.run();
return [2 /*return*/, eventArgs];
});
});
};
// NOTE:
// If `touchstart`, `touchmove`, or `touchend` are canceled, we should not dispatch any mouse event
// that would be a consequential result of the prevented touch event
MouseClickStrategy.prototype._isTouchEventWasCancelled = function () {
return this.eventState.touchStartCancelled || this.eventState.touchEndCancelled;
};
MouseClickStrategy.prototype._bindMousedownHandler = function () {
var _this = this;
var onmousedown = function (e) {
_this.eventState.mousedownPrevented = e.defaultPrevented;
eventUtils$1.preventDefault(e);
eventUtils$1.unbind(_this.element, 'mousedown', onmousedown);
};
eventUtils$1.bind(this.element, 'mousedown', onmousedown);
};
MouseClickStrategy.prototype._bindBlurHandler = function (element) {
var _this = this;
var onblur = function () {
_this.eventState.blurRaised = true;
eventUtils$1.unbind(element, 'blur', onblur, true);
};
eventUtils$1.bind(element, 'blur', onblur, true);
};
MouseClickStrategy.prototype._ensureActiveElementBlur = function (element) {
var _this = this;
// NOTE: In some cases, mousedown may lead to active element change (browsers raise blur).
// We simulate the blur event if the active element was changed after the mousedown, and
// the blur event does not get raised automatically (B239273, B253520)
return new Promise$5(function (resolve) {
var simulateBlur = domUtils$3.getActiveElement() !== element && !_this.eventState.blurRaised;
if (!simulateBlur) {
resolve();
return;
}
if (browserUtils$5.isIE && browserUtils$5.version < 12) {
// NOTE: In whatever way an element is blurred from the client script, the
// blur event is raised asynchronously in IE (in MSEdge focus/blur is sync)
nextTick()
.then(function () {
if (!_this.eventState.blurRaised)
eventSimulator$4.blur(element);
resolve();
});
}
else {
eventSimulator$4.blur(element);
resolve();
}
});
};
MouseClickStrategy.prototype._focus = function (eventArgs) {
if (this.eventState.simulateDefaultBehavior === false)
return Promise$5.resolve();
// NOTE: If a target element is a contentEditable element, we need to call focusAndSetSelection directly for
// this element. Otherwise, if the element obtained by elementFromPoint is a child of the contentEditable
// element, a selection position may be calculated incorrectly (by using the caretPos option).
var elementForFocus = domUtils$3.isContentEditableElement(this.element) ? this.element : eventArgs.element;
// NOTE: IE doesn't perform focus if active element has been changed while executing mousedown
var simulateFocus = !browserUtils$5.isIE || this.activeElementBeforeMouseDown === domUtils$3.getActiveElement();
return focusAndSetSelection(elementForFocus, simulateFocus, this.caretPos);
};
MouseClickStrategy.prototype._raiseTouchEvents = function (eventArgs) {
if (featureDetection.isTouchDevice) {
this.eventState.touchStartCancelled = !eventSimulator$4.touchstart(eventArgs.element, eventArgs.options);
this.eventState.touchEndCancelled = !eventSimulator$4.touchend(eventArgs.element, eventArgs.options);
}
};
return MouseClickStrategy;
}());
function createMouseClickStrategy(element, caretPos) {
return new MouseClickStrategy(element, caretPos);
}
var ClickAutomation = /** @class */ (function (_super) {
__extends(ClickAutomation, _super);
function ClickAutomation(element, clickOptions, win, cursor, dispatchProxylessEventFn, leftTopPoint) {
var _this = _super.call(this, element, clickOptions, win, cursor, dispatchProxylessEventFn, leftTopPoint) || this;
_this.modifiers = clickOptions.modifiers;
_this.strategy = createMouseClickStrategy(_this.element, clickOptions.caretPos);
return _this;
}
ClickAutomation.prototype._mousedown = function (eventArgs) {
if (this.canUseProxylessEventSimulator(eventArgs.element))
return this.proxylessEventSimulator.mouseDown(eventArgs);
return this.strategy.mousedown(eventArgs);
};
ClickAutomation.prototype._mouseup = function (element, eventArgs) {
if (this.canUseProxylessEventSimulator(eventArgs.element))
return this.proxylessEventSimulator.mouseUp(eventArgs);
return this.strategy.mouseup(element, eventArgs);
};
ClickAutomation.prototype.run = function (useStrictElementCheck) {
var _this = this;
var eventArgs;
return this
._ensureElement(useStrictElementCheck)
.then(function (_a) {
var element = _a.element, clientPoint = _a.clientPoint, screenPoint = _a.screenPoint, devicePoint = _a.devicePoint;
eventArgs = {
point: clientPoint,
screenPoint: screenPoint,
element: element,
options: hammerhead.utils.extend({
clientX: clientPoint === null || clientPoint === void 0 ? void 0 : clientPoint.x,
clientY: clientPoint === null || clientPoint === void 0 ? void 0 : clientPoint.y,
screenX: devicePoint === null || devicePoint === void 0 ? void 0 : devicePoint.x,
screenY: devicePoint === null || devicePoint === void 0 ? void 0 : devicePoint.y,
}, _this.modifiers),
};
// NOTE: we should raise mouseup event with 'mouseActionStepDelay' after we trigger
// mousedown event regardless of how long mousedown event handlers were executing
return hammerhead.Promise.all([delay(_this.automationSettings.mouseActionStepDelay), _this.cursor
.leftButtonDown()
.then(function () { return _this._mousedown(eventArgs); }),
]);
})
.then(function () { return _this.cursor.buttonUp(); })
.then(function () { return _this._getElementForEvent(eventArgs); })
.then(function (element) {
return element ? _this._mouseup(element, eventArgs) : null;
});
};
return ClickAutomation;
}(VisibleElementAutomation));
function getLineYByXCoord(startLine, endLine, x) {
if (endLine.x === startLine.x)
return 0;
var equationSlope = (endLine.y - startLine.y) / (endLine.x - startLine.x);
var equationYIntercept = startLine.x * (startLine.y - endLine.y) / (endLine.x - startLine.x) + startLine.y;
return Math.round(equationSlope * x + equationYIntercept);
}
function getLineXByYCoord(startLine, endLine, y) {
if (endLine.y - startLine.y === 0)
return 0;
var equationSlope = (endLine.x - startLine.x) / (endLine.y - startLine.y);
var equationXIntercept = startLine.y * (startLine.x - endLine.x) / (endLine.y - startLine.y) + startLine.x;
return Math.round(equationSlope * y + equationXIntercept);
}
function findIntersectionHorizontal(startLinePoint, endLinePoint, rectSide) {
var intersectionX = getLineXByYCoord(startLinePoint, endLinePoint, rectSide.top);
var haveIntersectionInBounds = intersectionX && intersectionX >= rectSide.left && intersectionX <= rectSide.right;
return haveIntersectionInBounds ? new AxisValues(intersectionX, rectSide.top) : null;
}
function findIntersectionVertical(startLinePoint, endLinePoint, rectSide) {
var intersectionY = getLineYByXCoord(startLinePoint, endLinePoint, rectSide.left);
var haveIntersectionInBounds = intersectionY && intersectionY >= rectSide.top && intersectionY <= rectSide.bottom;
return haveIntersectionInBounds ? new AxisValues(rectSide.left, intersectionY) : null;
}
function getLineRectIntersection (startLine, endLine, rect) {
var res = [];
var rectLines = [
{ left: rect.left, top: rect.top, right: rect.left, bottom: rect.bottom, isHorizontal: false },
{ left: rect.right, top: rect.top, right: rect.right, bottom: rect.bottom, isHorizontal: false },
{ left: rect.left, top: rect.top, right: rect.right, bottom: rect.top, isHorizontal: true },
{ left: rect.left, top: rect.bottom, right: rect.right, bottom: rect.bottom, isHorizontal: true }, // bottom-side
];
for (var _i = 0, rectLines_1 = rectLines; _i < rectLines_1.length; _i++) {
var rectLine = rectLines_1[_i];
var intersection = rectLine.isHorizontal
? findIntersectionHorizontal(startLine, endLine, rectLine)
: findIntersectionVertical(startLine, endLine, rectLine);
if (intersection)
res.push(intersection);
}
if (!res.length)
return null;
if (res.length === 1)
return res[0];
// NOTE: if a line and rect have two intersection points, we return the nearest to startLinePoint
return res[0].distance(startLine) < res[1].distance(startLine) ? res[0] : res[1];
}
var eventSimulator$5 = hammerhead__default.eventSandbox.eventSimulator;
var messageSandbox$2 = hammerhead__default.eventSandbox.message;
var positionUtils$2 = testCafeCore__default.positionUtils;
var domUtils$4 = testCafeCore__default.domUtils;
var styleUtils$3 = testCafeCore__default.styleUtils;
var MOVE_REQUEST_CMD$1 = 'automation|move|request';
var MOVE_RESPONSE_CMD$1 = 'automation|move|response';
function onMoveToIframeRequest(e) {
var iframePoint = new AxisValues(e.message.endX, e.message.endY);
var iframeWin = e.source;
var iframe = domUtils$4.findIframeByWindow(iframeWin);
var iframeBorders = styleUtils$3.getBordersWidth(iframe);
var iframePadding = styleUtils$3.getElementPadding(iframe);
var iframeRectangle = positionUtils$2.getIframeClientCoordinates(iframe);
var iframePointRelativeToParent = positionUtils$2.getIframePointRelativeToParentFrame(iframePoint, iframeWin);
var cursorPosition = cursor.getPosition();
cursor.shouldRender = e.message.shouldRender;
var intersectionPoint = positionUtils$2.isInRectangle(cursorPosition, iframeRectangle) ? cursorPosition :
getLineRectIntersection(cursorPosition, iframePointRelativeToParent, iframeRectangle);
var intersectionRelatedToIframe = {
x: intersectionPoint.x - iframeRectangle.left,
y: intersectionPoint.y - iframeRectangle.top,
};
var moveOptions = new MoveOptions({
modifiers: e.message.modifiers,
offsetX: intersectionRelatedToIframe.x + iframeBorders.left + iframePadding.left,
offsetY: intersectionRelatedToIframe.y + iframeBorders.top + iframePadding.top,
speed: e.message.speed,
// NOTE: we should not perform scrolling because the active window was
// already scrolled to the target element before the request (GH-847)
skipScrolling: true,
}, false);
var responseMsg = {
cmd: MOVE_RESPONSE_CMD$1,
x: intersectionRelatedToIframe.x,
y: intersectionRelatedToIframe.y,
};
if (cursor.getActiveWindow(window) !== iframeWin) {
// const moveAutomation = new MoveAutomation(iframe, moveOptions);
MoveAutomation.create(iframe, moveOptions, window, cursor)
.then(function (moveAutomation) {
return moveAutomation.run();
})
.then(function () {
cursor.setActiveWindow(iframeWin);
messageSandbox$2.sendServiceMsg(responseMsg, iframeWin);
});
}
else
messageSandbox$2.sendServiceMsg(responseMsg, iframeWin);
}
function onMoveOutRequest(e) {
var parentWin = e.source;
var iframeRectangle = {
left: e.message.left,
right: e.message.right,
top: e.message.top,
bottom: e.message.bottom,
};
if (!e.message.iframeUnderCursor) {
var _a = e.message, startX = _a.startX, startY = _a.startY;
var clientX = startX - iframeRectangle.left;
var clientY = startY - iframeRectangle.top;
// NOTE: We should not emulate mouseout and mouseleave if iframe was reloaded.
var element = lastHoveredElementHolder.get();
if (element) {
eventSimulator$5.mouseout(element, { clientX: clientX, clientY: clientY, relatedTarget: null });
eventSimulator$5.mouseleave(element, { clientX: clientX, clientY: clientY, relatedTarget: null });
}
messageSandbox$2.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD$1 }, parentWin);
return;
}
var cursorPosition = cursor.getPosition();
var startPoint = AxisValues.create(iframeRectangle).add(cursorPosition);
var endPoint = new AxisValues(e.message.endX, e.message.endY);
var intersectionPoint = getLineRectIntersection(startPoint, endPoint, iframeRectangle);
// NOTE: We should not move the cursor out of the iframe if
// the cursor path does not intersect with the iframe borders.
if (!intersectionPoint) {
messageSandbox$2.sendServiceMsg({
cmd: MOVE_RESPONSE_CMD$1,
x: iframeRectangle.left,
y: iframeRectangle.top,
}, parentWin);
return;
}
var moveOptions = new MoveOptions({
modifiers: e.message.modifiers,
offsetX: intersectionPoint.x - iframeRectangle.left,
offsetY: intersectionPoint.y - iframeRectangle.top,
speed: e.message.speed,
// NOTE: we should not perform scrolling because the active window was
// already scrolled to the target element before the request (GH-847)
skipScrolling: true,
}, false);
MoveAutomation.create(document.documentElement, moveOptions, window, cursor)
.then(function (moveAutomation) {
return moveAutomation.run();
})
.then(function () {
var responseMsg = {
cmd: MOVE_RESPONSE_CMD$1,
x: intersectionPoint.x,
y: intersectionPoint.y,
};
cursor.setActiveWindow(parentWin);
messageSandbox$2.sendServiceMsg(responseMsg, parentWin);
});
}
// Setup cross-iframe interaction
messageSandbox$2.on(messageSandbox$2.SERVICE_MSG_RECEIVED_EVENT, function (e) {
if (e.message.cmd === MOVE_REQUEST_CMD$1) {
if (e.source.parent === window)
onMoveToIframeRequest(e);
else {
hammerhead__default.on(hammerhead__default.EVENTS.beforeUnload, function () { return messageSandbox$2.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD$1 }, e.source); });
onMoveOutRequest(e);
}
}
});
var Promise$6 = hammerhead__default.Promise;
var browserUtils$6 = hammerhead__default.utils.browser;
var featureDetection$1 = hammerhead__default.utils.featureDetection;
var eventSimulator$6 = hammerhead__default.eventSandbox.eventSimulator;
var focusBlurSandbox$1 = hammerhead__default.eventSandbox.focusBlur;
var nativeMethods$9 = hammerhead__default.nativeMethods;
var domUtils$5 = testCafeCore__default.domUtils;
var styleUtils$4 = testCafeCore__default.styleUtils;
var delay$1 = testCafeCore__default.delay;
var selectController$1 = testCafeCore__default.selectController;
var selectElementUI$1 = testCafeUI.selectElement;
var FOCUS_DELAY = featureDetection$1.isTouchDevice ? 0 : 160;
var SelectChildClickAutomation = /** @class */ (function () {
function SelectChildClickAutomation(element, clickOptions) {
this.element = element;
this.modifiers = clickOptions.modifiers;
this.caretPos = clickOptions.caretPos;
this.offsetX = clickOptions.offsetX;
this.offsetY = clickOptions.offsetY;
this.speed = clickOptions.speed;
this.automationSettings = new AutomationSettings(clickOptions.speed);
this.parentSelect = domUtils$5.getSelectParent(this.element);
this.optionListExpanded = this.parentSelect ? selectController$1.isOptionListExpanded(this.parentSelect) : false;
this.childIndex = null;
this.clickCausesChange = false;
if (this.parentSelect) {
var isOption = domUtils$5.isOptionElement(this.element);
var selectedIndex = this.parentSelect.selectedIndex;
this.childIndex = isOption ? domUtils$5.getElementIndexInParent(this.parentSelect, this.element) :
domUtils$5.getElementIndexInParent(this.parentSelect, this.element);
var parent_1 = nativeMethods$9.nodeParentNodeGetter.call(this.element);
var parentOptGroup = domUtils$5.isOptionGroupElement(parent_1) ? parent_1 : null;
var isDisabled = this.element.disabled || parentOptGroup && parentOptGroup.disabled;
this.clickCausesChange = isOption && !isDisabled && this.childIndex !== selectedIndex;
}
this.eventsArgs = {
options: this.modifiers,
element: this.element,
};
}
SelectChildClickAutomation.prototype._calculateEventArguments = function () {
var childElement = this.optionListExpanded ? selectController$1.getEmulatedChildElement(this.element) : this.element;
var parentSelectSize = styleUtils$4.getSelectElementSize(this.parentSelect) > 1;
return {
options: this.modifiers,
element: browserUtils$6.isIE && parentSelectSize ? this.parentSelect : childElement,
};
};
SelectChildClickAutomation.prototype._getMoveArguments = function () {
var element = null;
var offsetX = null;
var offsetY = null;
if (this.optionListExpanded) {
element = selectController$1.getEmulatedChildElement(this.element);
var moveActionOffsets = getDefaultAutomationOffsets(element);
offsetX = moveActionOffsets.offsetX;
offsetY = moveActionOffsets.offsetY;
}
else {
element = document.documentElement;
var elementCenter = selectElementUI$1.getSelectChildCenter(this.element);
offsetX = elementCenter.x;
offsetY = elementCenter.y;
}
return { element: element, offsetX: offsetX, offsetY: offsetY, speed: this.speed };
};
SelectChildClickAutomation.prototype._move = function (_a) {
var _this = this;
var element = _a.element, offsetX = _a.offsetX, offsetY = _a.offsetY, speed = _a.speed;
var moveOptions = new MoveOptions({
offsetX: offsetX,
offsetY: offsetY,
speed: speed,
modifiers: this.modifiers,
}, false);
return MoveAutomation.create(element, moveOptions, window, cursor)
.then(function (moveAutomation) {
return moveAutomation.run();
})
.then(function () { return delay$1(_this.automationSettings.mouseActionStepDelay); });
};
SelectChildClickAutomation.prototype._mousedown = function () {
var _this = this;
if (browserUtils$6.isFirefox) {
eventSimulator$6.mousedown(this.eventsArgs.element, this.eventsArgs.options);
if (this.clickCausesChange)
this.parentSelect.selectedIndex = this.childIndex;
return this._focus();
}
if (browserUtils$6.isIE) {
eventSimulator$6.mousedown(this.eventsArgs.element, this.eventsArgs.options);
return this._focus();
}
// NOTE: In Chrome, document.activeElement is 'select' after mousedown. But we need to
// raise blur and change the event for a previously active element during focus raising.
// That's why we should change the event order and raise focus before mousedown.
return this
._focus()
.then(function () { return delay$1(FOCUS_DELAY); })
.then(function () {
eventSimulator$6.mousedown(_this.eventsArgs.element, _this.eventsArgs.options);
if (_this.clickCausesChange)
_this.parentSelect.selectedIndex = _this.childIndex;
});
};
SelectChildClickAutomation.prototype._focus = function () {
var _this = this;
return new Promise$6(function (resolve) {
focusBlurSandbox$1.focus(_this.parentSelect, resolve, false, true);
});
};
SelectChildClickAutomation.prototype._mouseup = function () {
var elementForMouseupEvent = browserUtils$6.isIE ? this.parentSelect : this.eventsArgs.element;
eventSimulator$6.mouseup(elementForMouseupEvent, this.eventsArgs.options);
if (browserUtils$6.isIE && this.clickCausesChange)
this.parentSelect.selectedIndex = this.childIndex;
var simulateInputEventOnValueChange = browserUtils$6.isFirefox || browserUtils$6.isSafari ||
browserUtils$6.isChrome && browserUtils$6.version >= 53;
var simulateChangeEventOnValueChange = simulateInputEventOnValueChange || browserUtils$6.isIE;
if (simulateInputEventOnValueChange && this.clickCausesChange)
eventSimulator$6.input(this.parentSelect);
if (simulateChangeEventOnValueChange && this.clickCausesChange)
eventSimulator$6.change(this.parentSelect);
return Promise$6.resolve();
};
SelectChildClickAutomation.prototype._click = function () {
eventSimulator$6.click(this.eventsArgs.element, this.eventsArgs.options);
};
SelectChildClickAutomation.prototype.run = function () {
var _this = this;
if (!this.parentSelect) {
eventSimulator$6.click(this.eventsArgs.element, this.eventsArgs.options);
return Promise$6.resolve();
}
if (!this.optionListExpanded)
selectElementUI$1.scrollOptionListByChild(this.element);
var moveArguments = this._getMoveArguments();
this.eventsArgs = this._calculateEventArguments();
if (styleUtils$4.getSelectElementSize(this.parentSelect) <= 1) {
return this
._move(moveArguments)
.then(function () { return _this._click(); });
}
return this
._move(moveArguments)
.then(function () { return _this._mousedown(); })
.then(function () { return _this._mouseup(); })
.then(function () { return _this._click(); });
};
return SelectChildClickAutomation;
}());
var featureDetection$2 = hammerhead__default.utils.featureDetection;
var browserUtils$7 = hammerhead__default.utils.browser;
var eventSimulator$7 = hammerhead__default.eventSandbox.eventSimulator;
var eventUtils$2 = testCafeCore__default.eventUtils;
var delay$2 = testCafeCore__default.delay;
var FIRST_CLICK_DELAY = featureDetection$2.isTouchDevice ? 0 : 160;
var DblClickAutomation = /** @class */ (function (_super) {
__extends(DblClickAutomation, _super);
function DblClickAutomation(element, clickOptions) {
var _this = _super.call(this, element, clickOptions, window, cursor) || this;
_this.modifiers = clickOptions.modifiers;
_this.caretPos = clickOptions.caretPos;
_this.speed = clickOptions.speed;
_this.automationSettings = new AutomationSettings(_this.speed);
_this.offsetX = clickOptions.offsetX;
_this.offsetY = clickOptions.offsetY;
_this.eventArgs = null;
_this.eventState = {
dblClickElement: null,
};
return _this;
}
DblClickAutomation.prototype._firstClick = function (useStrictElementCheck) {
var _this = this;
// NOTE: we should always perform click with the highest speed
var clickOptions = new ClickOptions(this.options);
clickOptions.speed = 1;
var clickAutomation = new ClickAutomation(this.element, clickOptions, window, cursor);
clickAutomation.on(clickAutomation.TARGET_ELEMENT_FOUND_EVENT, function (e) { return _this.emit(_this.TARGET_ELEMENT_FOUND_EVENT, e); });
return clickAutomation.run(useStrictElementCheck)
.then(function (clickEventArgs) {
return delay$2(FIRST_CLICK_DELAY).then(function () { return clickEventArgs; });
});
};
DblClickAutomation.prototype._secondClick = function (eventArgs) {
var _this = this;
//NOTE: we should not call focus after the second mousedown (except in IE) because of the native browser behavior
if (browserUtils$7.isIE)
eventUtils$2.bind(document, 'focus', eventUtils$2.preventDefault, true);
var clickOptions = new ClickOptions({
offsetX: eventArgs.screenPoint.x,
offsetY: eventArgs.screenPoint.y,
caretPos: this.caretPos,
modifiers: this.modifiers,
speed: 1,
});
var clickAutomation = new ClickAutomation(document.documentElement, clickOptions, window, cursor);
return clickAutomation.run()
.then(function (clickEventArgs) {
// NOTE: We should raise the `dblclick` event on an element that
// has been actually clicked during the second click automation.
_this.eventState.dblClickElement = clickAutomation.strategy.eventState.clickElement;
if (browserUtils$7.isIE)
eventUtils$2.unbind(document, 'focus', eventUtils$2.preventDefault, true);
return clickEventArgs;
});
};
DblClickAutomation.prototype._dblClick = function (eventArgs) {
if (this.eventState.dblClickElement)
eventSimulator$7.dblclick(this.eventState.dblClickElement, eventArgs.options);
};
DblClickAutomation.prototype.run = function (useStrictElementCheck) {
var _this = this;
// NOTE: If the target element is out of viewport the firstClick sub-automation raises an error
return this
._firstClick(useStrictElementCheck)
.then(function (eventArgs) { return _this._secondClick(eventArgs); })
.then(function (eventArgs) { return _this._dblClick(eventArgs); });
};
return DblClickAutomation;
}(VisibleElementAutomation));
var DragAndDropState = /** @class */ (function () {
function DragAndDropState() {
this.enabled = false;
this.dropAllowed = false;
this.element = null;
this.dataTransfer = null;
this.dataStore = null;
}
return DragAndDropState;
}());
var nativeMethods$a = hammerhead__default.nativeMethods;
var featureDetection$3 = hammerhead__default.utils.featureDetection;
var htmlUtils$1 = hammerhead__default.utils.html;
var urlUtils = hammerhead__default.utils.url;
var DataTransfer = hammerhead__default.eventSandbox.DataTransfer;
var DragDataStore = hammerhead__default.eventSandbox.DragDataStore;
var eventUtils$3 = testCafeCore__default.eventUtils;
var domUtils$6 = testCafeCore__default.domUtils;
// Utils
function findDraggableElement(element) {
var parentNode = element;
while (parentNode) {
if (parentNode.draggable)
return parentNode;
parentNode = nativeMethods$a.nodeParentNodeGetter.call(parentNode);
}
return null;
}
var DragMoveAutomation = /** @class */ (function (_super) {
__extends(DragMoveAutomation, _super);
function DragMoveAutomation(element, offset, moveOptions, win, cursor) {
var _this = _super.call(this, element, offset, moveOptions, win, cursor) || this;
_this.dragElement = null;
_this.dragAndDropState = new DragAndDropState();
return _this;
}
DragMoveAutomation.create = function (el, moveOptions, win, cursor) {
return __awaiter(this, void 0, void 0, function () {
var _a, element, offset;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, MoveAutomation.getTarget(el, win, new AxisValues(moveOptions.offsetX, moveOptions.offsetY))];
case 1:
_a = _b.sent(), element = _a.element, offset = _a.offset;
return [2 /*return*/, new DragMoveAutomation(element, offset, moveOptions, win, cursor)];
}
});
});
};
DragMoveAutomation.prototype._getCursorSpeed = function () {
return this.automationSettings.draggingSpeed;
};
DragMoveAutomation.prototype._getEventSequenceOptions = function (currPosition) {
var _a = _super.prototype._getEventSequenceOptions.call(this, currPosition), eventOptions = _a.eventOptions, eventSequenceOptions = _a.eventSequenceOptions;
eventOptions.dataTransfer = this.dragAndDropState.dataTransfer;
eventOptions.buttons = eventUtils$3.BUTTONS_PARAMETER.leftButton;
eventSequenceOptions.holdLeftButton = true;
return { eventOptions: eventOptions, eventSequenceOptions: eventSequenceOptions };
};
DragMoveAutomation.prototype._getCorrectedTopElement = function (topElement) {
return this.touchMode ? this.dragElement : topElement;
};
DragMoveAutomation.prototype._runEventSequence = function (currentElement, _a) {
var eventOptions = _a.eventOptions, eventSequenceOptions = _a.eventSequenceOptions;
var eventSequence = createEventSequence(this.dragAndDropState.enabled, this.firstMovingStepOccured, eventSequenceOptions);
var _b = eventSequence.run(currentElement, lastHoveredElementHolder.get(), eventOptions, this.dragElement, this.dragAndDropState.dataStore), dragAndDropMode = _b.dragAndDropMode, dropAllowed = _b.dropAllowed;
this.dragAndDropState.enabled = dragAndDropMode;
this.dragAndDropState.dropAllowed = dropAllowed;
};
DragMoveAutomation.prototype._needMoveCursorImmediately = function () {
return false;
};
DragMoveAutomation.prototype.run = function () {
var _this = this;
return getElementFromPoint$2(this.cursor.getPosition())
.then(function (topElement) {
_this.dragElement = topElement;
var draggable = findDraggableElement(_this.dragElement);
// NOTE: we should skip simulating drag&drop's native behavior if the mousedown event was prevented (GH - 2529)
if (draggable && featureDetection$3.hasDataTransfer && !_this.skipDefaultDragBehavior) {
_this.dragAndDropState.enabled = true;
_this.dragElement = draggable;
_this.dragAndDropState.element = _this.dragElement;
_this.dragAndDropState.dataStore = new DragDataStore();
_this.dragAndDropState.dataTransfer = new DataTransfer(_this.dragAndDropState.dataStore);
var isLink = domUtils$6.isAnchorElement(_this.dragElement);
if (isLink || domUtils$6.isImgElement(_this.dragElement)) {
var srcAttr = isLink ? 'href' : 'src';
var parsedUrl = urlUtils.parseProxyUrl(_this.dragElement[srcAttr]);
var src = parsedUrl ? parsedUrl.destUrl : _this.dragElement[srcAttr];
var outerHTML = htmlUtils$1.cleanUpHtml(nativeMethods$a.elementOuterHTMLGetter.call(_this.dragElement));
_this.dragAndDropState.dataTransfer.setData('text/plain', src);
_this.dragAndDropState.dataTransfer.setData('text/uri-list', src);
_this.dragAndDropState.dataTransfer.setData('text/html', outerHTML);
}
}
return _super.prototype.run.call(_this)
.then(function () { return _this.dragAndDropState; });
});
};
return DragMoveAutomation;
}(MoveAutomation));
var MIN_MOVING_TIME = 25;
var Promise$7 = hammerhead__default.Promise;
var extend$1 = hammerhead__default.utils.extend;
var featureDetection$4 = hammerhead__default.utils.featureDetection;
var eventSimulator$8 = hammerhead__default.eventSandbox.eventSimulator;
var focusBlurSandbox$2 = hammerhead__default.eventSandbox.focusBlur;
var DragAutomationBase = /** @class */ (function (_super) {
__extends(DragAutomationBase, _super);
function DragAutomationBase(element, mouseOptions) {
var _this = _super.call(this, element, mouseOptions, window, cursor) || this;
_this.modifiers = mouseOptions.modifiers;
_this.speed = mouseOptions.speed;
_this.offsetX = mouseOptions.offsetX;
_this.offsetY = mouseOptions.offsetY;
_this.endPoint = null;
_this.simulateDefaultBehavior = true;
_this.downEvent = featureDetection$4.isTouchDevice ? 'touchstart' : 'mousedown';
_this.upEvent = featureDetection$4.isTouchDevice ? 'touchend' : 'mouseup';
_this.dragAndDropState = null;
return _this;
}
DragAutomationBase.prototype._getEndPoint = function () {
throw new Error('Not implemented');
};
DragAutomationBase.prototype._mousedown = function (eventArgs) {
var _this = this;
return cursor
.leftButtonDown()
.then(function () {
_this.simulateDefaultBehavior = eventSimulator$8[_this.downEvent](eventArgs.element, eventArgs.options);
return _this._focus(eventArgs);
});
};
DragAutomationBase.prototype._focus = function (eventArgs) {
var _this = this;
return new Promise$7(function (resolve) {
// NOTE: If the target element is a child of a contentEditable element, we need to call focus for its parent
var elementForFocus = testCafeCore.domUtils.isContentEditableElement(_this.element) ?
testCafeCore.contentEditable.findContentEditableParent(_this.element) : eventArgs.element;
focusBlurSandbox$2.focus(elementForFocus, resolve, false, true);
});
};
DragAutomationBase.prototype._getDestination = function () {
throw new Error('Not implemented');
};
DragAutomationBase.prototype._drag = function () {
var _this = this;
return this._getDestination()
.then(function (_a) {
var element = _a.element, offsets = _a.offsets, endPoint = _a.endPoint;
_this.endPoint = endPoint;
var dragOptions = new MoveOptions({
offsetX: offsets.offsetX,
offsetY: offsets.offsetY,
modifiers: _this.modifiers,
speed: _this.speed,
minMovingTime: MIN_MOVING_TIME,
skipDefaultDragBehavior: _this.simulateDefaultBehavior === false,
}, false);
return DragMoveAutomation.create(element, dragOptions, window, cursor);
})
.then(function (moveAutomation) {
return moveAutomation.run();
})
.then(function (dragAndDropState) {
_this.dragAndDropState = dragAndDropState;
return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay);
});
};
DragAutomationBase.prototype._mouseup = function () {
var _this = this;
return cursor
.buttonUp()
.then(function () {
var point = testCafeCore.positionUtils.offsetToClientCoords(_this.endPoint);
var topElement = null;
var options = extend$1({
clientX: point.x,
clientY: point.y,
}, _this.modifiers);
return getElementFromPoint$2(point)
.then(function (element) {
topElement = element;
if (!topElement)
return topElement;
if (_this.dragAndDropState.enabled) {
options.dataTransfer = _this.dragAndDropState.dataTransfer;
if (_this.dragAndDropState.dropAllowed)
eventSimulator$8.drop(topElement, options);
eventSimulator$8.dragend(_this.dragAndDropState.element, options);
_this.dragAndDropState.dataStore.setProtectedMode();
}
else
eventSimulator$8[_this.upEvent](topElement, options);
return getElementFromPoint$2(point);
})
.then(function (element) {
//B231323
if (topElement && element === topElement && !_this.dragAndDropState.enabled)
eventSimulator$8.click(topElement, options);
});
});
};
DragAutomationBase.prototype.run = function (useStrictElementCheck) {
var _this = this;
var eventArgs = null;
return this
._ensureElement(useStrictElementCheck)
.then(function (_a) {
var element = _a.element, clientPoint = _a.clientPoint;
eventArgs = {
point: clientPoint,
element: element,
options: extend$1({
clientX: clientPoint.x,
clientY: clientPoint.y,
}, _this.modifiers),
};
// NOTE: we should raise start drag with 'mouseActionStepDelay' after we trigger
// mousedown event regardless of how long mousedown event handlers were executing
return Promise$7.all([testCafeCore.delay(_this.automationSettings.mouseActionStepDelay), _this._mousedown(eventArgs)]);
})
.then(function () { return _this._drag(); })
.then(function () { return _this._mouseup(); });
};
return DragAutomationBase;
}(VisibleElementAutomation));
var styleUtils$5 = testCafeCore__default.styleUtils;
var DragToOffsetAutomation = /** @class */ (function (_super) {
__extends(DragToOffsetAutomation, _super);
function DragToOffsetAutomation(element, offsetX, offsetY, mouseOptions) {
var _this = _super.call(this, element, mouseOptions) || this;
_this.dragOffsetX = offsetX;
_this.dragOffsetY = offsetY;
return _this;
}
DragToOffsetAutomation.prototype._getDestination = function () {
return __awaiter(this, void 0, void 0, function () {
var startPoint, maxX, maxY, endPoint, element, offsets;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, getAutomationPoint(this.element, { x: this.offsetX, y: this.offsetY })];
case 1:
startPoint = _a.sent();
maxX = styleUtils$5.getWidth(document);
maxY = styleUtils$5.getHeight(document);
endPoint = {
x: startPoint.x + this.dragOffsetX,
y: startPoint.y + this.dragOffsetY,
};
endPoint = {
x: Math.min(Math.max(0, endPoint.x), maxX),
y: Math.min(Math.max(0, endPoint.y), maxY),
};
element = document.documentElement;
offsets = {
offsetX: endPoint.x,
offsetY: endPoint.y,
};
return [2 /*return*/, { element: element, offsets: offsets, endPoint: endPoint }];
}
});
});
};
return DragToOffsetAutomation;
}(DragAutomationBase));
var positionUtils$3 = testCafeCore__default.positionUtils;
var DragToElementAutomation = /** @class */ (function (_super) {
__extends(DragToElementAutomation, _super);
function DragToElementAutomation(element, destinationElement, dragToElementOptions) {
var _this = _super.call(this, element, dragToElementOptions) || this;
_this.destinationElement = destinationElement;
_this.destinationOffsetX = dragToElementOptions.destinationOffsetX;
_this.destinationOffsetY = dragToElementOptions.destinationOffsetY;
return _this;
}
DragToElementAutomation.prototype._getDestination = function () {
return __awaiter(this, void 0, void 0, function () {
var element, elementRect, offsets, endPoint;
return __generator(this, function (_a) {
element = this.destinationElement;
elementRect = positionUtils$3.getElementRectangle(element);
offsets = getOffsetOptions(element, this.destinationOffsetX, this.destinationOffsetY);
endPoint = {
x: elementRect.left + offsets.offsetX,
y: elementRect.top + offsets.offsetY,
};
return [2 /*return*/, { element: element, offsets: offsets, endPoint: endPoint }];
});
});
};
return DragToElementAutomation;
}(DragAutomationBase));
var HoverAutomation = /** @class */ (function (_super) {
__extends(HoverAutomation, _super);
function HoverAutomation(element, hoverOptions) {
return _super.call(this, element, hoverOptions, window, cursor) || this;
}
HoverAutomation.prototype.run = function (useStrictElementCheck) {
return this._ensureElement(useStrictElementCheck, true);
};
return HoverAutomation;
}(VisibleElementAutomation));
var browserUtils$8 = hammerhead__default.utils.browser;
var eventSandbox = hammerhead__default.sandbox.event;
var eventSimulator$9 = hammerhead__default.eventSandbox.eventSimulator;
var listeners$4 = hammerhead__default.eventSandbox.listeners;
var nativeMethods$b = hammerhead__default.nativeMethods;
var domUtils$7 = testCafeCore__default.domUtils;
var contentEditable$1 = testCafeCore__default.contentEditable;
var textSelection$1 = testCafeCore__default.textSelection;
var WHITE_SPACES_RE = / /g;
function _getSelectionInElement(element) {
var currentSelection = textSelection$1.getSelectionByElement(element);
var isInverseSelection = textSelection$1.hasInverseSelectionContentEditable(element);
if (textSelection$1.hasElementContainsSelection(element))
return contentEditable$1.getSelection(element, currentSelection, isInverseSelection);
// NOTE: if we type text to an element that doesn't contain selection we
// assume the selectionStart and selectionEnd positions are null in this
// element. So we calculate the necessary start and end nodes and offsets
return {
startPos: contentEditable$1.calculateNodeAndOffsetByPosition(element, 0),
endPos: contentEditable$1.calculateNodeAndOffsetByPosition(element, 0),
};
}
function _updateSelectionAfterDeletionContent(element, selection) {
var startNode = selection.startPos.node;
var startParent = nativeMethods$b.nodeParentNodeGetter.call(startNode);
var hasStartParent = startParent && startNode.parentElement;
var browserRequiresSelectionUpdating = browserUtils$8.isChrome && browserUtils$8.version < 58 || browserUtils$8.isSafari;
if (browserRequiresSelectionUpdating || !hasStartParent || !domUtils$7.isElementContainsNode(element, startNode)) {
selection = _getSelectionInElement(element);
if (textSelection$1.hasInverseSelectionContentEditable(element)) {
selection = {
startPos: selection.endPos,
endPos: selection.startPos,
};
}
}
selection.endPos.offset = selection.startPos.offset;
return selection;
}
function _typeTextInElementNode(elementNode, text, offset) {
var nodeForTyping = document.createTextNode(text);
var textLength = text.length;
var selectPosition = { node: nodeForTyping, offset: textLength };
var parent = nativeMethods$b.nodeParentNodeGetter.call(elementNode);
if (domUtils$7.getTagName(elementNode) === 'br')
parent.insertBefore(nodeForTyping, elementNode);
else if (offset > 0) {
var childNodes = nativeMethods$b.nodeChildNodesGetter.call(elementNode);
elementNode.insertBefore(nodeForTyping, childNodes[offset]);
}
else
elementNode.appendChild(nodeForTyping);
textSelection$1.selectByNodesAndOffsets(selectPosition, selectPosition);
}
function _typeTextInChildTextNode(element, selection, text) {
var startNode = selection.startPos.node;
// NOTE: startNode could be moved or deleted on textInput event. Need ensure startNode.
if (!domUtils$7.isElementContainsNode(element, startNode)) {
selection = _excludeInvisibleSymbolsFromSelection(_getSelectionInElement(element));
startNode = selection.startPos.node;
}
var startOffset = selection.startPos.offset;
var endOffset = selection.endPos.offset;
var nodeValue = startNode.nodeValue;
var selectPosition = { node: startNode, offset: startOffset + text.length };
startNode.nodeValue = nodeValue.substring(0, startOffset) + text +
nodeValue.substring(endOffset, nodeValue.length);
textSelection$1.selectByNodesAndOffsets(selectPosition, selectPosition);
}
function _excludeInvisibleSymbolsFromSelection(selection) {
var startNode = selection.startPos.node;
var startOffset = selection.startPos.offset;
var endOffset = selection.endPos.offset;
var firstNonWhitespaceSymbolIndex = contentEditable$1.getFirstNonWhitespaceSymbolIndex(startNode.nodeValue);
var lastNonWhitespaceSymbolIndex = contentEditable$1.getLastNonWhitespaceSymbolIndex(startNode.nodeValue);
if (startOffset < firstNonWhitespaceSymbolIndex && startOffset !== 0) {
selection.startPos.offset = firstNonWhitespaceSymbolIndex;
selection.endPos.offset = endOffset + firstNonWhitespaceSymbolIndex - startOffset;
}
else if (endOffset > lastNonWhitespaceSymbolIndex && endOffset !== startNode.nodeValue.length) {
selection.startPos.offset = startNode.nodeValue.length;
selection.endPos.offset = endOffset + startNode.nodeValue.length - startOffset;
}
return selection;
}
// NOTE: https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/beforeinput_event
// The `beforeInput` event is supported only in Chrome-based browsers and Safari
// The order of events differs in Chrome and Safari:
// In Chrome: `beforeinput` occurs before `textInput`
// In Safari: `beforeinput` occurs after `textInput`
function simulateBeforeInput(element, text, needSimulate) {
if (needSimulate)
return eventSimulator$9.beforeInput(element, text);
return true;
}
// NOTE: Typing can be prevented in Chrome/Edge but can not be prevented in IE11 or Firefox
// Firefox does not support TextInput event
// Safari supports the TextInput event but has a bug: e.data is added to the node value.
// So in Safari we need to call preventDefault in the last textInput handler but not prevent the Input event
function simulateTextInput(element, text) {
var forceInputInSafari;
function onSafariTextInput(e) {
e.preventDefault();
forceInputInSafari = true;
}
function onSafariPreventTextInput(e) {
if (e.type === 'textInput')
forceInputInSafari = false;
}
if (browserUtils$8.isSafari) {
listeners$4.addInternalEventBeforeListener(window, ['textInput'], onSafariTextInput);
eventSandbox.on(eventSandbox.EVENT_PREVENTED_EVENT, onSafariPreventTextInput);
}
var isInputEventRequired = browserUtils$8.isFirefox || eventSimulator$9.textInput(element, text) || forceInputInSafari;
if (browserUtils$8.isSafari) {
listeners$4.removeInternalEventBeforeListener(window, ['textInput'], onSafariTextInput);
eventSandbox.off(eventSandbox.EVENT_PREVENTED_EVENT, onSafariPreventTextInput);
}
return isInputEventRequired || browserUtils$8.isIE11;
}
function _typeTextToContentEditable(element, text) {
var currentSelection = _getSelectionInElement(element);
var startNode = currentSelection.startPos.node;
var endNode = currentSelection.endPos.node;
var needProcessInput = true;
var needRaiseInputEvent = true;
var textInputData = text;
text = text.replace(WHITE_SPACES_RE, String.fromCharCode(160));
// NOTE: some browsers raise the 'input' event after the element
// content is changed, but in others we should do it manually.
var onInput = function () {
needRaiseInputEvent = false;
};
// NOTE: IE11 raises the 'textinput' event many times after the element changed.
// The 'textinput' should be called only once
function onTextInput(event, dispatched, preventEvent) {
preventEvent();
}
// NOTE: IE11 does not raise input event when type to contenteditable
var beforeContentChanged = function () {
needProcessInput = simulateTextInput(element, textInputData);
needRaiseInputEvent = needProcessInput && !browserUtils$8.isIE11;
listeners$4.addInternalEventBeforeListener(window, ['input'], onInput);
listeners$4.addInternalEventBeforeListener(window, ['textinput'], onTextInput);
};
var afterContentChanged = function () {
nextTick()
.then(function () {
if (needRaiseInputEvent)
eventSimulator$9.input(element, text);
listeners$4.removeInternalEventBeforeListener(window, ['input'], onInput);
listeners$4.removeInternalEventBeforeListener(window, ['textinput'], onTextInput);
});
};
if (!startNode || !endNode || !domUtils$7.isContentEditableElement(startNode) ||
!domUtils$7.isContentEditableElement(endNode))
return;
if (!domUtils$7.isTheSameNode(startNode, endNode)) {
textSelection$1.deleteSelectionContents(element);
// NOTE: after deleting the selection contents we should refresh the stored startNode because
// contentEditable element's content could change and we can no longer find parent elements
// of the nodes. In MSEdge, 'parentElement' for the deleted element isn't undefined
currentSelection = _updateSelectionAfterDeletionContent(element, currentSelection);
startNode = currentSelection.startPos.node;
}
if (!startNode || !domUtils$7.isContentEditableElement(startNode) || !domUtils$7.isRenderedNode(startNode))
return;
if (!simulateBeforeInput(element, text, browserUtils$8.isChrome || browserUtils$8.isFirefox))
return;
beforeContentChanged();
if (needProcessInput)
needProcessInput = simulateBeforeInput(element, text, browserUtils$8.isSafari);
if (needProcessInput) {
// NOTE: we can type only to the text nodes; for nodes with the 'element-node' type, we use a special behavior
if (domUtils$7.isElementNode(startNode))
_typeTextInElementNode(startNode, text);
else
_typeTextInChildTextNode(element, _excludeInvisibleSymbolsFromSelection(currentSelection), text);
}
afterContentChanged();
}
function _typeTextToTextEditable(element, text) {
var elementValue = domUtils$7.getElementValue(element);
var textLength = text.length;
var startSelection = textSelection$1.getSelectionStart(element);
var endSelection = textSelection$1.getSelectionEnd(element);
var isInputTypeNumber = domUtils$7.isInputElement(element) && element.type === 'number';
if (!simulateBeforeInput(element, text, browserUtils$8.isChrome || browserUtils$8.isFirefox))
return;
var needProcessInput = simulateTextInput(element, text);
if (needProcessInput)
needProcessInput = simulateBeforeInput(element, text, browserUtils$8.isSafari);
if (!needProcessInput)
return;
// NOTE: the 'maxlength' attribute doesn't work in all browsers. IE still doesn't support input with the 'number' type
var elementMaxLength = !browserUtils$8.isIE && isInputTypeNumber ? null : parseInt(element.maxLength, 10);
if (elementMaxLength < 0)
elementMaxLength = browserUtils$8.isIE && browserUtils$8.version < 17 ? 0 : null;
var newElementValue = elementValue.substring(0, startSelection) + text + elementValue.substring(endSelection, elementValue.length);
if (elementMaxLength === null || isNaN(elementMaxLength) || elementMaxLength >= newElementValue.length) {
// NOTE: B254013
if (isInputTypeNumber && browserUtils$8.isIOS && elementValue[elementValue.length - 1] === '.') {
startSelection += 1;
endSelection += 1;
}
domUtils$7.setElementValue(element, newElementValue);
textSelection$1.select(element, startSelection + textLength, startSelection + textLength);
}
// NOTE: We should simulate the 'input' event after typing a char (B253410, T138385)
eventSimulator$9.input(element, text);
}
function _typeTextToNonTextEditable(element, text, caretPos) {
if (caretPos !== null) {
var elementValue = domUtils$7.getElementValue(element);
domUtils$7.setElementValue(element, elementValue.substr(0, caretPos) + text + elementValue.substr(caretPos + text.length));
}
else
domUtils$7.setElementValue(element, text);
eventSimulator$9.change(element);
eventSimulator$9.input(element, text);
}
function typeText (element, text, caretPos) {
if (domUtils$7.isContentEditableElement(element))
_typeTextToContentEditable(element, text);
if (!domUtils$7.isElementReadOnly(element)) {
if (domUtils$7.isTextEditableElement(element))
_typeTextToTextEditable(element, text);
else if (domUtils$7.isInputElement(element))
_typeTextToNonTextEditable(element, text, caretPos);
}
}
function isLetterKey (key) {
return key.length === 1 && (key >= 'a' && key <= 'z' || key >= 'A' && key <= 'Z');
}
var nativeMethods$c = hammerhead__default.nativeMethods;
var browserUtils$9 = hammerhead__default.utils.browser;
var focusBlurSandbox$3 = hammerhead__default.eventSandbox.focusBlur;
var Promise$8 = hammerhead__default.Promise;
var isRadioButtonElement$1 = testCafeCore.domUtils.isRadioButtonElement, getActiveElement$1 = testCafeCore.domUtils.getActiveElement, getTabIndexAttributeIntValue = testCafeCore.domUtils.getTabIndexAttributeIntValue;
function changeLetterCase(letter) {
var isLowCase = letter === letter.toLowerCase();
return isLowCase ? letter.toUpperCase() : letter.toLowerCase();
}
function getActualKeysAndEventKeyProperties(keyArray) {
var eventKeyProperties = keyArray.slice();
//NOTE: check 'shift' modifier in keys
for (var i = 0; i < keyArray.length; i++) {
var key = keyArray[i];
if (key.toLowerCase() === 'shift') {
var nextKey = keyArray[i + 1];
if (!nextKey)
continue;
if (testCafeCore.KEY_MAPS.shiftMap[nextKey])
keyArray[i + 1] = testCafeCore.KEY_MAPS.shiftMap[nextKey];
else if (testCafeCore.KEY_MAPS.reversedShiftMap[nextKey])
eventKeyProperties[i + 1] = testCafeCore.KEY_MAPS.reversedShiftMap[nextKey];
}
if (testCafeCore.KEY_MAPS.shiftMap[key] && (!keyArray[i - 1] || keyArray[i - 1].toLowerCase() !== 'shift')) {
keyArray[i] = testCafeCore.KEY_MAPS.shiftMap[key];
keyArray.splice(i, 0, 'shift');
eventKeyProperties.splice(i, 0, 'shift');
i++;
}
}
return { actualKeys: keyArray, eventKeyProperties: eventKeyProperties };
}
function getChar(key, shiftModified) {
if (key === 'space')
return ' ';
if (shiftModified) {
if (isLetterKey(key))
return changeLetterCase(key);
if (testCafeCore.KEY_MAPS.reversedShiftMap[key])
return testCafeCore.KEY_MAPS.reversedShiftMap[key];
}
return key;
}
function getDeepActiveElement(currentDocument) {
var doc = currentDocument || document;
var activeElement = getActiveElement$1(doc);
var activeElementInIframe = null;
if (activeElement && testCafeCore.domUtils.isIframeElement(activeElement) &&
nativeMethods$c.contentDocumentGetter.call(activeElement)) {
try {
activeElementInIframe = getDeepActiveElement(nativeMethods$c.contentDocumentGetter.call(activeElement));
}
catch (e) { // eslint-disable-line no-empty
}
}
return activeElementInIframe || activeElement;
}
function focusNextElement(element, reverse, skipRadioGroups) {
return new Promise$8(function (resolve) {
var nextElement = getNextFocusableElement(element, reverse, skipRadioGroups);
if (nextElement)
focusBlurSandbox$3.focus(nextElement, function () { return resolve(nextElement); });
else
resolve();
});
}
function getFocusableElementsFilter(sourceElement, skipRadioGroups) {
var filter = null;
if (skipRadioGroups) {
// NOTE: in all browsers except Mozilla and Opera focus sets on one radio set from group only.
// in Mozilla and Opera focus sets on any radio set.
if (sourceElement.name !== '' && !browserUtils$9.isFirefox)
filter = function (item) { return !item.name || item === sourceElement || item.name !== sourceElement.name; };
}
// NOTE arrow navigations works with radio buttons in all browsers only between radio buttons with same names
// Navigation between radio buttons without name just moves focus between radio buttons in Chrome
// In other browsers navigation between radio buttons without name does not work
else if (sourceElement.name !== '')
filter = function (item) { return isRadioButtonElement$1(item) && item.name === sourceElement.name; };
else if (browserUtils$9.isChrome)
filter = function (item) { return isRadioButtonElement$1(item) && !item.name; };
return filter;
}
function filterFocusableElements(elements, sourceElement, skipRadioGroups) {
if (!isRadioButtonElement$1(sourceElement))
return elements;
if (!skipRadioGroups && !sourceElement.name && !browserUtils$9.isChrome)
return [sourceElement];
var filterFn = getFocusableElementsFilter(sourceElement, skipRadioGroups);
if (filterFn)
elements = testCafeCore.arrayUtils.filter(elements, filterFn);
return elements;
}
function correctFocusableElement(elements, element, skipRadioGroups) {
var isNotCheckedRadioButtonElement = isRadioButtonElement$1(element) && element.name && !element.checked;
var checkedRadioButtonElementWithSameName = null;
if (skipRadioGroups && isNotCheckedRadioButtonElement) {
checkedRadioButtonElementWithSameName = testCafeCore.arrayUtils.find(elements, function (el) {
return isRadioButtonElement$1(el) && el.name === element.name && el.checked;
});
}
return checkedRadioButtonElementWithSameName || element;
}
function activeElementHasNegativeTabIndex(doc) {
var activeElement = nativeMethods$c.documentActiveElementGetter.call(doc);
var activeElementTabIndex = activeElement && getTabIndexAttributeIntValue(activeElement);
return activeElement && activeElementTabIndex < 0;
}
function getNextFocusableElement(element, reverse, skipRadioGroups) {
var offset = reverse ? -1 : 1;
var doc = testCafeCore.domUtils.getTopSameDomainWindow(window).document;
var sort = !activeElementHasNegativeTabIndex(doc);
var allFocusable = testCafeCore.domUtils.getFocusableElements(doc, sort);
allFocusable = filterFocusableElements(allFocusable, element, skipRadioGroups);
var isRadioInput = isRadioButtonElement$1(element);
var currentIndex = testCafeCore.arrayUtils.indexOf(allFocusable, element);
var isLastElementFocused = reverse ? currentIndex === 0 : currentIndex === allFocusable.length - 1;
if (isLastElementFocused) {
if (!reverse && element.tabIndex < 0)
return testCafeCore.arrayUtils.find(allFocusable, function (el) { return el.tabIndex === 0; });
return skipRadioGroups || !isRadioInput ? document.body : allFocusable[allFocusable.length - 1 - currentIndex];
}
if (reverse && currentIndex === -1)
return allFocusable[allFocusable.length - 1];
return correctFocusableElement(allFocusable, allFocusable[currentIndex + offset], skipRadioGroups);
}
function getKeyCode (char) {
if (isLetterKey(char))
return char.toUpperCase().charCodeAt(0);
var res = testCafeCore.KEY_MAPS.shiftMap[char] ? testCafeCore.KEY_MAPS.shiftMap[char].charCodeAt(0) : char.charCodeAt(0);
return testCafeCore.KEY_MAPS.symbolCharCodeToKeyCode[res] || res;
}
var KEY_IDENTIFIER_MAPS = {
SPECIAL_KEYS: {
capslock: 'CapsLock',
delete: 'U+007F',
end: 'End',
enter: 'Enter',
esc: 'U+001B',
home: 'Home',
ins: 'Insert',
pagedown: 'PageDown',
pageup: 'PageUp',
space: 'U+0020',
tab: 'Tab',
alt: 'Alt',
ctrl: 'Control',
meta: 'Meta',
shift: 'Shift',
},
LETTERS: {
a: 'U+0041',
b: 'U+0042',
c: 'U+0043',
d: 'U+0044',
e: 'U+0045',
f: 'U+0046',
g: 'U+0047',
h: 'U+0048',
i: 'U+0049',
j: 'U+004A',
k: 'U+004B',
l: 'U+004C',
m: 'U+004D',
n: 'U+004E',
o: 'U+004F',
p: 'U+0050',
q: 'U+0051',
r: 'U+0052',
s: 'U+0053',
t: 'U+0054',
u: 'U+0055',
v: 'U+0056',
w: 'U+0057',
x: 'U+0058',
y: 'U+0059',
z: 'U+005A',
},
SYMBOLS: {
'0': 'U+0030',
'1': 'U+0031',
'2': 'U+0032',
'3': 'U+0033',
'4': 'U+0034',
'5': 'U+0035',
'6': 'U+0036',
'7': 'U+0037',
'8': 'U+0038',
'9': 'U+0039',
' ': 'U+0020',
'!': 'U+0021',
'@': 'U+0040',
'#': 'U+0023',
'$': 'U+0024',
'%': 'U+0025',
'^': 'U+005E',
'*': 'U+002A',
'(': 'U+0028',
')': 'U+0029',
'_': 'U+005F',
'|': 'U+007C',
'\\': 'U+005C',
'/': 'U+002F',
'?': 'U+003F',
'.': 'U+002E',
',': 'U+002C',
'<': 'U+003C',
'>': 'U+003E',
'[': 'U+005B',
']': 'U+005D',
'{': 'U+007B',
'}': 'U+007D',
'§': 'U+00A7',
'±': 'U+00B1',
'\'': 'U+0027',
'"': 'U+0022',
':': 'U+003A',
';': 'U+003B',
'`': 'U+0060',
'~': 'U+007E',
},
};
function getKeyIdentifier(char) {
if (isLetterKey(char))
return KEY_IDENTIFIER_MAPS.LETTERS[char.toLowerCase()];
return KEY_IDENTIFIER_MAPS.SYMBOLS[char] || KEY_IDENTIFIER_MAPS.SPECIAL_KEYS[char] || char;
}
function getKeyProperties(isKeyPressEvent, key, keyIdentifier) {
var properties = {};
if ('keyIdentifier' in KeyboardEvent.prototype)
properties.keyIdentifier = isKeyPressEvent ? '' : keyIdentifier;
if ('key' in KeyboardEvent.prototype)
properties.key = key;
return properties;
}
var browserUtils$a = hammerhead__default.utils.browser;
var extend$2 = hammerhead__default.utils.extend;
var eventSimulator$a = hammerhead__default.eventSandbox.eventSimulator;
var KeyPressSimulator = /** @class */ (function () {
function KeyPressSimulator(key, eventKeyProperty) {
this.isLetter = isLetterKey(key);
this.isChar = key.length === 1 || key === 'space';
this.sanitizedKey = testCafeCore.getSanitizedKey(key);
this.modifierKeyCode = testCafeCore.KEY_MAPS.modifiers[this.sanitizedKey];
this.specialKeyCode = testCafeCore.KEY_MAPS.specialKeys[this.sanitizedKey];
this.keyCode = null;
this.keyIdentifierProperty = getKeyIdentifier(eventKeyProperty);
this.topSameDomainDocument = testCafeCore.domUtils.getTopSameDomainWindow(window).document;
this.keyProperty = testCafeCore.KEY_MAPS.keyProperty[eventKeyProperty] || eventKeyProperty;
if (this.isChar && key !== 'space')
this.keyCode = getKeyCode(this.sanitizedKey);
else if (this.modifierKeyCode)
this.keyCode = this.modifierKeyCode;
else if (this.specialKeyCode)
this.keyCode = this.specialKeyCode;
this.storedActiveElement = null;
}
KeyPressSimulator._isKeyActivatedInputElement = function (el) {
return testCafeCore.domUtils.isInputElement(el) && /button|submit|reset|radio|checkbox/.test(el.type);
};
KeyPressSimulator.prototype._type = function (element, char) {
var elementChanged = element !== this.storedActiveElement;
var shouldType = !elementChanged;
var elementForTyping = element;
var isActiveElementEditable = testCafeCore.domUtils.isEditableElement(element);
var isStoredElementEditable = testCafeCore.domUtils.isEditableElement(this.storedActiveElement);
// Unnecessary typing happens if an element was changed after the keydown/keypress event (T210448)
// In IE, this error may occur when we try to determine if the removed element is in an iframe
try {
if (elementChanged) {
var isActiveElementInIframe = testCafeCore.domUtils.isElementInIframe(element);
var isStoredElementInIframe = testCafeCore.domUtils.isElementInIframe(this.storedActiveElement);
var shouldTypeInWebKit = isActiveElementInIframe === isStoredElementInIframe || isStoredElementEditable;
shouldType = (!browserUtils$a.isFirefox || isStoredElementEditable) &&
(!browserUtils$a.isWebKit || shouldTypeInWebKit);
}
}
/*eslint-disable no-empty */
catch (err) {
}
/*eslint-disable no-empty */
if (shouldType) {
if (!browserUtils$a.isIE && elementChanged && isStoredElementEditable && isActiveElementEditable)
elementForTyping = this.storedActiveElement;
typeText(elementForTyping, char);
}
};
KeyPressSimulator.prototype._addKeyPropertyToEventOptions = function (eventOptions) {
extend$2(eventOptions, getKeyProperties(eventOptions.type === 'keypress', this.keyProperty, this.keyIdentifierProperty));
return eventOptions;
};
KeyPressSimulator.prototype.down = function (modifiersState) {
this.storedActiveElement = getDeepActiveElement(this.topSameDomainDocument);
if (this.modifierKeyCode)
modifiersState[this.sanitizedKey] = true;
if (modifiersState.shift && this.isLetter)
this.keyProperty = changeLetterCase(this.keyProperty);
var eventOptions = { keyCode: this.keyCode, type: 'keydown' };
this._addKeyPropertyToEventOptions(eventOptions);
return eventSimulator$a.keydown(this.storedActiveElement, extend$2(eventOptions, modifiersState));
};
KeyPressSimulator.prototype.press = function (modifiersState) {
if (!(this.isChar || this.specialKeyCode))
return true;
var activeElement = getDeepActiveElement(this.topSameDomainDocument);
var character = this.isChar ? getChar(this.sanitizedKey, modifiersState.shift) : null;
var charCode = this.specialKeyCode || character.charCodeAt(0);
var elementChanged = activeElement !== this.storedActiveElement;
if (browserUtils$a.isWebKit && elementChanged) {
var isActiveElementInIframe = testCafeCore.domUtils.isElementInIframe(activeElement);
var isStoredElementInIframe = testCafeCore.domUtils.isElementInIframe(this.storedActiveElement);
if (isActiveElementInIframe !== isStoredElementInIframe)
return true;
}
this.storedActiveElement = activeElement;
var eventOptions = { keyCode: charCode, charCode: charCode, type: 'keypress' };
this._addKeyPropertyToEventOptions(eventOptions);
var raiseDefault = browserUtils$a.isAndroid || eventSimulator$a.keypress(activeElement, extend$2(eventOptions, modifiersState));
if (!raiseDefault)
return raiseDefault;
activeElement = getDeepActiveElement(this.topSameDomainDocument);
if (character && !(modifiersState.ctrl || modifiersState.alt))
this._type(activeElement, character);
var isKeyActivatedInput = KeyPressSimulator._isKeyActivatedInputElement(activeElement);
var isButton = testCafeCore.domUtils.isButtonElement(activeElement);
var isSafariWithAutoRaisedClick = browserUtils$a.isSafari &&
browserUtils$a.compareVersions([browserUtils$a.webkitVersion, '603.1.30']) >= 0;
var raiseClickOnEnter = !isSafariWithAutoRaisedClick && (isKeyActivatedInput || isButton);
if (raiseClickOnEnter && this.sanitizedKey === 'enter')
activeElement.click();
return raiseDefault;
};
KeyPressSimulator.prototype.up = function (modifiersState) {
if (this.modifierKeyCode)
modifiersState[this.sanitizedKey] = false;
var eventOptions = { keyCode: this.keyCode, type: 'keyup' };
this._addKeyPropertyToEventOptions(eventOptions);
var raiseDefault = eventSimulator$a.keyup(getDeepActiveElement(this.topSameDomainDocument), extend$2(eventOptions, modifiersState));
var activeElement = getDeepActiveElement(this.topSameDomainDocument);
// NOTE: in some browsers we should emulate click on active input element while pressing "space" key
var emulateClick = !browserUtils$a.isFirefox && !browserUtils$a.isSafari &&
(!browserUtils$a.isChrome || browserUtils$a.version >= 53);
if (emulateClick && raiseDefault && this.sanitizedKey === 'space' &&
KeyPressSimulator._isKeyActivatedInputElement(activeElement))
activeElement.click();
return raiseDefault;
};
Object.defineProperty(KeyPressSimulator.prototype, "key", {
get: function () {
return this.sanitizedKey;
},
enumerable: false,
configurable: true
});
return KeyPressSimulator;
}());
var SHORTCUT_TYPE = {
ctrlA: 'ctrl+a',
backspace: 'backspace',
delete: 'delete',
left: 'left',
right: 'right',
up: 'up',
down: 'down',
shiftLeft: 'shift+left',
shiftRight: 'shift+right',
shiftUp: 'shift+up',
shiftDown: 'shift+down',
shiftHome: 'shift+home',
shiftEnd: 'shift+end',
home: 'home',
end: 'end',
enter: 'enter',
tab: 'tab',
shiftTab: 'shift+tab',
esc: 'esc',
};
var _a;
var Promise$9 = hammerhead__default.Promise;
var browserUtils$b = hammerhead__default.utils.browser;
var eventSimulator$b = hammerhead__default.eventSandbox.eventSimulator;
var elementEditingWatcher = hammerhead__default.eventSandbox.elementEditingWatcher;
var textSelection$2 = testCafeCore__default.textSelection;
var eventUtils$4 = testCafeCore__default.eventUtils;
var domUtils$8 = testCafeCore__default.domUtils;
var selectElement = testCafeUI.selectElement;
var currentTextarea = null;
var currentTextareaCursorIndent = null;
function onTextAreaBlur() {
currentTextarea = null;
currentTextareaCursorIndent = null;
eventUtils$4.unbind(this, 'blur', onTextAreaBlur, true);
}
function updateTextAreaIndent(element) {
if (domUtils$8.isTextAreaElement(element)) {
if (currentTextarea !== element) {
eventUtils$4.bind(element, 'blur', onTextAreaBlur, true);
currentTextarea = element;
}
currentTextareaCursorIndent = getLineIndentInTextarea(element);
}
}
function getLineIndentInTextarea(textarea) {
var inverseSelection = textSelection$2.hasInverseSelection(textarea);
var textareaValue = domUtils$8.getTextAreaValue(textarea);
var cursorPosition = inverseSelection ?
textSelection$2.getSelectionStart(textarea) :
textSelection$2.getSelectionEnd(textarea);
if (!textareaValue || !cursorPosition)
return 0;
return domUtils$8.getTextareaIndentInLine(textarea, cursorPosition);
}
function moveTextAreaCursorUp(element, withSelection) {
var textareaValue = domUtils$8.getTextAreaValue(element);
if (!textareaValue)
return;
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var hasInverseSelection = textSelection$2.hasInverseSelection(element);
var partBeforeCursor = textareaValue.substring(0, hasInverseSelection ? startPos : endPos);
var lastLineBreakIndex = partBeforeCursor.lastIndexOf('\n');
var partBeforeLastLineBreak = partBeforeCursor.substring(0, lastLineBreakIndex);
if (currentTextareaCursorIndent === null || currentTextarea !== element)
updateTextAreaIndent(element);
lastLineBreakIndex = partBeforeLastLineBreak.lastIndexOf('\n');
var newPosition = Math.min(lastLineBreakIndex + 1 + currentTextareaCursorIndent, partBeforeLastLineBreak.length);
moveTextAreaCursor(element, startPos, endPos, hasInverseSelection, newPosition, withSelection);
}
function moveTextAreaCursorDown(element, withSelection) {
var textareaValue = domUtils$8.getTextAreaValue(element);
if (!textareaValue)
return;
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var hasInverseSelection = textSelection$2.hasInverseSelection(element);
var cursorPosition = hasInverseSelection ? startPos : endPos;
var partAfterCursor = textareaValue.substring(cursorPosition);
var firstLineBreakIndex = partAfterCursor.indexOf('\n');
var nextLineStartIndex = firstLineBreakIndex === -1 ? partAfterCursor.length : firstLineBreakIndex + 1;
var partAfterNewIndent = partAfterCursor.substring(nextLineStartIndex);
var newPosition = cursorPosition + nextLineStartIndex;
firstLineBreakIndex = partAfterNewIndent.indexOf('\n');
var maxIndent = firstLineBreakIndex === -1 ? partAfterNewIndent.length : firstLineBreakIndex;
if (currentTextareaCursorIndent === null || currentTextarea !== element)
updateTextAreaIndent(element);
newPosition = Math.min(newPosition + currentTextareaCursorIndent, newPosition + maxIndent);
moveTextAreaCursor(element, startPos, endPos, hasInverseSelection, newPosition, withSelection);
}
function moveTextAreaCursor(element, startPos, endPos, hasInverseSelection, newPosition, withSelection) {
var newStart = null;
var newEnd = null;
if (withSelection) {
if (startPos === endPos) {
newStart = startPos;
newEnd = newPosition;
}
else if (!hasInverseSelection) {
newStart = startPos;
newEnd = newPosition;
}
else {
newStart = endPos;
newEnd = newPosition;
}
}
else
newEnd = newStart = newPosition;
textSelection$2.select(element, newStart, newEnd);
}
function setElementValue(element, value, position) {
if (domUtils$8.isInputElement(element) && element.type === 'number') {
if (value.charAt(0) === '-' && value.charAt(1) === '.')
value = value.substring(1);
if (value.charAt(value.length - 1) === '.')
value = value.substring(0, value.length - 1);
}
domUtils$8.setElementValue(element, value);
textSelection$2.select(element, position, position);
eventSimulator$b.input(element);
}
function submitFormOnEnterPressInInput(form, inputElement) {
var buttons = form.querySelectorAll('input, button');
var submitButton = null;
var i = null;
for (i = 0; i < buttons.length; i++) {
if (!submitButton && buttons[i].type === 'submit' && !buttons[i].disabled) {
submitButton = buttons[i];
break;
}
}
if (submitButton)
eventSimulator$b.click(submitButton);
else if (domUtils$8.blocksImplicitSubmission(inputElement)) {
var formInputs = form.getElementsByTagName('input');
var textInputs = [];
for (i = 0; i < formInputs.length; i++) {
if (domUtils$8.blocksImplicitSubmission(formInputs[i]))
textInputs.push(formInputs[i]);
}
// NOTE: the form is submitted on enter press if there is only one input of the following types on it
// and this input is focused (http://www.w3.org/TR/html5/forms.html#implicit-submission)
if (textInputs.length === 1 && textInputs[0] === inputElement) {
var isInputValid = inputElement.validity.valid;
if (isInputValid && eventSimulator$b.submit(form))
form.submit();
}
}
}
//shortcuts
function selectAll(element) {
if (domUtils$8.isEditableElement(element))
textSelection$2.select(element);
return Promise$9.resolve();
}
function backspace(element) {
if (domUtils$8.isTextEditableElementAndEditingAllowed(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var value = domUtils$8.getElementValue(element).replace(/\r\n/g, '\n');
if (endPos === startPos) {
if (startPos > 0) {
setElementValue(element, value.substring(0, startPos - 1) +
value.substring(endPos, value.length), startPos - 1);
}
}
else
setElementValue(element, value.substring(0, startPos) + value.substring(endPos, value.length), startPos);
}
if (domUtils$8.isContentEditableElement(element))
textSelection$2.deleteSelectionContents(element);
return Promise$9.resolve();
}
function del(element) {
if (domUtils$8.isTextEditableElementAndEditingAllowed(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var value = domUtils$8.getElementValue(element).replace(/\r\n/g, '\n');
if (endPos === startPos) {
if (startPos < value.length) {
setElementValue(element, value.substring(0, startPos) +
value.substring(endPos + 1, value.length), startPos);
}
}
else {
setElementValue(element, value.substring(0, startPos) +
value.substring(endPos, value.length), startPos);
}
}
if (domUtils$8.isContentEditableElement(element))
textSelection$2.deleteSelectionContents(element);
return Promise$9.resolve();
}
function left(element) {
var startPosition = null;
var endPosition = null;
if (domUtils$8.isSelectElement(element))
selectElement.switchOptionsByKeys(element, 'left');
if (isRadioButtonNavigationRequired(element))
return focusAndCheckNextRadioButton(element, true);
if (domUtils$8.isTextEditableElement(element)) {
startPosition = textSelection$2.getSelectionStart(element) || 0;
endPosition = textSelection$2.getSelectionEnd(element);
var newPosition = startPosition === endPosition ? startPosition - 1 : startPosition;
textSelection$2.select(element, newPosition, newPosition);
updateTextAreaIndent(element);
}
if (domUtils$8.isContentEditableElement(element)) {
startPosition = textSelection$2.getSelectionStart(element);
endPosition = textSelection$2.getSelectionEnd(element);
// NOTE: we only remove selection
if (startPosition !== endPosition) {
var selection = textSelection$2.getSelectionByElement(element);
var inverseSelection = textSelection$2.hasInverseSelectionContentEditable(element);
var startNode = inverseSelection ? selection.focusNode : selection.anchorNode;
var startOffset = inverseSelection ? selection.focusOffset : selection.anchorOffset;
var startPos = { node: startNode, offset: startOffset };
textSelection$2.selectByNodesAndOffsets(startPos, startPos, true);
}
}
return Promise$9.resolve();
}
function right(element) {
var startPosition = null;
var endPosition = null;
if (domUtils$8.isSelectElement(element))
selectElement.switchOptionsByKeys(element, 'right');
if (isRadioButtonNavigationRequired(element))
return focusAndCheckNextRadioButton(element, false);
if (domUtils$8.isTextEditableElement(element)) {
startPosition = textSelection$2.getSelectionStart(element);
endPosition = textSelection$2.getSelectionEnd(element);
var newPosition = startPosition === endPosition ? endPosition + 1 : endPosition;
if (startPosition === domUtils$8.getElementValue(element).length)
newPosition = startPosition;
textSelection$2.select(element, newPosition, newPosition);
updateTextAreaIndent(element);
}
if (domUtils$8.isContentEditableElement(element)) {
startPosition = textSelection$2.getSelectionStart(element);
endPosition = textSelection$2.getSelectionEnd(element);
//NOTE: we only remove selection
if (startPosition !== endPosition) {
var selection = textSelection$2.getSelectionByElement(element);
var inverseSelection = textSelection$2.hasInverseSelectionContentEditable(element);
var endNode = inverseSelection ? selection.anchorNode : selection.focusNode;
var endOffset = inverseSelection ? selection.anchorOffset : selection.focusOffset;
var startPos = { node: endNode, offset: endOffset };
textSelection$2.selectByNodesAndOffsets(startPos, startPos, true);
}
}
return Promise$9.resolve();
}
function up(element) {
if (domUtils$8.isSelectElement(element))
selectElement.switchOptionsByKeys(element, 'up');
if (isRadioButtonNavigationRequired(element))
return focusAndCheckNextRadioButton(element, true);
if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
return home(element);
if (domUtils$8.isTextAreaElement(element))
moveTextAreaCursorUp(element, false);
return Promise$9.resolve();
}
function down(element) {
if (domUtils$8.isSelectElement(element))
selectElement.switchOptionsByKeys(element, 'down');
if (isRadioButtonNavigationRequired(element))
return focusAndCheckNextRadioButton(element, false);
if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
return end(element);
if (domUtils$8.isTextAreaElement(element))
moveTextAreaCursorDown(element, false);
return Promise$9.resolve();
}
function home(element, withSelection) {
if (domUtils$8.isTextEditableElement(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var inverseSelection = textSelection$2.hasInverseSelection(element);
var referencePosition = null;
var isSingleLineSelection = !domUtils$8.isTextAreaElement(element) ? true :
domUtils$8.getTextareaLineNumberByPosition(element, startPos) ===
domUtils$8.getTextareaLineNumberByPosition(element, endPos);
if (isSingleLineSelection)
referencePosition = inverseSelection ? endPos : startPos;
else
referencePosition = inverseSelection ? startPos : endPos;
var valueBeforeCursor = domUtils$8.getElementValue(element).substring(0, referencePosition);
var lastLineBreakIndex = valueBeforeCursor.lastIndexOf('\n');
var newPosition = lastLineBreakIndex === -1 ? 0 : lastLineBreakIndex + 1;
var newStartPos = null;
var newEndPos = null;
if (isSingleLineSelection) {
newStartPos = newPosition;
newEndPos = withSelection ? referencePosition : newPosition;
textSelection$2.select(element, newEndPos, newStartPos);
}
else if (!inverseSelection)
textSelection$2.select(element, startPos, newPosition);
else
textSelection$2.select(element, endPos, newPosition);
}
return Promise$9.resolve();
}
function end(element, withSelection) {
if (domUtils$8.isTextEditableElement(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var inverseSelection = textSelection$2.hasInverseSelection(element);
var referencePosition = null;
var isSingleLineSelection = !domUtils$8.isTextAreaElement(element) ? true :
domUtils$8.getTextareaLineNumberByPosition(element, startPos) ===
domUtils$8.getTextareaLineNumberByPosition(element, endPos);
if (isSingleLineSelection)
referencePosition = inverseSelection ? endPos : startPos;
else
referencePosition = inverseSelection ? startPos : endPos;
var valueAsterCursor = domUtils$8.getElementValue(element).substring(referencePosition);
var firstLineBreakIndex = valueAsterCursor.indexOf('\n');
var newPosition = referencePosition;
var newStartPos = null;
var newEndPos = null;
newPosition += firstLineBreakIndex === -1 ? valueAsterCursor.length : firstLineBreakIndex;
if (isSingleLineSelection) {
newStartPos = withSelection ? referencePosition : newPosition;
newEndPos = newPosition;
textSelection$2.select(element, newStartPos, newEndPos);
}
else if (!inverseSelection)
textSelection$2.select(element, startPos, newPosition);
else
textSelection$2.select(element, endPos, newPosition);
}
return Promise$9.resolve();
}
function esc(element) {
if (domUtils$8.isSelectElement(element))
selectElement.collapseOptionList();
return Promise$9.resolve();
}
function shiftUp(element) {
if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
return shiftHome(element);
if (domUtils$8.isTextAreaElement(element))
moveTextAreaCursorUp(element, true);
return Promise$9.resolve();
}
function shiftDown(element) {
if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
return shiftEnd(element);
if (domUtils$8.isTextAreaElement(element))
moveTextAreaCursorDown(element, true);
return Promise$9.resolve();
}
function shiftLeft(element) {
if (domUtils$8.isTextEditableElement(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
if (startPos === endPos || textSelection$2.hasInverseSelection(element))
textSelection$2.select(element, endPos, Math.max(startPos - 1, 0));
else
textSelection$2.select(element, startPos, Math.max(endPos - 1, 0));
updateTextAreaIndent(element);
}
return Promise$9.resolve();
}
function shiftRight(element) {
if (domUtils$8.isTextEditableElement(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var endPos = textSelection$2.getSelectionEnd(element);
var valueLength = domUtils$8.getElementValue(element).length;
if (startPos === endPos || !textSelection$2.hasInverseSelection(element))
textSelection$2.select(element, startPos, Math.min(endPos + 1, valueLength));
else
textSelection$2.select(element, endPos, Math.min(startPos + 1, valueLength));
updateTextAreaIndent(element);
}
return Promise$9.resolve();
}
function shiftHome(element) {
return home(element, true);
}
function shiftEnd(element) {
return end(element, true);
}
function enter(element) {
if (domUtils$8.isSelectElement(element))
selectElement.collapseOptionList();
//submit form on enter pressed
if (domUtils$8.isInputElement(element)) {
if (!browserUtils$b.isIE)
elementEditingWatcher.processElementChanging(element);
var form = domUtils$8.getParents(element, 'form')[0];
// NOTE: if a user presses enter when a form input is focused and the form has
// a submit button, the browser sends the click event to the submit button
if (form)
submitFormOnEnterPressInInput(form, element);
}
else if (domUtils$8.isTextAreaElement(element)) {
var startPos = textSelection$2.getSelectionStart(element);
var value = domUtils$8.getTextAreaValue(element);
var valueBeforeCursor = value.substring(0, startPos);
var valueAfterCursor = value.substring(startPos);
var newPosition = startPos + 1;
setElementValue(element, valueBeforeCursor + String.fromCharCode(10) + valueAfterCursor, newPosition);
}
//S173120
else if (element.tagName && domUtils$8.isAnchorElement(element))
eventSimulator$b.click(element);
return Promise$9.resolve();
}
function isRadioButtonNavigationRequired(element) {
return domUtils$8.isRadioButtonElement(element);
}
function focusAndCheckNextRadioButton(element, reverse) {
return focusNextElementOnNavigationButton(element, reverse, false)
.then(function (focusedElement) {
if (focusedElement)
focusedElement.checked = true;
});
}
function focusNextElementOnNavigationButton(element, reverse, skipRadioGroups) {
if (skipRadioGroups === void 0) { skipRadioGroups = true; }
if (!element)
return Promise$9.resolve();
if (domUtils$8.isSelectElement(element))
selectElement.collapseOptionList();
return focusNextElement(element, reverse, skipRadioGroups)
.then(function (nextElement) {
if (nextElement && domUtils$8.isTextEditableInput(nextElement))
textSelection$2.select(nextElement);
return nextElement;
});
}
var supportedShortcutHandlers = (_a = {},
_a[SHORTCUT_TYPE.ctrlA] = selectAll,
_a[SHORTCUT_TYPE.backspace] = backspace,
_a[SHORTCUT_TYPE.delete] = del,
_a[SHORTCUT_TYPE.left] = left,
_a[SHORTCUT_TYPE.right] = right,
_a[SHORTCUT_TYPE.up] = up,
_a[SHORTCUT_TYPE.down] = down,
_a[SHORTCUT_TYPE.shiftLeft] = shiftLeft,
_a[SHORTCUT_TYPE.shiftRight] = shiftRight,
_a[SHORTCUT_TYPE.shiftUp] = shiftUp,
_a[SHORTCUT_TYPE.shiftDown] = shiftDown,
_a[SHORTCUT_TYPE.shiftHome] = shiftHome,
_a[SHORTCUT_TYPE.shiftEnd] = shiftEnd,
_a[SHORTCUT_TYPE.home] = home,
_a[SHORTCUT_TYPE.end] = end,
_a[SHORTCUT_TYPE.enter] = enter,
_a[SHORTCUT_TYPE.tab] = function (element) { return focusNextElementOnNavigationButton(element, false); },
_a[SHORTCUT_TYPE.shiftTab] = function (element) { return focusNextElementOnNavigationButton(element, true); },
_a[SHORTCUT_TYPE.esc] = esc,
_a);
var Promise$a = hammerhead__default.Promise;
var browserUtils$c = hammerhead__default.utils.browser;
var messageSandbox$3 = hammerhead__default.eventSandbox.message;
var nativeMethods$d = hammerhead__default.nativeMethods;
var PRESS_REQUEST_CMD = 'automation|press|request';
var PRESS_RESPONSE_CMD = 'automation|press|response';
// Setup cross-iframe interaction
messageSandbox$3.on(messageSandbox$3.SERVICE_MSG_RECEIVED_EVENT, function (e) {
if (e.message.cmd === PRESS_REQUEST_CMD) {
hammerhead__default.on(hammerhead__default.EVENTS.beforeUnload, function () { return messageSandbox$3.sendServiceMsg({ cmd: PRESS_RESPONSE_CMD }, e.source); });
var pressAutomation = new PressAutomation(e.message.keyCombinations, e.message.options);
pressAutomation
.run()
.then(function () { return messageSandbox$3.sendServiceMsg({ cmd: PRESS_RESPONSE_CMD }, e.source); });
}
});
var PressAutomation = /** @class */ (function () {
function PressAutomation(keyCombinations, options) {
this.keyCombinations = keyCombinations;
this.isSelectElement = false;
this.pressedKeyString = '';
this.modifiersState = null;
this.shortcutHandlers = null;
this.topSameDomainDocument = testCafeCore.domUtils.getTopSameDomainWindow(window).document;
this.automationSettings = new AutomationSettings(options.speed);
this.options = options;
}
PressAutomation._getKeyPressSimulators = function (keyCombination) {
var keysArray = testCafeCore.getKeyArray(keyCombination);
// NOTE: symbols may have the same keyCode, but their "event.key" will be different, so we
// need to get the "event.key" property for each key, and add the 'shift' key where needed.
var _a = getActualKeysAndEventKeyProperties(keysArray), actualKeys = _a.actualKeys, eventKeyProperties = _a.eventKeyProperties;
return testCafeCore.arrayUtils.map(actualKeys, function (key, index) { return new KeyPressSimulator(key, eventKeyProperties[index]); });
};
PressAutomation._getShortcuts = function (keyCombination) {
var keys = testCafeCore.getKeyArray(keyCombination.toLowerCase());
var shortcuts = [];
var curFullCombination = [];
var curCombination = [];
for (var i = 0; i < keys.length; i++) {
curFullCombination.push(keys[i]);
curCombination = curFullCombination.slice();
while (curCombination.length) {
var keyString = curCombination.join('+');
if (supportedShortcutHandlers[keyString]) {
shortcuts.push(keyString);
curFullCombination = curCombination = [];
}
else
curCombination.shift();
}
}
return shortcuts;
};
PressAutomation._getShortcutHandlers = function (keyCombination) {
var shortcuts = PressAutomation._getShortcuts(keyCombination.toLowerCase());
var shortcutHandlers = {};
var stringWithShortcut = '';
var shortcut = null;
var shortcutPosition = null;
var shortcutLength = null;
for (var i = 0; i < shortcuts.length; i++) {
shortcut = shortcuts[i];
shortcutPosition = keyCombination.indexOf(shortcut);
shortcutLength = shortcut.length;
stringWithShortcut += keyCombination.substring(0, shortcutPosition + shortcutLength);
shortcutHandlers[stringWithShortcut] = supportedShortcutHandlers[shortcut];
keyCombination = keyCombination.substring(shortcutPosition + shortcutLength);
}
return shortcutHandlers;
};
PressAutomation.prototype._down = function (keyPressSimulator) {
this.pressedKeyString += (this.pressedKeyString ? '+' : '') + keyPressSimulator.key;
var keyDownPrevented = !keyPressSimulator.down(this.modifiersState);
return Promise$a.resolve(keyDownPrevented);
};
PressAutomation.prototype._press = function (keyPressSimulator, keyEventPrevented) {
var _this = this;
// NOTE: preventing the 'keydown' and 'keypress' events for the select element does not
// affect the assignment of the new selectedIndex. So, we should execute a shortcut
// for the select element without taking into account that 'key' events are suppressed
if (keyEventPrevented && !this.isSelectElement)
return testCafeCore.delay(this.automationSettings.keyActionStepDelay);
var currentShortcutHandler = this.shortcutHandlers[this.pressedKeyString];
var keyPressPrevented = false;
// NOTE: B254435
if (!currentShortcutHandler || browserUtils$c.isFirefox || keyPressSimulator.key === 'enter')
keyPressPrevented = !keyPressSimulator.press(this.modifiersState);
if ((!keyPressPrevented || this.isSelectElement) && currentShortcutHandler) {
return currentShortcutHandler(getDeepActiveElement(this.topSameDomainDocument))
.then(function () { return testCafeCore.delay(_this.automationSettings.keyActionStepDelay); });
}
return testCafeCore.delay(this.automationSettings.keyActionStepDelay);
};
PressAutomation.prototype._up = function (keyPressSimulator) {
keyPressSimulator.up(this.modifiersState);
return testCafeCore.delay(this.automationSettings.keyActionStepDelay);
};
PressAutomation.prototype._runCombination = function (keyCombination) {
var _this = this;
this.modifiersState = { ctrl: false, alt: false, shift: false, meta: false };
this.isSelectElement = testCafeCore.domUtils.isSelectElement(getDeepActiveElement(this.topSameDomainDocument));
this.pressedKeyString = '';
this.shortcutHandlers = PressAutomation._getShortcutHandlers(keyCombination);
var keyPressSimulators = PressAutomation._getKeyPressSimulators(keyCombination);
return testCafeCore.promiseUtils.each(keyPressSimulators, function (keySimulator) {
return _this
._down(keySimulator)
.then(function (keyEventPrevented) { return _this._press(keySimulator, keyEventPrevented); });
})
.then(function () {
testCafeCore.arrayUtils.reverse(keyPressSimulators);
return testCafeCore.promiseUtils.each(keyPressSimulators, function (keySimulator) { return _this._up(keySimulator); });
});
};
PressAutomation.prototype.run = function () {
var _this = this;
var activeElement = testCafeCore.domUtils.getActiveElement();
var activeElementIsIframe = testCafeCore.domUtils.isIframeElement(activeElement);
if (!isIframeWindow(window) && activeElementIsIframe && nativeMethods$d.contentWindowGetter.call(activeElement)) {
var msg = {
cmd: PRESS_REQUEST_CMD,
keyCombinations: this.keyCombinations,
options: this.options,
};
return testCafeCore.sendRequestToFrame(msg, PRESS_RESPONSE_CMD, nativeMethods$d.contentWindowGetter.call(activeElement));
}
return testCafeCore.promiseUtils.each(this.keyCombinations, function (combination) {
return _this
._runCombination(combination)
.then(function () { return testCafeCore.delay(_this.automationSettings.keyActionStepDelay); });
});
};
return PressAutomation;
}());
var Promise$b = hammerhead__default.Promise;
var extend$3 = hammerhead__default.utils.extend;
var browserUtils$d = hammerhead__default.utils.browser;
var eventSimulator$c = hammerhead__default.eventSandbox.eventSimulator;
var domUtils$9 = testCafeCore__default.domUtils, eventUtils$5 = testCafeCore__default.eventUtils, delay$3 = testCafeCore__default.delay;
var RClickAutomation = /** @class */ (function (_super) {
__extends(RClickAutomation, _super);
function RClickAutomation(element, clickOptions) {
var _this = _super.call(this, element, clickOptions, window, cursor) || this;
_this.modifiers = clickOptions.modifiers;
_this.caretPos = clickOptions.caretPos;
_this.eventState = {
simulateDefaultBehavior: true,
activeElementBeforeMouseDown: null,
};
return _this;
}
RClickAutomation.prototype._mousedown = function (eventArgs) {
var _this = this;
return cursor
.rightButtonDown()
.then(function () {
_this.eventState.activeElementBeforeMouseDown = domUtils$9.getActiveElement();
_this.eventState.simulateDefaultBehavior = eventSimulator$c.mousedown(eventArgs.element, eventArgs.options);
return _this._focus(eventArgs);
});
};
RClickAutomation.prototype._focus = function (eventArgs) {
if (this.simulateDefaultBehavior === false)
return nextTick();
// NOTE: If a target element is a contentEditable element, we need to call focusAndSetSelection directly for
// this element. Otherwise, if the element obtained by elementFromPoint is a child of the contentEditable
// element, a selection position may be calculated incorrectly (by using the caretPos option).
var elementForFocus = domUtils$9.isContentEditableElement(this.element) ? this.element : eventArgs.element;
// NOTE: IE doesn't perform focus if active element has been changed while executing mousedown
var simulateFocus = !browserUtils$d.isIE || this.eventState.activeElementBeforeMouseDown === domUtils$9.getActiveElement();
return focusAndSetSelection(elementForFocus, simulateFocus, this.caretPos)
.then(function () { return nextTick(); });
};
RClickAutomation.prototype._mouseup = function (eventArgs) {
var _this = this;
return cursor
.buttonUp()
.then(function () { return _this._getElementForEvent(eventArgs); })
.then(function (element) { return eventSimulator$c.mouseup(element, eventArgs.options); });
};
RClickAutomation.prototype._contextmenu = function (eventArgs) {
return this
._getElementForEvent(eventArgs)
.then(function (element) {
eventSimulator$c.contextmenu(element, eventArgs.options);
if (!domUtils$9.isElementFocusable(element))
focusByRelatedElement(element);
});
};
RClickAutomation.prototype.run = function (useStrictElementCheck) {
var _this = this;
var eventArgs = null;
return this
._ensureElement(useStrictElementCheck)
.then(function (_a) {
var element = _a.element, clientPoint = _a.clientPoint, devicePoint = _a.devicePoint;
eventArgs = {
point: clientPoint,
element: element,
options: extend$3({
clientX: clientPoint.x,
clientY: clientPoint.y,
screenX: devicePoint.x,
screenY: devicePoint.y,
button: eventUtils$5.BUTTON.right,
}, _this.modifiers),
};
// NOTE: we should raise mouseup event with 'mouseActionStepDelay' after we trigger
// mousedown event regardless of how long mousedown event handlers were executing
return Promise$b.all([delay$3(_this.automationSettings.mouseActionStepDelay), _this._mousedown(eventArgs)]);
})
.then(function () { return _this._mouseup(eventArgs); })
.then(function () { return _this._contextmenu(eventArgs); });
};
return RClickAutomation;
}(VisibleElementAutomation));
var browserUtils$e = hammerhead__default.utils.browser;
var domUtils$a = testCafeCore__default.domUtils;
var positionUtils$4 = testCafeCore__default.positionUtils;
var styleUtils$6 = testCafeCore__default.styleUtils;
var contentEditable$2 = testCafeCore__default.contentEditable;
var arrayUtils$1 = testCafeCore__default.arrayUtils;
var MODIFIERS_LIST = ['direction', 'font-family', 'font-size', 'font-size-adjust', 'font-variant', 'font-weight', 'font-style', 'letter-spacing', 'line-height', 'text-align', 'text-indent', 'text-transform', 'word-wrap', 'word-spacing', 'padding-top', 'padding-left', 'padding-right', 'padding-bottom', 'margin-top', 'margin-left', 'margin-right', 'margin-bottom', 'border-top-width', 'border-left-width', 'border-right-width', 'border-bottom-width'];
function ensureRectangleInsideElement(element, rect) {
var elementBorders = styleUtils$6.getBordersWidth(element);
var elementOffset = positionUtils$4.getOffsetPosition(element);
// NOTE: strange behavior in Chrome - for some elements (e.g., for the 'font' element)
// scrollHeight is 0, so we use getBoundingClientRect
var elementHeight = element.scrollHeight || element.getBoundingClientRect().height;
var left = Math.ceil(rect.left);
var top = Math.ceil(rect.top);
var bottom = Math.floor(rect.bottom);
if (!domUtils$a.isTextAreaElement(element)) {
var clientOffset = positionUtils$4.offsetToClientCoords({
x: elementOffset.left,
y: elementOffset.top,
});
var minLeft = clientOffset.x + elementBorders.left + 1;
var minTop = clientOffset.y + elementBorders.top + 1;
var bottomBound = clientOffset.y + elementBorders.top + elementBorders.bottom + elementHeight;
var maxBottom = clientOffset.y + elementBorders.top + elementHeight - 1;
left = Math.ceil(left <= clientOffset.x ? minLeft : rect.left);
top = Math.ceil(top <= clientOffset.y ? minTop : rect.top);
bottom = Math.floor(bottom >= bottomBound ? maxBottom : rect.bottom);
}
return {
left: left,
top: top,
bottom: bottom,
};
}
function getAbsoluteRect(rect) {
var documentScroll = styleUtils$6.getElementScroll(document);
return {
left: rect.left + documentScroll.left,
top: rect.top + documentScroll.top,
bottom: rect.bottom + documentScroll.top,
};
}
function getSelectionRectangleInContentEditableElement(element, position) {
var range = domUtils$a.findDocument(element).createRange();
var selectionPosition = contentEditable$2.calculateNodeAndOffsetByPosition(element, position);
range.setStart(selectionPosition.node, Math.min(selectionPosition.offset, selectionPosition.node.length));
range.setEnd(selectionPosition.node, Math.min(selectionPosition.offset, selectionPosition.node.length));
return range.getClientRects()[0];
}
function getTextSelectionRectangle(element, position) {
var range = element.createTextRange();
range.collapse(true);
range.moveStart('character', position);
range.moveEnd('character', position);
range.collapse(true);
return range.getBoundingClientRect();
}
function getSelectionRectangle(element, position) {
var clientRectBeforeFakeDiv = element.getBoundingClientRect();
var fakeDiv = createFakeDiv(element);
var rect = null;
var clientRectAfterFakeDiv = element.getBoundingClientRect();
var topBoundDiff = clientRectAfterFakeDiv.top - clientRectBeforeFakeDiv.top;
var leftBoundDiff = clientRectAfterFakeDiv.left - clientRectBeforeFakeDiv.left;
var valueLength = domUtils$a.getElementValue(element).length;
try {
var range = document.createRange(); //B254723
range.setStart(hammerhead__default.nativeMethods.nodeFirstChildGetter.call(fakeDiv), Math.min(position, valueLength));
// NOTE: The range.getClientRects function returns wrong result if range length is 0 in Safari 11
range.setEnd(hammerhead__default.nativeMethods.nodeFirstChildGetter.call(fakeDiv), Math.min(position + 1, valueLength + 1));
if (domUtils$a.isTextAreaElement(element)) {
rect = range.getBoundingClientRect();
if (rect.width === 0 && rect.height === 0)
rect = range.getClientRects()[0];
}
else
rect = range.getClientRects()[0];
}
catch (err) {
rect = null;
}
domUtils$a.remove(fakeDiv);
if (!rect)
return null;
return {
width: rect.width,
height: rect.height,
top: rect.top - topBoundDiff,
bottom: rect.bottom - topBoundDiff,
left: rect.left - leftBoundDiff,
right: rect.right - leftBoundDiff,
};
}
function createFakeDiv(element) {
var body = document.body;
var elementOffset = positionUtils$4.getOffsetPosition(element);
var elementMargin = styleUtils$6.getElementMargin(element);
var elementTop = elementOffset.top - elementMargin.top;
var elementLeft = elementOffset.left - elementMargin.left;
var fakeDiv = document.createElement('div');
var fakeDivCssStyles = 'white-space:pre-wrap;border-style:solid;';
if (styleUtils$6.get(body, 'position') === 'absolute') {
var bodyMargin = styleUtils$6.getElementMargin(body);
var bodyLeft = styleUtils$6.get(body, 'left');
var bodyTop = styleUtils$6.get(body, 'top');
elementLeft -= bodyMargin.left + (parseInt(bodyLeft.replace('px', ''), 10) || 0);
elementTop -= bodyMargin.top + (parseInt(bodyTop.replace('px', ''), 10) || 0);
}
arrayUtils$1.forEach(MODIFIERS_LIST, function (modifier) {
fakeDivCssStyles += "".concat(modifier, ":").concat(styleUtils$6.get(element, modifier), ";");
});
styleUtils$6.set(fakeDiv, {
cssText: fakeDivCssStyles,
position: 'absolute',
left: elementLeft + 'px',
top: elementTop + 'px',
width: element.scrollWidth + 'px',
height: element.scrollHeight + 'px',
});
hammerhead__default.nativeMethods.nodeTextContentSetter.call(fakeDiv, domUtils$a.getElementValue(element) + ' ');
body.appendChild(fakeDiv);
return fakeDiv;
}
function getPositionCoordinates(element, position) {
var rect = null;
if (domUtils$a.isContentEditableElement(element))
rect = getSelectionRectangleInContentEditableElement(element, position);
else if (typeof element.createTextRange === 'function')
rect = getTextSelectionRectangle(element, position);
else
rect = getSelectionRectangle(element, position);
if (!rect)
return null;
rect = ensureRectangleInsideElement(element, rect);
rect = getAbsoluteRect(rect);
return {
x: rect.left,
y: Math.floor(rect.top + (rect.bottom - rect.top) / 2),
};
}
function getSelectionCoordinatesByPosition(element, position) {
var isTextEditable = domUtils$a.isTextEditableElement(element);
var isContentEditable = domUtils$a.isContentEditableElement(element);
var hasText = isTextEditable && domUtils$a.getElementValue(element).length > 0 ||
isContentEditable && contentEditable$2.getContentEditableValue(element).length;
if (!hasText)
return positionUtils$4.findCenter(element);
return getPositionCoordinates(element, position);
}
function getSelectionCoordinatesByNodeAndOffset(element, node, offset) {
var range = domUtils$a.findDocument(element).createRange();
range.setStart(node, Math.min(offset, node.length));
range.setEnd(node, Math.min(offset, node.length));
var rect = range.getClientRects()[0];
if (!rect)
return null;
rect = ensureRectangleInsideElement(element, rect);
rect = getAbsoluteRect(rect);
return {
x: rect.left,
y: Math.floor(rect.top + (rect.bottom - rect.top) / 2),
};
}
function getLastVisibleSelectionPosition(element, startPos, endPos) {
var backward = startPos > endPos;
var inc = backward ? 1 : -1;
var currentPos = endPos;
var currentPoint = null;
while (currentPos !== startPos) {
currentPos += inc;
currentPoint = getPositionCoordinates(element, currentPos);
if (currentPoint)
break;
}
if (!currentPoint) {
currentPoint = getPositionCoordinates(element, startPos) ||
positionUtils$4.findCenter(element);
}
return currentPoint;
}
function scrollEditableElementByPoint(element, point) {
if (!domUtils$a.isEditableElement(element))
return;
var isTextarea = domUtils$a.isTextAreaElement(element);
var isInputElement = domUtils$a.isInputElement(element);
// NOTE: we don't need to scroll input elements in Mozilla and
// IE > 10 because it happens automatically on selection setting
if (isInputElement && (browserUtils$e.isFirefox || browserUtils$e.isIE && browserUtils$e.version > 10))
return;
var elementOffset = positionUtils$4.getOffsetPosition(element);
var elementBorders = styleUtils$6.getBordersWidth(element);
var elementScroll = styleUtils$6.getElementScroll(element);
var offsetX = point.x - elementOffset.left - elementBorders.left;
var offsetY = point.y - elementOffset.top - elementBorders.top;
var scrollValue = null;
if (isTextarea) {
if (offsetY < elementScroll.top)
scrollValue = offsetY;
if (offsetY > element.clientHeight + elementScroll.top)
scrollValue = offsetY - element.clientHeight;
if (scrollValue !== null)
styleUtils$6.setScrollTop(element, Math.round(scrollValue));
return;
}
if (offsetX < elementScroll.left)
scrollValue = offsetX;
if (offsetX > element.clientWidth + elementScroll.left)
scrollValue = offsetX - element.clientWidth;
if (scrollValue !== null)
styleUtils$6.setScrollLeft(element, Math.round(scrollValue));
}
function excludeElementScroll(element, point) {
var isTextEditable = domUtils$a.isTextEditableElement(element);
var isInputElement = domUtils$a.isInputElement(element);
if (!(isTextEditable || domUtils$a.isContentEditableElement(element)))
return point;
var elementOffset = positionUtils$4.getOffsetPosition(element);
var elementBorders = styleUtils$6.getBordersWidth(element);
var elementScroll = styleUtils$6.getElementScroll(element);
var maxLeft = elementOffset.left + elementBorders.left + element.clientWidth;
// NOTE: we can't know input elements' scroll value in Mozilla and
// IE > 10 (https://bugzilla.mozilla.org/show_bug.cgi?id=293186)
if (isInputElement && isTextEditable &&
(browserUtils$e.isFirefox || browserUtils$e.isIE && browserUtils$e.version > 10)) {
return {
x: Math.min(point.x, maxLeft),
y: point.y,
};
}
return {
x: point.x - elementScroll.left,
y: point.y - elementScroll.top,
};
}
var Promise$c = hammerhead__default.Promise;
var browserUtils$f = hammerhead__default.utils.browser;
var featureDetection$5 = hammerhead__default.utils.featureDetection;
var eventSimulator$d = hammerhead__default.eventSandbox.eventSimulator;
var focusBlurSandbox$4 = hammerhead__default.eventSandbox.focusBlur;
var contentEditable$3 = testCafeCore__default.contentEditable;
var domUtils$b = testCafeCore__default.domUtils;
var positionUtils$5 = testCafeCore__default.positionUtils;
var eventUtils$6 = testCafeCore__default.eventUtils;
var delay$4 = testCafeCore__default.delay;
var SelectBaseAutomation = /** @class */ (function (_super) {
__extends(SelectBaseAutomation, _super);
function SelectBaseAutomation(element, actionOptions) {
var _this = _super.call(this, element, actionOptions, window, cursor) || this;
_this.absoluteStartPoint = null;
_this.absoluteEndPoint = null;
_this.clientPoint = null;
_this.speed = actionOptions.speed;
_this.downEvent = featureDetection$5.isTouchDevice ? 'touchstart' : 'mousedown';
_this.upEvent = featureDetection$5.isTouchDevice ? 'touchend' : 'mouseup';
_this.eventArgs = {
options: null,
element: null,
};
_this.eventState = {
mousedownPrevented: false,
simulateDefaultBehavior: true,
};
return _this;
}
SelectBaseAutomation.prototype._calculateEventArguments = function () {
var _this = this;
var clientPoint = positionUtils$5.offsetToClientCoords(this.clientPoint);
return getElementFromPoint$2(clientPoint)
.then(function (element) {
if (!element) {
throw new ActionElementIsInvisibleError(null, {
reason: positionUtils$5.getElOutsideBoundsReason(_this.element),
});
}
return {
element: element,
options: {
clientX: clientPoint.x,
clientY: clientPoint.y,
},
};
});
};
SelectBaseAutomation.prototype._move = function (_a) {
var _this = this;
var element = _a.element, offsetX = _a.offsetX, offsetY = _a.offsetY, speed = _a.speed;
var moveOptions = new MoveOptions({ offsetX: offsetX, offsetY: offsetY, speed: speed }, false);
return MoveAutomation.create(element, moveOptions, window, cursor)
.then(function (moveAutomation) {
return moveAutomation.run();
})
.then(function () { return delay$4(_this.automationSettings.mouseActionStepDelay); });
};
SelectBaseAutomation.prototype._bindMousedownHandler = function () {
var _this = this;
var onmousedown = function (e) {
_this.eventState.mousedownPrevented = e.defaultPrevented;
eventUtils$6.preventDefault(e);
eventUtils$6.unbind(_this.element, 'mousedown', onmousedown);
};
eventUtils$6.bind(this.element, 'mousedown', onmousedown);
};
SelectBaseAutomation.prototype._calculateAbsoluteStartPoint = function () {
throw new Error('Not implemented');
};
SelectBaseAutomation.prototype._calculateAbsoluteEndPoint = function () {
throw new Error('Not implemented');
};
SelectBaseAutomation.prototype._moveToPoint = function (point) {
scrollEditableElementByPoint(this.element, point);
this.clientPoint = excludeElementScroll(this.element, point);
var moveArguments = {
element: document.documentElement,
offsetX: this.clientPoint.x,
offsetY: this.clientPoint.y,
speed: this.speed,
};
return this._move(moveArguments);
};
SelectBaseAutomation.prototype._mousedown = function () {
var _this = this;
return cursor
.leftButtonDown()
.then(function () { return _this._calculateEventArguments(); })
.then(function (args) {
_this.eventArgs = args;
// NOTE: In WebKit and IE, the mousedown event opens the select element's dropdown;
// therefore, we should prevent mousedown and hide the dropdown (B236416).
var needCloseSelectDropDown = (browserUtils$f.isWebKit || browserUtils$f.isIE) &&
domUtils$b.isSelectElement(_this.element);
if (needCloseSelectDropDown)
_this._bindMousedownHandler();
_this.eventState.simulateDefaultBehavior = eventSimulator$d[_this.downEvent](_this.eventArgs.element, _this.eventArgs.options);
if (_this.eventState.simulateDefaultBehavior === false)
_this.eventState.simulateDefaultBehavior = needCloseSelectDropDown && !_this.eventState.mousedownPrevented;
return _this._focus();
});
};
SelectBaseAutomation.prototype._focus = function () {
var _this = this;
return new Promise$c(function (resolve) {
// NOTE: If the target element is a child of a contentEditable element, we need to call focus for its parent
var elementForFocus = domUtils$b.isContentEditableElement(_this.element) ?
contentEditable$3.findContentEditableParent(_this.element) : _this.element;
focusBlurSandbox$4.focus(elementForFocus, resolve, false, true);
});
};
SelectBaseAutomation.prototype._setSelection = function () {
throw new Error('Not implemented');
};
SelectBaseAutomation.prototype._mouseup = function () {
var _this = this;
return cursor
.buttonUp()
.then(function () {
_this._setSelection();
return _this._calculateEventArguments();
})
.then(function (args) {
_this.eventArgs = args;
eventSimulator$d[_this.upEvent](_this.eventArgs.element, _this.eventArgs.options);
});
};
SelectBaseAutomation.prototype.run = function () {
var _this = this;
this.absoluteStartPoint = this._calculateAbsoluteStartPoint();
this.absoluteEndPoint = this._calculateAbsoluteEndPoint();
return this
._moveToPoint(this.absoluteStartPoint)
.then(function () { return _this._mousedown(); })
.then(function () { return _this._moveToPoint(_this.absoluteEndPoint); })
.then(function () { return _this._mouseup(); });
};
return SelectBaseAutomation;
}(VisibleElementAutomation));
var textSelection$3 = testCafeCore__default.textSelection;
var domUtils$c = testCafeCore__default.domUtils;
var positionUtils$6 = testCafeCore__default.positionUtils;
var SelectTextAutomation = /** @class */ (function (_super) {
__extends(SelectTextAutomation, _super);
function SelectTextAutomation(element, startPos, endPos, actionOptions) {
var _this = _super.call(this, element, actionOptions) || this;
_this.startPos = startPos;
_this.endPos = endPos;
return _this;
}
SelectTextAutomation.prototype._calculateAbsoluteStartPoint = function () {
var point = getSelectionCoordinatesByPosition(this.element, this.startPos);
return point || positionUtils$6.findCenter(this.element);
};
SelectTextAutomation.prototype._calculateAbsoluteEndPoint = function () {
var point = getSelectionCoordinatesByPosition(this.element, this.endPos);
if (point)
return point;
// NOTE: if selection ends on an invisible symbol, we should try to find the last visible selection position
if (domUtils$c.isContentEditableElement(this.element))
return getLastVisibleSelectionPosition(this.element, this.startPos, this.endPos);
return positionUtils$6.findCenter(this.element);
};
SelectTextAutomation.prototype._setSelection = function () {
var isTextEditable = domUtils$c.isTextEditableElement(this.element);
var isContentEditable = domUtils$c.isContentEditableElement(this.element);
if (!(isTextEditable || isContentEditable) || this.eventState.simulateDefaultBehavior === false)
return;
textSelection$3.select(this.element, this.startPos, this.endPos);
};
SelectTextAutomation.prototype.run = function (useStrictElementCheck) {
var _this = this;
return this
._ensureElement(useStrictElementCheck)
.then(function () { return _super.prototype.run.call(_this); });
};
return SelectTextAutomation;
}(SelectBaseAutomation));
var textSelection$4 = testCafeCore__default.textSelection;
var contentEditable$4 = testCafeCore__default.contentEditable;
var positionUtils$7 = testCafeCore__default.positionUtils;
var SelectEditableContentAutomation = /** @class */ (function (_super) {
__extends(SelectEditableContentAutomation, _super);
function SelectEditableContentAutomation(startNode, endNode, actionOptions) {
var _this = _super.call(this, contentEditable$4.getNearestCommonAncestor(startNode, endNode), actionOptions) || this;
var startOffset = contentEditable$4.getFirstVisiblePosition(startNode);
var endOffset = contentEditable$4.getLastVisiblePosition(endNode);
var startPos = { node: startNode, offset: startOffset };
var endPos = { node: endNode, offset: endOffset };
var startPosition = contentEditable$4.calculatePositionByNodeAndOffset(_this.element, startPos);
var endPosition = contentEditable$4.calculatePositionByNodeAndOffset(_this.element, endPos);
if (startPosition > endPosition) {
startOffset = contentEditable$4.getLastVisiblePosition(startNode);
endOffset = contentEditable$4.getFirstVisiblePosition(endNode);
}
// NOTE: We should recalculate nodes and offsets for selection because we
// may have to select children of expectedStartNode and expectedEndNode
startPos = contentEditable$4.calculateNodeAndOffsetByPosition(startNode, startOffset);
endPos = contentEditable$4.calculateNodeAndOffsetByPosition(endNode, endOffset);
_this.startNode = startPos.node;
_this.startOffset = startPos.offset;
_this.endNode = endPos.node;
_this.endOffset = endPos.offset;
return _this;
}
SelectEditableContentAutomation.prototype._calculateAbsoluteStartPoint = function () {
var point = getSelectionCoordinatesByNodeAndOffset(this.element, this.startNode, this.startOffset);
return point || positionUtils$7.findCenter(this.element);
};
SelectEditableContentAutomation.prototype._calculateAbsoluteEndPoint = function () {
var point = getSelectionCoordinatesByNodeAndOffset(this.element, this.endNode, this.endOffset);
return point || positionUtils$7.findCenter(this.element);
};
SelectEditableContentAutomation.prototype._setSelection = function () {
if (this.eventState.simulateDefaultBehavior === false)
return;
// NOTE: The same cursor position may correspond to different nodes, so, if we
// know which nodes should be selected eventually, we should select them directly.
var startPos = { node: this.startNode, offset: this.startOffset };
var endPos = { node: this.endNode, offset: this.endOffset };
textSelection$4.selectByNodesAndOffsets(startPos, endPos, true);
};
return SelectEditableContentAutomation;
}(SelectBaseAutomation));
var Promise$d = hammerhead__default.Promise;
var extend$4 = hammerhead__default.utils.extend;
var browserUtils$g = hammerhead__default.utils.browser;
var eventSimulator$e = hammerhead__default.eventSandbox.eventSimulator;
var elementEditingWatcher$1 = hammerhead__default.eventSandbox.elementEditingWatcher;
var domUtils$d = testCafeCore__default.domUtils;
var promiseUtils = testCafeCore__default.promiseUtils;
var contentEditable$5 = testCafeCore__default.contentEditable;
var textSelection$5 = testCafeCore__default.textSelection;
var delay$5 = testCafeCore__default.delay;
var SPECIAL_KEYS = testCafeCore__default.KEY_MAPS.specialKeys;
var TypeAutomation = /** @class */ (function () {
function TypeAutomation(element, text, typeOptions) {
this.element = TypeAutomation.findTextEditableChild(element) || element;
this.typingText = text.toString();
this.modifiers = typeOptions.modifiers;
this.caretPos = typeOptions.caretPos;
this.replace = typeOptions.replace;
this.paste = typeOptions.paste;
this.offsetX = typeOptions.offsetX;
this.offsetY = typeOptions.offsetY;
this.speed = typeOptions.speed;
this.automationSettings = new AutomationSettings(this.speed);
this.elementChanged = element !== this.element;
this.currentPos = 0;
this.currentKeyCode = null;
this.currentCharCode = null;
this.currentKey = null;
this.currentKeyIdentifier = null;
this.ignoreChangeEvent = true;
this.eventArgs = {
options: null,
element: null,
};
this.eventState = {
skipType: false,
simulateKeypress: true,
simulateTypeChar: true,
};
}
TypeAutomation.findTextEditableChild = function (element) {
var innerElement = null;
if (!domUtils$d.isEditableElement(element)) {
var allChildren = element.querySelectorAll('*');
for (var i = 0; i < allChildren.length; i++) {
if (domUtils$d.isTextEditableElementAndEditingAllowed(allChildren[i])) {
innerElement = allChildren[i];
break;
}
}
}
return innerElement;
};
TypeAutomation.prototype._calculateEventArguments = function (isPressEvent) {
var activeElement = domUtils$d.getActiveElement();
var isContentEditable = domUtils$d.isContentEditableElement(this.element);
var element = this.eventArgs.element || this.element;
// T162478: Wrong typing and keys pressing in editor
if (!isContentEditable && activeElement !== element)
element = TypeAutomation.findTextEditableChild(activeElement) || activeElement;
var options = extend$4({
keyCode: isPressEvent ? this.currentCharCode : this.currentKeyCode,
}, this.modifiers);
if (isPressEvent)
options.charCode = this.currentCharCode;
extend$4(options, getKeyProperties(isPressEvent, this.currentKey, this.currentKeyIdentifier));
return { element: element, options: options };
};
TypeAutomation.prototype._calculateTargetElement = function () {
var activeElement = domUtils$d.getActiveElement();
var isContentEditable = domUtils$d.isContentEditableElement(this.element);
if (isContentEditable) {
if (activeElement !== contentEditable$5.findContentEditableParent(this.element)) {
this.eventState.skipType = true;
return;
}
}
else if (activeElement !== this.element) {
this.eventState.skipType = true;
return;
}
this.element = isContentEditable ? this.element : activeElement;
};
TypeAutomation.prototype._click = function (useStrictElementCheck) {
var _this = this;
var activeElement = domUtils$d.getActiveElement();
var isTextEditable = domUtils$d.isTextEditableElementAndEditingAllowed(this.element);
var isContentEditable = domUtils$d.isContentEditableElement(this.element);
if (activeElement !== this.element) {
var _a = getDefaultAutomationOffsets(this.element), offsetX = _a.offsetX, offsetY = _a.offsetY;
var clickOptions = new ClickOptions({
offsetX: this.elementChanged ? offsetX : this.offsetX,
offsetY: this.elementChanged ? offsetY : this.offsetY,
speed: this.speed,
caretPos: this.caretPos,
modifiers: this.modifiers,
});
var clickAutomation = new ClickAutomation(this.element, clickOptions, window, cursor);
return clickAutomation
.run(useStrictElementCheck)
.then(function () { return delay$5(_this.automationSettings.mouseActionStepDelay); });
}
if (isTextEditable)
elementEditingWatcher$1.watchElementEditing(this.element);
var isEditableElement = isTextEditable || isContentEditable;
if (isEditableElement) {
var selectionStart = textSelection$5.getSelectionStart(this.element);
if (!isNaN(parseInt(this.caretPos, 10)) && this.caretPos !== selectionStart)
textSelection$5.select(this.element, this.caretPos, this.caretPos);
}
return Promise$d.resolve();
};
TypeAutomation.prototype._type = function () {
var _this = this;
if (this.eventState.skipType)
return Promise$d.resolve();
var isContentEditable = domUtils$d.isContentEditableElement(this.element);
if (this.replace) {
if (domUtils$d.isTextEditableElementAndEditingAllowed(this.element))
textSelection$5.select(this.element);
else if (isContentEditable)
textSelection$5.deleteSelectionContents(this.element, true);
}
return promiseUtils.whilst(function () { return !_this._isTypingFinished(); }, function () { return _this._typingStep(); });
};
TypeAutomation.prototype._isTypingFinished = function () {
return this.currentPos === this.typingText.length;
};
TypeAutomation.prototype._typingStep = function () {
var char = this.typingText.charAt(this.currentPos);
this.currentKeyCode = getKeyCode(char);
this.currentCharCode = this.typingText.charCodeAt(this.currentPos);
this.currentKey = this.currentKeyCode === SPECIAL_KEYS['enter'] ? 'Enter' : char;
this.currentKeyIdentifier = getKeyIdentifier(this.currentKey);
this.ignoreChangeEvent = domUtils$d.getElementValue(this.element) === elementEditingWatcher$1.getElementSavedValue(this.element);
this._keydown();
this._keypress();
return this._keyup();
};
TypeAutomation.prototype._keydown = function () {
this.eventArgs = this._calculateEventArguments();
this.eventState.simulateKeypress = eventSimulator$e.keydown(this.eventArgs.element, this.eventArgs.options);
};
TypeAutomation.prototype._keypress = function () {
if (this.eventState.simulateKeypress === false)
return;
this.eventArgs = this._calculateEventArguments(true);
this.eventState.simulateTypeChar = browserUtils$g.isAndroid || eventSimulator$e.keypress(this.eventArgs.element, this.eventArgs.options);
};
TypeAutomation.prototype._keyup = function () {
var _this = this;
var elementForTyping = this.eventArgs.element;
this.eventArgs = this._calculateEventArguments();
var isTextEditableElement = domUtils$d.isTextEditableElement(this.element);
var isContentEditable = domUtils$d.isContentEditableElement(this.element);
var shouldTypeAllText = this.paste || !isTextEditableElement && !isContentEditable;
return Promise$d
.resolve()
.then(function () {
return shouldTypeAllText ? _this._typeAllText(elementForTyping) : _this._typeChar(elementForTyping);
})
.then(function () {
eventSimulator$e.keyup(_this.eventArgs.element, _this.eventArgs.options);
if (shouldTypeAllText)
_this.currentPos = _this.typingText.length;
else
_this.currentPos++;
});
};
TypeAutomation.prototype._typeChar = function (element) {
// NOTE: change event must not be raised after prevented keydown
// or keypress even if element value was changed (B253816)
if (this.eventState.simulateKeypress === false || this.eventState.simulateTypeChar === false) {
// NOTE: change event should still be raised if element value
// was changed before the prevented keypress or keydown (GH-4881)
if (this.ignoreChangeEvent)
elementEditingWatcher$1.restartWatchingElementEditing(element);
return delay$5(this.automationSettings.keyActionStepDelay);
}
var currentChar = this.typingText.charAt(this.currentPos);
var isDigit = /^\d$/.test(currentChar);
var prevChar = this.currentPos === 0 ? null : this.typingText.charAt(this.currentPos - 1);
var isInputTypeNumber = domUtils$d.isInputElement(element) && element.type === 'number';
if (isInputTypeNumber) {
var selectionStart = textSelection$5.getSelectionStart(element);
var valueLength = domUtils$d.getInputValue(element).length;
var textHasDigits = /^\d/.test(this.typingText);
var isPermissibleSymbol = currentChar === '.' || currentChar === '-' && valueLength;
if (!isDigit && (textHasDigits || !isPermissibleSymbol || selectionStart !== 0))
return delay$5(this.automationSettings.keyActionStepDelay);
// NOTE: allow to type '.' or '-' only if it is the first symbol and the input already has
// a value, or if '.' or '-' are added to a digit. Otherwise, the value won't be set.
if (isDigit && (prevChar === '.' || prevChar === '-' && !valueLength))
currentChar = prevChar + currentChar;
}
typeText(element, currentChar, null);
return delay$5(this.automationSettings.keyActionStepDelay);
};
TypeAutomation.prototype._typeAllText = function (element) {
typeText(element, this.typingText, this.caretPos);
return delay$5(this.automationSettings.keyActionStepDelay);
};
TypeAutomation.prototype.run = function (useStrictElementCheck) {
var _this = this;
return this
._click(useStrictElementCheck)
.then(function () { return _this._calculateTargetElement(); })
.then(function () { return _this._type(); });
};
return TypeAutomation;
}());
var UploadAutomation = /** @class */ (function () {
function UploadAutomation(element, paths, createError) {
this.element = element;
this.paths = paths;
this.createError = createError;
}
UploadAutomation.prototype.run = function () {
var _this = this;
return hammerhead.doUpload(this.element, this.paths)
.then(function (errs) {
if (!errs.length)
return;
var filePaths = testCafeCore.arrayUtils.map(errs, function (err) { return err.path; });
var scannedFilePaths = testCafeCore.arrayUtils.reduce(errs, function (prev, current) {
return prev.concat(current.resolvedPaths);
}, []);
throw _this.createError(filePaths, scannedFilePaths);
});
};
return UploadAutomation;
}());
var domUtils$e = testCafeCore__default.domUtils;
var contentEditable$6 = testCafeCore__default.contentEditable;
function getSelectTextAreaContentArguments(element, argumentsObject) {
var value = domUtils$e.getTextAreaValue(element);
var linesArray = value && value.length ? value.split('\n') : [];
var lastLineIndex = linesArray.length - 1;
var startLineIndex = !argumentsObject.startLine ? 0 : Math.min(argumentsObject.startLine, lastLineIndex);
var startLineLength = linesArray[startLineIndex] ? linesArray[startLineIndex].length : 0;
var startPos = !argumentsObject.startPos ? 0 : Math.min(argumentsObject.startPos, startLineLength);
var endLineIndex = argumentsObject.endLine === void 0 || argumentsObject.endLine === null ?
lastLineIndex : Math.min(argumentsObject.endLine, lastLineIndex);
var endLineLength = linesArray[endLineIndex] ? linesArray[endLineIndex].length : 0;
var endPos = argumentsObject.endPos === void 0 ||
argumentsObject.endPos ===
null ? endLineLength : Math.min(argumentsObject.endPos, endLineLength);
var startLinePosition = domUtils$e.getTextareaPositionByLineAndOffset(element, startLineIndex, 0);
var endLinePosition = domUtils$e.getTextareaPositionByLineAndOffset(element, endLineIndex, 0);
return {
startPos: startLinePosition + startPos,
endPos: endLinePosition + endPos,
};
}
function calculateSelectTextArguments (element, argumentsObject) {
if (argumentsObject === void 0) { argumentsObject = {}; }
var isTextEditable = domUtils$e.isTextEditableElement(element);
var firstPos = isTextEditable ? 0 : contentEditable$6.getFirstVisiblePosition(element);
var lastPos = isTextEditable ? domUtils$e.getElementValue(element).length : contentEditable$6.getLastVisiblePosition(element);
var startPos = !argumentsObject.startPos ? firstPos : Math.min(argumentsObject.startPos, lastPos);
var endPos = argumentsObject.endPos === void 0 ||
argumentsObject.endPos === null ? lastPos : Math.min(argumentsObject.endPos, lastPos);
if (argumentsObject.offset !== void 0) {
if (argumentsObject.offset >= 0)
endPos = Math.min(argumentsObject.offset, endPos);
else {
startPos = endPos;
endPos = Math.max(0, endPos + argumentsObject.offset);
}
return { startPos: startPos, endPos: endPos };
}
if (argumentsObject.startLine !== void 0)
return getSelectTextAreaContentArguments(element, argumentsObject);
return { startPos: startPos, endPos: endPos };
}
var exports$1 = {};
exports$1.DispatchEvent = DispatchEventAutomation;
exports$1.SetScroll = SetScrollAutomation;
exports$1.ScrollIntoView = ScrollIntoViewAutomation;
exports$1.Click = ClickAutomation;
exports$1.SelectChildClick = SelectChildClickAutomation;
exports$1.DblClick = DblClickAutomation;
exports$1.DragToOffset = DragToOffsetAutomation;
exports$1.DragToElement = DragToElementAutomation;
exports$1.Hover = HoverAutomation;
exports$1.Press = PressAutomation;
exports$1.RClick = RClickAutomation;
exports$1.SelectText = SelectTextAutomation;
exports$1.SelectEditableContent = SelectEditableContentAutomation;
exports$1.Type = TypeAutomation;
exports$1.Upload = UploadAutomation;
exports$1.MouseOptions = MouseOptions;
exports$1.ClickOptions = ClickOptions;
exports$1.TypeOptions = TypeOptions;
exports$1.AutomationSettings = AutomationSettings;
exports$1.getOffsetOptions = getOffsetOptions;
exports$1.calculateSelectTextArguments = calculateSelectTextArguments;
exports$1.cursor = cursor;
exports$1.getNextFocusableElement = getNextFocusableElement;
exports$1.SHORTCUT_TYPE = SHORTCUT_TYPE;
exports$1.getSelectionCoordinatesByPosition = getSelectionCoordinatesByPosition;
exports$1.getElementFromPoint = getElementFromPoint$2;
// NOTE: for testing purposes
exports$1.MoveAutomation = MoveAutomation;
var nativeMethods$e = hammerhead__default.nativeMethods;
var evalIframeScript = hammerhead__default.EVENTS.evalIframeScript;
nativeMethods$e.objectDefineProperty(window, '%testCafeAutomation%', { configurable: true, value: exports$1 });
// eslint-disable-next-line no-undef
hammerhead__default.on(evalIframeScript, function (e) { return initTestCafeAutomation(nativeMethods$e.contentWindowGetter.call(e.iframe), true); });
}(window['%hammerhead%'], window['%hammerhead%'].Promise, window['%testCafeCore%'], window['%testCafeUI%']));
}
initTestCafeAutomation(window);
})();