selenium-webdriver 4.43.0 → 4.45.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGES +18 -0
- data/Gemfile +1 -4
- data/README.md +43 -23
- data/bin/linux/selenium-manager +0 -0
- data/bin/macos/selenium-manager +0 -0
- data/bin/windows/selenium-manager.exe +0 -0
- data/lib/selenium/webdriver/atoms/findElements.js +272 -68
- data/lib/selenium/webdriver/atoms/getAttribute.js +152 -17
- data/lib/selenium/webdriver/atoms/isDisplayed.js +385 -39
- data/lib/selenium/webdriver/chromium/options.rb +3 -1
- data/lib/selenium/webdriver/chromium/profile.rb +6 -0
- data/lib/selenium/webdriver/common/driver_finder.rb +32 -23
- data/lib/selenium/webdriver/common/local_driver.rb +4 -8
- data/lib/selenium/webdriver/common/service.rb +1 -11
- data/lib/selenium/webdriver/common/virtual_authenticator/credential.rb +1 -1
- data/lib/selenium/webdriver/firefox/service.rb +22 -12
- data/lib/selenium/webdriver/remote/http/curb.rb +6 -8
- data/lib/selenium/webdriver/safari/options.rb +8 -4
- data/lib/selenium/webdriver/safari.rb +1 -6
- data/lib/selenium/webdriver/support/guards/guard.rb +10 -11
- data/lib/selenium/webdriver/support/guards.rb +2 -1
- data/lib/selenium/webdriver/version.rb +1 -1
- data/selenium-webdriver.gemspec +1 -1
- metadata +4 -4
|
@@ -1,17 +1,152 @@
|
|
|
1
|
-
function()
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
1
|
+
(function (element, attribute) {
|
|
2
|
+
const PROPERTY_ALIASES = {
|
|
3
|
+
'class': 'className',
|
|
4
|
+
'readonly': 'readOnly',
|
|
5
|
+
};
|
|
6
|
+
const BOOLEAN_PROPERTIES = new Set([
|
|
7
|
+
'allowfullscreen',
|
|
8
|
+
'allowpaymentrequest',
|
|
9
|
+
'allowusermedia',
|
|
10
|
+
'async',
|
|
11
|
+
'autofocus',
|
|
12
|
+
'autoplay',
|
|
13
|
+
'checked',
|
|
14
|
+
'compact',
|
|
15
|
+
'complete',
|
|
16
|
+
'controls',
|
|
17
|
+
'declare',
|
|
18
|
+
'default',
|
|
19
|
+
'defaultchecked',
|
|
20
|
+
'defaultselected',
|
|
21
|
+
'defer',
|
|
22
|
+
'disabled',
|
|
23
|
+
'ended',
|
|
24
|
+
'formnovalidate',
|
|
25
|
+
'hidden',
|
|
26
|
+
'indeterminate',
|
|
27
|
+
'iscontenteditable',
|
|
28
|
+
'ismap',
|
|
29
|
+
'itemscope',
|
|
30
|
+
'loop',
|
|
31
|
+
'multiple',
|
|
32
|
+
'muted',
|
|
33
|
+
'nohref',
|
|
34
|
+
'nomodule',
|
|
35
|
+
'noresize',
|
|
36
|
+
'noshade',
|
|
37
|
+
'novalidate',
|
|
38
|
+
'nowrap',
|
|
39
|
+
'open',
|
|
40
|
+
'paused',
|
|
41
|
+
'playsinline',
|
|
42
|
+
'pubdate',
|
|
43
|
+
'readonly',
|
|
44
|
+
'required',
|
|
45
|
+
'reversed',
|
|
46
|
+
'scoped',
|
|
47
|
+
'seamless',
|
|
48
|
+
'seeking',
|
|
49
|
+
'selected',
|
|
50
|
+
'truespeed',
|
|
51
|
+
'typemustmatch',
|
|
52
|
+
'willvalidate',
|
|
53
|
+
]);
|
|
54
|
+
function getAttribute(element, attributeName) {
|
|
55
|
+
return element.getAttribute(attributeName.toLowerCase());
|
|
56
|
+
}
|
|
57
|
+
function getProperty(element, propertyName) {
|
|
58
|
+
return element[propertyName];
|
|
59
|
+
}
|
|
60
|
+
function isElement(node, tagName) {
|
|
61
|
+
const elem = node;
|
|
62
|
+
if (!elem || elem.nodeType !== 1) {
|
|
63
|
+
return false;
|
|
64
|
+
}
|
|
65
|
+
if (!tagName) {
|
|
66
|
+
return true;
|
|
67
|
+
}
|
|
68
|
+
const normalizedTag = tagName.toUpperCase();
|
|
69
|
+
if (node instanceof HTMLFormElement) {
|
|
70
|
+
return normalizedTag === 'FORM';
|
|
71
|
+
}
|
|
72
|
+
return typeof elem.tagName === 'string' && elem.tagName.toUpperCase() === normalizedTag;
|
|
73
|
+
}
|
|
74
|
+
function isSelectable(element) {
|
|
75
|
+
if (isElement(element, 'OPTION')) {
|
|
76
|
+
return true;
|
|
77
|
+
}
|
|
78
|
+
if (isElement(element, 'INPUT')) {
|
|
79
|
+
const type = element.type.toLowerCase();
|
|
80
|
+
return type === 'checkbox' || type === 'radio';
|
|
81
|
+
}
|
|
82
|
+
return false;
|
|
83
|
+
}
|
|
84
|
+
function isSelected(element) {
|
|
85
|
+
var _a;
|
|
86
|
+
if (isElement(element, 'OPTION')) {
|
|
87
|
+
return element.selected;
|
|
88
|
+
}
|
|
89
|
+
const type = (_a = element.type) === null || _a === void 0 ? void 0 : _a.toLowerCase();
|
|
90
|
+
if (type === 'checkbox' || type === 'radio') {
|
|
91
|
+
return element.checked;
|
|
92
|
+
}
|
|
93
|
+
return false;
|
|
94
|
+
}
|
|
95
|
+
function isObject(value) {
|
|
96
|
+
return value !== null && (typeof value === 'object' || typeof value === 'function');
|
|
97
|
+
}
|
|
98
|
+
const name = attribute.toLowerCase();
|
|
99
|
+
if (name === 'style') {
|
|
100
|
+
const style = element.style;
|
|
101
|
+
if (!style) {
|
|
102
|
+
return null;
|
|
103
|
+
}
|
|
104
|
+
return typeof style === 'string' ? style : style.cssText;
|
|
105
|
+
}
|
|
106
|
+
if ((name === 'selected' || name === 'checked') && isSelectable(element)) {
|
|
107
|
+
return isSelected(element) ? 'true' : null;
|
|
108
|
+
}
|
|
109
|
+
const isLink = isElement(element, 'A');
|
|
110
|
+
const isImg = isElement(element, 'IMG');
|
|
111
|
+
if ((isImg && name === 'src') || (isLink && name === 'href')) {
|
|
112
|
+
const attrValue = getAttribute(element, name);
|
|
113
|
+
if (attrValue) {
|
|
114
|
+
return String(getProperty(element, name));
|
|
115
|
+
}
|
|
116
|
+
return attrValue;
|
|
117
|
+
}
|
|
118
|
+
if (name === 'spellcheck') {
|
|
119
|
+
const attrValue = getAttribute(element, name);
|
|
120
|
+
if (attrValue !== null) {
|
|
121
|
+
const lower = attrValue.toLowerCase();
|
|
122
|
+
if (lower === 'false') {
|
|
123
|
+
return 'false';
|
|
124
|
+
}
|
|
125
|
+
if (lower === 'true') {
|
|
126
|
+
return 'true';
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
return String(getProperty(element, name));
|
|
130
|
+
}
|
|
131
|
+
const propName = PROPERTY_ALIASES[name] || attribute;
|
|
132
|
+
if (BOOLEAN_PROPERTIES.has(name)) {
|
|
133
|
+
const hasAttr = element.getAttribute(name) !== null;
|
|
134
|
+
const propValue = getProperty(element, propName);
|
|
135
|
+
return hasAttr || !!propValue ? 'true' : null;
|
|
136
|
+
}
|
|
137
|
+
if (name === 'value' && isElement(element, 'LI')) {
|
|
138
|
+
const attrValue = element.getAttribute(name);
|
|
139
|
+
return attrValue != null ? attrValue : null;
|
|
140
|
+
}
|
|
141
|
+
let property;
|
|
142
|
+
try {
|
|
143
|
+
property = getProperty(element, propName);
|
|
144
|
+
}
|
|
145
|
+
catch (_e) {
|
|
146
|
+
}
|
|
147
|
+
if (property == null || isObject(property)) {
|
|
148
|
+
const attrValue = element.getAttribute(name);
|
|
149
|
+
return attrValue != null ? attrValue : null;
|
|
150
|
+
}
|
|
151
|
+
return property != null ? String(property) : null;
|
|
152
|
+
})
|
|
@@ -1,39 +1,385 @@
|
|
|
1
|
-
function()
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
function
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
1
|
+
(function isShownElement(elem, optIgnoreOpacity) {
|
|
2
|
+
var tagNameDescriptor = Object.getOwnPropertyDescriptor(Element.prototype, 'tagName');
|
|
3
|
+
var computedStyleCache = new Map();
|
|
4
|
+
var clientRectCache = new Map();
|
|
5
|
+
var displayedCache = new Map();
|
|
6
|
+
function toUpperCaseTag(tagName) {
|
|
7
|
+
return tagName ? tagName.toUpperCase() : undefined;
|
|
8
|
+
}
|
|
9
|
+
function isElement(node, tagName) {
|
|
10
|
+
if (!node || node.nodeType !== 1) {
|
|
11
|
+
return false;
|
|
12
|
+
}
|
|
13
|
+
var asElement = node;
|
|
14
|
+
var rawTagName = tagNameDescriptor && typeof tagNameDescriptor.get === 'function'
|
|
15
|
+
? tagNameDescriptor.get.call(asElement)
|
|
16
|
+
: asElement.tagName;
|
|
17
|
+
var upperTagName = typeof rawTagName === 'string' ? rawTagName.toUpperCase() : '';
|
|
18
|
+
var normalizedTagName = toUpperCaseTag(tagName);
|
|
19
|
+
if (upperTagName === 'FORM') {
|
|
20
|
+
return !normalizedTagName || normalizedTagName === 'FORM';
|
|
21
|
+
}
|
|
22
|
+
return !!upperTagName && (!normalizedTagName || upperTagName === normalizedTagName);
|
|
23
|
+
}
|
|
24
|
+
function getParentElement(node) {
|
|
25
|
+
var current = node.parentNode;
|
|
26
|
+
while (current &&
|
|
27
|
+
current.nodeType !== Node.ELEMENT_NODE &&
|
|
28
|
+
current.nodeType !== Node.DOCUMENT_NODE &&
|
|
29
|
+
current.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {
|
|
30
|
+
current = current.parentNode;
|
|
31
|
+
}
|
|
32
|
+
return current && current.nodeType === 1 ? current : null;
|
|
33
|
+
}
|
|
34
|
+
function getEffectiveStyle(elem, propertyName) {
|
|
35
|
+
var computed = computedStyleCache.get(elem);
|
|
36
|
+
if (computed === undefined) {
|
|
37
|
+
var win = elem.ownerDocument.defaultView;
|
|
38
|
+
computed = win ? (win.getComputedStyle(elem) || null) : null;
|
|
39
|
+
computedStyleCache.set(elem, computed);
|
|
40
|
+
}
|
|
41
|
+
if (!computed) {
|
|
42
|
+
return null;
|
|
43
|
+
}
|
|
44
|
+
var value = computed.getPropertyValue(propertyName);
|
|
45
|
+
return value || null;
|
|
46
|
+
}
|
|
47
|
+
function getOpacity(elem) {
|
|
48
|
+
var opacityStyle = getEffectiveStyle(elem, 'opacity');
|
|
49
|
+
var opacity = opacityStyle ? Number(opacityStyle) : 1;
|
|
50
|
+
var parent = getParentElement(elem);
|
|
51
|
+
return parent ? opacity * getOpacity(parent) : opacity;
|
|
52
|
+
}
|
|
53
|
+
function getParentNodeInComposedDom(node) {
|
|
54
|
+
var parent = node.parentNode;
|
|
55
|
+
var slottable = node;
|
|
56
|
+
var parentWithShadow = parent;
|
|
57
|
+
if (parentWithShadow && parentWithShadow.shadowRoot && slottable.assignedSlot !== undefined) {
|
|
58
|
+
return slottable.assignedSlot ? slottable.assignedSlot.parentNode : null;
|
|
59
|
+
}
|
|
60
|
+
return parent;
|
|
61
|
+
}
|
|
62
|
+
function createRect(left, top, width, height) {
|
|
63
|
+
return {
|
|
64
|
+
left: left,
|
|
65
|
+
top: top,
|
|
66
|
+
right: left + width,
|
|
67
|
+
bottom: top + height,
|
|
68
|
+
width: width,
|
|
69
|
+
height: height,
|
|
70
|
+
};
|
|
71
|
+
}
|
|
72
|
+
function getClientRect(elem) {
|
|
73
|
+
var cachedRect = clientRectCache.get(elem);
|
|
74
|
+
if (cachedRect) {
|
|
75
|
+
return cachedRect;
|
|
76
|
+
}
|
|
77
|
+
var rect;
|
|
78
|
+
var imageMap = maybeFindImageMap(elem);
|
|
79
|
+
if (imageMap) {
|
|
80
|
+
rect = imageMap.rect;
|
|
81
|
+
}
|
|
82
|
+
else {
|
|
83
|
+
var elemTagName = typeof elem.tagName === 'string' ? elem.tagName : '';
|
|
84
|
+
if (elemTagName.toUpperCase() === 'HTML') {
|
|
85
|
+
var doc = elem.ownerDocument;
|
|
86
|
+
var sizeElem = doc.compatMode === 'CSS1Compat' ? doc.documentElement : (doc.body || doc.documentElement);
|
|
87
|
+
rect = createRect(0, 0, sizeElem.clientWidth, sizeElem.clientHeight);
|
|
88
|
+
}
|
|
89
|
+
else {
|
|
90
|
+
try {
|
|
91
|
+
var nativeRect = elem.getBoundingClientRect();
|
|
92
|
+
rect = {
|
|
93
|
+
left: nativeRect.left,
|
|
94
|
+
top: nativeRect.top,
|
|
95
|
+
right: nativeRect.right,
|
|
96
|
+
bottom: nativeRect.bottom,
|
|
97
|
+
width: nativeRect.right - nativeRect.left,
|
|
98
|
+
height: nativeRect.bottom - nativeRect.top,
|
|
99
|
+
};
|
|
100
|
+
}
|
|
101
|
+
catch (_error) {
|
|
102
|
+
rect = createRect(0, 0, 0, 0);
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
clientRectCache.set(elem, rect);
|
|
107
|
+
return rect;
|
|
108
|
+
}
|
|
109
|
+
function getAreaRelativeRect(area) {
|
|
110
|
+
var shape = area.shape.toLowerCase();
|
|
111
|
+
var coords = area.coords.split(',').map(function (value) {
|
|
112
|
+
return Number(value.trim());
|
|
113
|
+
});
|
|
114
|
+
if (shape === 'rect' && coords.length === 4) {
|
|
115
|
+
return createRect(coords[0], coords[1], coords[2] - coords[0], coords[3] - coords[1]);
|
|
116
|
+
}
|
|
117
|
+
if (shape === 'circle' && coords.length === 3) {
|
|
118
|
+
return createRect(coords[0] - coords[2], coords[1] - coords[2], coords[2] * 2, coords[2] * 2);
|
|
119
|
+
}
|
|
120
|
+
if (shape === 'poly' && coords.length > 2) {
|
|
121
|
+
var minX = coords[0];
|
|
122
|
+
var minY = coords[1];
|
|
123
|
+
var maxX = minX;
|
|
124
|
+
var maxY = minY;
|
|
125
|
+
for (var index = 2; index + 1 < coords.length; index += 2) {
|
|
126
|
+
minX = Math.min(minX, coords[index]);
|
|
127
|
+
maxX = Math.max(maxX, coords[index]);
|
|
128
|
+
minY = Math.min(minY, coords[index + 1]);
|
|
129
|
+
maxY = Math.max(maxY, coords[index + 1]);
|
|
130
|
+
}
|
|
131
|
+
return createRect(minX, minY, maxX - minX, maxY - minY);
|
|
132
|
+
}
|
|
133
|
+
return createRect(0, 0, 0, 0);
|
|
134
|
+
}
|
|
135
|
+
function findImageUsingMap(mapName, doc) {
|
|
136
|
+
return doc.querySelector('[usemap="#' + mapName.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"]');
|
|
137
|
+
}
|
|
138
|
+
function maybeFindImageMap(elem) {
|
|
139
|
+
var isMap = isElement(elem, 'MAP');
|
|
140
|
+
if (!isMap && !isElement(elem, 'AREA')) {
|
|
141
|
+
return null;
|
|
142
|
+
}
|
|
143
|
+
var map = isMap ? elem : isElement(elem.parentNode, 'MAP') ? elem.parentNode : null;
|
|
144
|
+
var image = null;
|
|
145
|
+
var rect = createRect(0, 0, 0, 0);
|
|
146
|
+
if (isElement(map, 'MAP') && map.name) {
|
|
147
|
+
image = findImageUsingMap(map.name, map.ownerDocument);
|
|
148
|
+
if (image) {
|
|
149
|
+
rect = getClientRect(image);
|
|
150
|
+
if (!isMap && isElement(elem, 'AREA') && elem.shape.toLowerCase() !== 'default') {
|
|
151
|
+
var relativeRect = getAreaRelativeRect(elem);
|
|
152
|
+
var relativeX = Math.min(Math.max(relativeRect.left, 0), rect.width);
|
|
153
|
+
var relativeY = Math.min(Math.max(relativeRect.top, 0), rect.height);
|
|
154
|
+
var width = Math.min(relativeRect.width, rect.width - relativeX);
|
|
155
|
+
var height = Math.min(relativeRect.height, rect.height - relativeY);
|
|
156
|
+
rect = createRect(relativeX + rect.left, relativeY + rect.top, width, height);
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
return { image: image, rect: rect };
|
|
161
|
+
}
|
|
162
|
+
function getClientRegion(elem) {
|
|
163
|
+
return getClientRect(elem);
|
|
164
|
+
}
|
|
165
|
+
function getOverflowState(elem) {
|
|
166
|
+
var region = getClientRegion(elem);
|
|
167
|
+
var ownerDoc = elem.ownerDocument;
|
|
168
|
+
var htmlElem = ownerDoc.documentElement;
|
|
169
|
+
var bodyElem = ownerDoc.body;
|
|
170
|
+
var htmlOverflowStyle = getEffectiveStyle(htmlElem, 'overflow') || 'visible';
|
|
171
|
+
var treatAsFixedPosition = false;
|
|
172
|
+
function canBeOverflowed(container, position) {
|
|
173
|
+
if (container === htmlElem) {
|
|
174
|
+
return true;
|
|
175
|
+
}
|
|
176
|
+
var display = getEffectiveStyle(container, 'display') || '';
|
|
177
|
+
if (display.indexOf('inline') === 0 || display === 'contents') {
|
|
178
|
+
return false;
|
|
179
|
+
}
|
|
180
|
+
if (position === 'absolute' && getEffectiveStyle(container, 'position') === 'static') {
|
|
181
|
+
return false;
|
|
182
|
+
}
|
|
183
|
+
return true;
|
|
184
|
+
}
|
|
185
|
+
function getOverflowParent(current) {
|
|
186
|
+
var position = getEffectiveStyle(current, 'position');
|
|
187
|
+
if (position === 'fixed') {
|
|
188
|
+
treatAsFixedPosition = true;
|
|
189
|
+
return current === htmlElem ? null : htmlElem;
|
|
190
|
+
}
|
|
191
|
+
var parent = getParentElement(current);
|
|
192
|
+
while (parent && !canBeOverflowed(parent, position)) {
|
|
193
|
+
parent = getParentElement(parent);
|
|
194
|
+
}
|
|
195
|
+
return parent;
|
|
196
|
+
}
|
|
197
|
+
function getOverflowStyles(current) {
|
|
198
|
+
var overflowElem = current;
|
|
199
|
+
if (htmlOverflowStyle === 'visible') {
|
|
200
|
+
if (current === htmlElem && bodyElem) {
|
|
201
|
+
overflowElem = bodyElem;
|
|
202
|
+
}
|
|
203
|
+
else if (current === bodyElem) {
|
|
204
|
+
return { x: 'visible', y: 'visible' };
|
|
205
|
+
}
|
|
206
|
+
}
|
|
207
|
+
var overflow = {
|
|
208
|
+
x: getEffectiveStyle(overflowElem, 'overflow-x') || 'visible',
|
|
209
|
+
y: getEffectiveStyle(overflowElem, 'overflow-y') || 'visible',
|
|
210
|
+
};
|
|
211
|
+
if (current === htmlElem) {
|
|
212
|
+
overflow.x = overflow.x === 'visible' ? 'auto' : overflow.x;
|
|
213
|
+
overflow.y = overflow.y === 'visible' ? 'auto' : overflow.y;
|
|
214
|
+
}
|
|
215
|
+
return overflow;
|
|
216
|
+
}
|
|
217
|
+
function getScroll(current) {
|
|
218
|
+
if (current === htmlElem) {
|
|
219
|
+
return {
|
|
220
|
+
x: ownerDoc.defaultView ? ownerDoc.defaultView.pageXOffset : 0,
|
|
221
|
+
y: ownerDoc.defaultView ? ownerDoc.defaultView.pageYOffset : 0,
|
|
222
|
+
};
|
|
223
|
+
}
|
|
224
|
+
return { x: current.scrollLeft, y: current.scrollTop };
|
|
225
|
+
}
|
|
226
|
+
for (var container = getOverflowParent(elem); container; container = getOverflowParent(container)) {
|
|
227
|
+
var containerOverflow = getOverflowStyles(container);
|
|
228
|
+
if (containerOverflow.x === 'visible' && containerOverflow.y === 'visible') {
|
|
229
|
+
continue;
|
|
230
|
+
}
|
|
231
|
+
var containerRect = getClientRect(container);
|
|
232
|
+
if (containerRect.width === 0 || containerRect.height === 0) {
|
|
233
|
+
return 'hidden';
|
|
234
|
+
}
|
|
235
|
+
var underflowsX = region.right < containerRect.left;
|
|
236
|
+
var underflowsY = region.bottom < containerRect.top;
|
|
237
|
+
if ((underflowsX && containerOverflow.x === 'hidden') || (underflowsY && containerOverflow.y === 'hidden')) {
|
|
238
|
+
return 'hidden';
|
|
239
|
+
}
|
|
240
|
+
if ((underflowsX && containerOverflow.x !== 'visible') || (underflowsY && containerOverflow.y !== 'visible')) {
|
|
241
|
+
var containerScroll = getScroll(container);
|
|
242
|
+
var unscrollableX = region.right < containerRect.left - containerScroll.x;
|
|
243
|
+
var unscrollableY = region.bottom < containerRect.top - containerScroll.y;
|
|
244
|
+
if ((unscrollableX && containerOverflow.x !== 'visible') || (unscrollableY && containerOverflow.y !== 'visible')) {
|
|
245
|
+
return 'hidden';
|
|
246
|
+
}
|
|
247
|
+
var containerUnderflowState = getOverflowState(container);
|
|
248
|
+
return containerUnderflowState === 'hidden' ? 'hidden' : 'scroll';
|
|
249
|
+
}
|
|
250
|
+
var overflowsX = region.left >= containerRect.left + containerRect.width;
|
|
251
|
+
var overflowsY = region.top >= containerRect.top + containerRect.height;
|
|
252
|
+
if ((overflowsX && containerOverflow.x === 'hidden') || (overflowsY && containerOverflow.y === 'hidden')) {
|
|
253
|
+
return 'hidden';
|
|
254
|
+
}
|
|
255
|
+
if ((overflowsX && containerOverflow.x !== 'visible') || (overflowsY && containerOverflow.y !== 'visible')) {
|
|
256
|
+
if (treatAsFixedPosition) {
|
|
257
|
+
var docScroll = getScroll(container);
|
|
258
|
+
if (region.left >= htmlElem.scrollWidth - docScroll.x || region.right >= htmlElem.scrollHeight - docScroll.y) {
|
|
259
|
+
return 'hidden';
|
|
260
|
+
}
|
|
261
|
+
}
|
|
262
|
+
var containerOverflowState = getOverflowState(container);
|
|
263
|
+
return containerOverflowState === 'hidden' ? 'hidden' : 'scroll';
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
return 'none';
|
|
267
|
+
}
|
|
268
|
+
function isShownInternal(elem, ignoreOpacity, displayedFn) {
|
|
269
|
+
if (!isElement(elem)) {
|
|
270
|
+
throw new Error('Argument to isShown must be of type Element');
|
|
271
|
+
}
|
|
272
|
+
if (isElement(elem, 'BODY')) {
|
|
273
|
+
return true;
|
|
274
|
+
}
|
|
275
|
+
if (isElement(elem, 'OPTION') || isElement(elem, 'OPTGROUP')) {
|
|
276
|
+
var select = elem.closest('select');
|
|
277
|
+
return !!select && isShownInternal(select, true, displayedFn);
|
|
278
|
+
}
|
|
279
|
+
var imageMap = maybeFindImageMap(elem);
|
|
280
|
+
if (imageMap) {
|
|
281
|
+
return !!imageMap.image && imageMap.rect.width > 0 && imageMap.rect.height > 0 &&
|
|
282
|
+
isShownInternal(imageMap.image, ignoreOpacity, displayedFn);
|
|
283
|
+
}
|
|
284
|
+
if (isElement(elem, 'INPUT') && elem.type.toLowerCase() === 'hidden') {
|
|
285
|
+
return false;
|
|
286
|
+
}
|
|
287
|
+
if (isElement(elem, 'NOSCRIPT')) {
|
|
288
|
+
return false;
|
|
289
|
+
}
|
|
290
|
+
var visibility = getEffectiveStyle(elem, 'visibility');
|
|
291
|
+
if (visibility === 'collapse' || visibility === 'hidden') {
|
|
292
|
+
return false;
|
|
293
|
+
}
|
|
294
|
+
if (!displayedFn(elem)) {
|
|
295
|
+
return false;
|
|
296
|
+
}
|
|
297
|
+
if (!ignoreOpacity && getOpacity(elem) === 0) {
|
|
298
|
+
return false;
|
|
299
|
+
}
|
|
300
|
+
function positiveSize(element) {
|
|
301
|
+
var rect = getClientRect(element);
|
|
302
|
+
if (rect.height > 0 && rect.width > 0) {
|
|
303
|
+
return true;
|
|
304
|
+
}
|
|
305
|
+
if (isElement(element, 'PATH') && (rect.height > 0 || rect.width > 0)) {
|
|
306
|
+
var strokeWidth = getEffectiveStyle(element, 'stroke-width');
|
|
307
|
+
return !!strokeWidth && parseInt(strokeWidth, 10) > 0;
|
|
308
|
+
}
|
|
309
|
+
var elementVisibility = getEffectiveStyle(element, 'visibility');
|
|
310
|
+
if (elementVisibility === 'collapse' || elementVisibility === 'hidden') {
|
|
311
|
+
return false;
|
|
312
|
+
}
|
|
313
|
+
if (!displayedFn(element)) {
|
|
314
|
+
return false;
|
|
315
|
+
}
|
|
316
|
+
if (getEffectiveStyle(element, 'overflow') === 'hidden') {
|
|
317
|
+
return false;
|
|
318
|
+
}
|
|
319
|
+
for (var index = 0; index < element.childNodes.length; index += 1) {
|
|
320
|
+
var child = element.childNodes[index];
|
|
321
|
+
if (child.nodeType === Node.TEXT_NODE) {
|
|
322
|
+
var text = child.nodeValue || '';
|
|
323
|
+
if (/^[\s]*$/.test(text) && /[\n\r\t]/.test(text)) {
|
|
324
|
+
continue;
|
|
325
|
+
}
|
|
326
|
+
return true;
|
|
327
|
+
}
|
|
328
|
+
if (isElement(child) && positiveSize(child)) {
|
|
329
|
+
return true;
|
|
330
|
+
}
|
|
331
|
+
}
|
|
332
|
+
return false;
|
|
333
|
+
}
|
|
334
|
+
if (!positiveSize(elem)) {
|
|
335
|
+
return false;
|
|
336
|
+
}
|
|
337
|
+
function hiddenByOverflow(element) {
|
|
338
|
+
if (getOverflowState(element) !== 'hidden') {
|
|
339
|
+
return false;
|
|
340
|
+
}
|
|
341
|
+
for (var index = 0; index < element.childNodes.length; index += 1) {
|
|
342
|
+
var child = element.childNodes[index];
|
|
343
|
+
if (isElement(child) && !hiddenByOverflow(child) && positiveSize(child)) {
|
|
344
|
+
return false;
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
return true;
|
|
348
|
+
}
|
|
349
|
+
return !hiddenByOverflow(elem);
|
|
350
|
+
}
|
|
351
|
+
function displayed(node) {
|
|
352
|
+
var cached = displayedCache.get(node);
|
|
353
|
+
if (cached !== undefined) {
|
|
354
|
+
return cached;
|
|
355
|
+
}
|
|
356
|
+
if (isElement(node)) {
|
|
357
|
+
var display = getEffectiveStyle(node, 'display');
|
|
358
|
+
var contentVisibility = getEffectiveStyle(node, 'content-visibility');
|
|
359
|
+
if (display === 'none' || contentVisibility === 'hidden') {
|
|
360
|
+
displayedCache.set(node, false);
|
|
361
|
+
return false;
|
|
362
|
+
}
|
|
363
|
+
}
|
|
364
|
+
var parent = getParentNodeInComposedDom(node);
|
|
365
|
+
if (typeof ShadowRoot === 'function' && parent instanceof ShadowRoot) {
|
|
366
|
+
if (parent.host.shadowRoot && parent.host.shadowRoot !== parent) {
|
|
367
|
+
displayedCache.set(node, false);
|
|
368
|
+
return false;
|
|
369
|
+
}
|
|
370
|
+
parent = parent.host;
|
|
371
|
+
}
|
|
372
|
+
if (parent && (parent.nodeType === Node.DOCUMENT_NODE || parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE)) {
|
|
373
|
+
displayedCache.set(node, true);
|
|
374
|
+
return true;
|
|
375
|
+
}
|
|
376
|
+
if (isElement(parent, 'DETAILS') && !parent.open && !isElement(node, 'SUMMARY')) {
|
|
377
|
+
displayedCache.set(node, false);
|
|
378
|
+
return false;
|
|
379
|
+
}
|
|
380
|
+
var result = !!parent && displayed(parent);
|
|
381
|
+
displayedCache.set(node, result);
|
|
382
|
+
return result;
|
|
383
|
+
}
|
|
384
|
+
return isShownInternal(elem, !!optIgnoreOpacity, displayed);
|
|
385
|
+
})
|
|
@@ -49,7 +49,9 @@ module Selenium
|
|
|
49
49
|
# options = Selenium::WebDriver::Chrome::Options.new(args: ['start-maximized', 'user-data-dir=/tmp/temp_profile'])
|
|
50
50
|
# driver = Selenium::WebDriver.for(:chrome, options: options)
|
|
51
51
|
#
|
|
52
|
-
# @param [Profile] profile An instance of a Chrome::Profile
|
|
52
|
+
# @param [Profile] profile (Deprecated) An instance of a Chrome::Profile class.
|
|
53
|
+
# Use {#add_argument} with `--user-data-dir=...`, {#add_preference}, and
|
|
54
|
+
# {#add_extension} instead.
|
|
53
55
|
# @param [Hash] opts the pre-defined options to create the Chrome::Options with
|
|
54
56
|
# @option opts [Array] encoded_extensions List of extensions that do not need to be Base64 encoded
|
|
55
57
|
# @option opts [Array<String>] args List of command-line arguments to use when starting Chrome
|