@axe-core/watcher 1.8.2 → 2.0.0-next.970e98d4
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.
- package/dist/cypress.d.ts +0 -4
- package/dist/cypress.js +1 -58
- package/dist/cypress.js.map +1 -1
- package/dist/cypressCommands.d.ts +6 -0
- package/dist/cypressCommands.js +101 -21
- package/dist/cypressCommands.js.map +1 -1
- package/dist/index.d.ts +2 -2
- package/dist/index.js +2 -2
- package/dist/index.js.map +1 -1
- package/dist/playwright.d.ts +2 -0
- package/dist/playwright.js +9 -2
- package/dist/playwright.js.map +1 -1
- package/dist/playwrightWrapping.d.ts +20 -0
- package/dist/playwrightWrapping.js +840 -0
- package/dist/playwrightWrapping.js.map +1 -0
- package/extension/background.js +1 -1
- package/extension/content.js +1 -1
- package/extension/manifest.json +1 -1
- package/package.json +5 -4
|
@@ -0,0 +1,840 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
3
|
+
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
4
|
+
return new (P || (P = Promise))(function (resolve, reject) {
|
|
5
|
+
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
6
|
+
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
7
|
+
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
8
|
+
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
9
|
+
});
|
|
10
|
+
};
|
|
11
|
+
var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
12
|
+
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
13
|
+
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
14
|
+
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
15
|
+
function step(op) {
|
|
16
|
+
if (f) throw new TypeError("Generator is already executing.");
|
|
17
|
+
while (_) try {
|
|
18
|
+
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;
|
|
19
|
+
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
20
|
+
switch (op[0]) {
|
|
21
|
+
case 0: case 1: t = op; break;
|
|
22
|
+
case 4: _.label++; return { value: op[1], done: false };
|
|
23
|
+
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
24
|
+
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
25
|
+
default:
|
|
26
|
+
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
27
|
+
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
28
|
+
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
29
|
+
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
30
|
+
if (t[2]) _.ops.pop();
|
|
31
|
+
_.trys.pop(); continue;
|
|
32
|
+
}
|
|
33
|
+
op = body.call(thisArg, _);
|
|
34
|
+
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
35
|
+
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
36
|
+
}
|
|
37
|
+
};
|
|
38
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
39
|
+
exports.wrapTouchscreen = exports.wrapMouse = exports.wrapKeyboard = exports.wrapJSHandle = exports.wrapLocator = exports.wrapFrameLocator = exports.wrapFrame = exports.wrapElementHandle = exports.wrapPage = exports.wrapBrowser = exports.wrapBrowserContext = exports.markAsWrapped = exports.isWrapped = void 0;
|
|
40
|
+
var kWrapped = Symbol('axe watcher wrapped');
|
|
41
|
+
var isWrapped = function (o) {
|
|
42
|
+
if (!o) {
|
|
43
|
+
return false;
|
|
44
|
+
}
|
|
45
|
+
return o[kWrapped] === true;
|
|
46
|
+
};
|
|
47
|
+
exports.isWrapped = isWrapped;
|
|
48
|
+
var markAsWrapped = function (o) {
|
|
49
|
+
Object.defineProperty(o, kWrapped, {
|
|
50
|
+
configurable: false,
|
|
51
|
+
enumerable: false,
|
|
52
|
+
value: true
|
|
53
|
+
});
|
|
54
|
+
};
|
|
55
|
+
exports.markAsWrapped = markAsWrapped;
|
|
56
|
+
var wrappedCallWithSideEffects = function (target, prop, controller) {
|
|
57
|
+
return function () {
|
|
58
|
+
var args = [];
|
|
59
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
60
|
+
args[_i] = arguments[_i];
|
|
61
|
+
}
|
|
62
|
+
return __awaiter(void 0, void 0, void 0, function () {
|
|
63
|
+
var result;
|
|
64
|
+
return __generator(this, function (_a) {
|
|
65
|
+
switch (_a.label) {
|
|
66
|
+
case 0: return [4 /*yield*/, target[prop].apply(target, args)];
|
|
67
|
+
case 1:
|
|
68
|
+
result = _a.sent();
|
|
69
|
+
return [4 /*yield*/, controller.analyze()];
|
|
70
|
+
case 2:
|
|
71
|
+
_a.sent();
|
|
72
|
+
return [2 /*return*/, result];
|
|
73
|
+
}
|
|
74
|
+
});
|
|
75
|
+
});
|
|
76
|
+
};
|
|
77
|
+
};
|
|
78
|
+
var wrapBrowserContext = function (browserContext, controller) {
|
|
79
|
+
if ((0, exports.isWrapped)(browserContext)) {
|
|
80
|
+
return browserContext;
|
|
81
|
+
}
|
|
82
|
+
var browserContextProxy = new Proxy(browserContext, {
|
|
83
|
+
get: function (target, prop, receiver) {
|
|
84
|
+
var _this = this;
|
|
85
|
+
switch (prop) {
|
|
86
|
+
case 'newPage':
|
|
87
|
+
return function () {
|
|
88
|
+
var args = [];
|
|
89
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
90
|
+
args[_i] = arguments[_i];
|
|
91
|
+
}
|
|
92
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
93
|
+
var page;
|
|
94
|
+
return __generator(this, function (_a) {
|
|
95
|
+
switch (_a.label) {
|
|
96
|
+
case 0: return [4 /*yield*/, target.newPage.apply(target, args)];
|
|
97
|
+
case 1:
|
|
98
|
+
page = _a.sent();
|
|
99
|
+
return [2 /*return*/, (0, exports.wrapPage)(page, controller)];
|
|
100
|
+
}
|
|
101
|
+
});
|
|
102
|
+
});
|
|
103
|
+
};
|
|
104
|
+
case 'browser': {
|
|
105
|
+
return function () {
|
|
106
|
+
var browser = target.browser();
|
|
107
|
+
if (!browser) {
|
|
108
|
+
return null;
|
|
109
|
+
}
|
|
110
|
+
return (0, exports.wrapBrowser)(browser, controller);
|
|
111
|
+
};
|
|
112
|
+
}
|
|
113
|
+
case 'pages': {
|
|
114
|
+
return function () {
|
|
115
|
+
var args = [];
|
|
116
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
117
|
+
args[_i] = arguments[_i];
|
|
118
|
+
}
|
|
119
|
+
var pages = target.pages.apply(target, args);
|
|
120
|
+
return pages.map(function (p) { return (0, exports.wrapPage)(p, controller); });
|
|
121
|
+
};
|
|
122
|
+
}
|
|
123
|
+
default:
|
|
124
|
+
return Reflect.get(target, prop, receiver);
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
});
|
|
128
|
+
(0, exports.markAsWrapped)(browserContextProxy);
|
|
129
|
+
return browserContextProxy;
|
|
130
|
+
};
|
|
131
|
+
exports.wrapBrowserContext = wrapBrowserContext;
|
|
132
|
+
var wrapBrowser = function (browser, controller) {
|
|
133
|
+
if ((0, exports.isWrapped)(browser)) {
|
|
134
|
+
return browser;
|
|
135
|
+
}
|
|
136
|
+
var browserProxy = new Proxy(browser, {
|
|
137
|
+
get: function (target, prop, receiver) {
|
|
138
|
+
var _this = this;
|
|
139
|
+
switch (prop) {
|
|
140
|
+
case 'newContext': {
|
|
141
|
+
return function () {
|
|
142
|
+
var args = [];
|
|
143
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
144
|
+
args[_i] = arguments[_i];
|
|
145
|
+
}
|
|
146
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
147
|
+
var context;
|
|
148
|
+
return __generator(this, function (_a) {
|
|
149
|
+
switch (_a.label) {
|
|
150
|
+
case 0: return [4 /*yield*/, target.newContext.apply(target, args)];
|
|
151
|
+
case 1:
|
|
152
|
+
context = _a.sent();
|
|
153
|
+
return [2 /*return*/, (0, exports.wrapBrowserContext)(context, controller)];
|
|
154
|
+
}
|
|
155
|
+
});
|
|
156
|
+
});
|
|
157
|
+
};
|
|
158
|
+
}
|
|
159
|
+
case 'newPage': {
|
|
160
|
+
return function () {
|
|
161
|
+
var args = [];
|
|
162
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
163
|
+
args[_i] = arguments[_i];
|
|
164
|
+
}
|
|
165
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
166
|
+
var page;
|
|
167
|
+
return __generator(this, function (_a) {
|
|
168
|
+
switch (_a.label) {
|
|
169
|
+
case 0: return [4 /*yield*/, target.newPage.apply(target, args)];
|
|
170
|
+
case 1:
|
|
171
|
+
page = _a.sent();
|
|
172
|
+
return [2 /*return*/, (0, exports.wrapPage)(page, controller)];
|
|
173
|
+
}
|
|
174
|
+
});
|
|
175
|
+
});
|
|
176
|
+
};
|
|
177
|
+
}
|
|
178
|
+
case 'contexts': {
|
|
179
|
+
return function () {
|
|
180
|
+
var args = [];
|
|
181
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
182
|
+
args[_i] = arguments[_i];
|
|
183
|
+
}
|
|
184
|
+
var contexts = target.contexts.apply(target, args);
|
|
185
|
+
return contexts.map(function (c) { return (0, exports.wrapBrowserContext)(c, controller); });
|
|
186
|
+
};
|
|
187
|
+
}
|
|
188
|
+
default:
|
|
189
|
+
return Reflect.get(target, prop, receiver);
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
});
|
|
193
|
+
(0, exports.markAsWrapped)(browserProxy);
|
|
194
|
+
return browserProxy;
|
|
195
|
+
};
|
|
196
|
+
exports.wrapBrowser = wrapBrowser;
|
|
197
|
+
var wrapPage = function (page, controller) {
|
|
198
|
+
if ((0, exports.isWrapped)(page)) {
|
|
199
|
+
return page;
|
|
200
|
+
}
|
|
201
|
+
var pageProxy = new Proxy(page, {
|
|
202
|
+
get: function (target, prop, receiver) {
|
|
203
|
+
var _this = this;
|
|
204
|
+
switch (prop) {
|
|
205
|
+
case 'addScriptTag':
|
|
206
|
+
case 'addStyleTag':
|
|
207
|
+
return function () {
|
|
208
|
+
var args = [];
|
|
209
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
210
|
+
args[_i] = arguments[_i];
|
|
211
|
+
}
|
|
212
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
213
|
+
var style;
|
|
214
|
+
return __generator(this, function (_a) {
|
|
215
|
+
switch (_a.label) {
|
|
216
|
+
case 0: return [4 /*yield*/, target[prop].apply(target, args)];
|
|
217
|
+
case 1:
|
|
218
|
+
style = _a.sent();
|
|
219
|
+
return [2 /*return*/, (0, exports.wrapElementHandle)(style, controller)];
|
|
220
|
+
}
|
|
221
|
+
});
|
|
222
|
+
});
|
|
223
|
+
};
|
|
224
|
+
case 'bringToFront':
|
|
225
|
+
case 'check':
|
|
226
|
+
case 'click':
|
|
227
|
+
case 'dblclick':
|
|
228
|
+
case 'dragAndDrop':
|
|
229
|
+
case 'emulateMedia':
|
|
230
|
+
case 'fill':
|
|
231
|
+
case 'focus':
|
|
232
|
+
case 'goBack':
|
|
233
|
+
case 'goForward':
|
|
234
|
+
case 'goto':
|
|
235
|
+
case 'hover':
|
|
236
|
+
case 'press':
|
|
237
|
+
case 'reload':
|
|
238
|
+
case 'selectOption':
|
|
239
|
+
case 'setChecked':
|
|
240
|
+
case 'setContent':
|
|
241
|
+
case 'tap':
|
|
242
|
+
case 'type':
|
|
243
|
+
case 'uncheck':
|
|
244
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
245
|
+
case 'context':
|
|
246
|
+
return function () {
|
|
247
|
+
var context = target.context();
|
|
248
|
+
return (0, exports.wrapBrowserContext)(context, controller);
|
|
249
|
+
};
|
|
250
|
+
case 'evaluateHandle':
|
|
251
|
+
case 'waitForFunction':
|
|
252
|
+
return function () {
|
|
253
|
+
var args = [];
|
|
254
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
255
|
+
args[_i] = arguments[_i];
|
|
256
|
+
}
|
|
257
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
258
|
+
var handle;
|
|
259
|
+
return __generator(this, function (_a) {
|
|
260
|
+
switch (_a.label) {
|
|
261
|
+
case 0: return [4 /*yield*/, target[prop].apply(target, args)];
|
|
262
|
+
case 1:
|
|
263
|
+
handle = _a.sent();
|
|
264
|
+
return [2 /*return*/, (0, exports.wrapJSHandle)(handle, controller)];
|
|
265
|
+
}
|
|
266
|
+
});
|
|
267
|
+
});
|
|
268
|
+
};
|
|
269
|
+
case 'frame':
|
|
270
|
+
case 'mainFrame':
|
|
271
|
+
return function () {
|
|
272
|
+
var args = [];
|
|
273
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
274
|
+
args[_i] = arguments[_i];
|
|
275
|
+
}
|
|
276
|
+
// @ts-expect-error TypeScript is angry.
|
|
277
|
+
var mainFrame = target[prop].apply(target, args);
|
|
278
|
+
if (!mainFrame) {
|
|
279
|
+
return null;
|
|
280
|
+
}
|
|
281
|
+
return (0, exports.wrapFrame)(mainFrame, controller);
|
|
282
|
+
};
|
|
283
|
+
case 'frames':
|
|
284
|
+
return function () {
|
|
285
|
+
var args = [];
|
|
286
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
287
|
+
args[_i] = arguments[_i];
|
|
288
|
+
}
|
|
289
|
+
var frames = target.frames.apply(target, args);
|
|
290
|
+
return frames.map(function (f) { return (0, exports.wrapFrame)(f, controller); });
|
|
291
|
+
};
|
|
292
|
+
case 'frameLocator':
|
|
293
|
+
return function () {
|
|
294
|
+
var args = [];
|
|
295
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
296
|
+
args[_i] = arguments[_i];
|
|
297
|
+
}
|
|
298
|
+
var frameLocator = target.frameLocator.apply(target, args);
|
|
299
|
+
return (0, exports.wrapFrameLocator)(frameLocator, controller);
|
|
300
|
+
};
|
|
301
|
+
case 'getByAltText':
|
|
302
|
+
case 'getByLabel':
|
|
303
|
+
case 'getByPlaceholder':
|
|
304
|
+
case 'getByRole':
|
|
305
|
+
case 'getByTestId':
|
|
306
|
+
case 'getByText':
|
|
307
|
+
case 'getByTitle':
|
|
308
|
+
case 'locator':
|
|
309
|
+
return function () {
|
|
310
|
+
var args = [];
|
|
311
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
312
|
+
args[_i] = arguments[_i];
|
|
313
|
+
}
|
|
314
|
+
// @ts-expect-error TypeScript is angry.
|
|
315
|
+
var el = target[prop].apply(target, args);
|
|
316
|
+
return (0, exports.wrapLocator)(el, controller);
|
|
317
|
+
};
|
|
318
|
+
case 'keyboard':
|
|
319
|
+
return (0, exports.wrapKeyboard)(target.keyboard, controller);
|
|
320
|
+
case 'mouse':
|
|
321
|
+
return (0, exports.wrapMouse)(target.mouse, controller);
|
|
322
|
+
case 'touchscreen':
|
|
323
|
+
return (0, exports.wrapTouchscreen)(target.touchscreen, controller);
|
|
324
|
+
default:
|
|
325
|
+
return Reflect.get(target, prop, receiver);
|
|
326
|
+
}
|
|
327
|
+
}
|
|
328
|
+
});
|
|
329
|
+
(0, exports.markAsWrapped)(pageProxy);
|
|
330
|
+
return pageProxy;
|
|
331
|
+
};
|
|
332
|
+
exports.wrapPage = wrapPage;
|
|
333
|
+
var wrapElementHandle = function (elementHandle, controller) {
|
|
334
|
+
if ((0, exports.isWrapped)(elementHandle)) {
|
|
335
|
+
return elementHandle;
|
|
336
|
+
}
|
|
337
|
+
var elementHandleProxy = new Proxy(elementHandle, {
|
|
338
|
+
get: function (target, prop, receiver) {
|
|
339
|
+
var _this = this;
|
|
340
|
+
switch (prop) {
|
|
341
|
+
case '$':
|
|
342
|
+
case 'asElement':
|
|
343
|
+
case 'waitForSelector':
|
|
344
|
+
return function () {
|
|
345
|
+
var args = [];
|
|
346
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
347
|
+
args[_i] = arguments[_i];
|
|
348
|
+
}
|
|
349
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
350
|
+
var el;
|
|
351
|
+
return __generator(this, function (_a) {
|
|
352
|
+
switch (_a.label) {
|
|
353
|
+
case 0: return [4 /*yield*/, target[prop].apply(target, args)];
|
|
354
|
+
case 1:
|
|
355
|
+
el = _a.sent();
|
|
356
|
+
return [2 /*return*/, (0, exports.wrapElementHandle)(el, controller)];
|
|
357
|
+
}
|
|
358
|
+
});
|
|
359
|
+
});
|
|
360
|
+
};
|
|
361
|
+
case '$$': {
|
|
362
|
+
return function () {
|
|
363
|
+
var args = [];
|
|
364
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
365
|
+
args[_i] = arguments[_i];
|
|
366
|
+
}
|
|
367
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
368
|
+
var els;
|
|
369
|
+
return __generator(this, function (_a) {
|
|
370
|
+
switch (_a.label) {
|
|
371
|
+
case 0: return [4 /*yield*/, target.$$.apply(target, args)];
|
|
372
|
+
case 1:
|
|
373
|
+
els = _a.sent();
|
|
374
|
+
return [2 /*return*/, els.map(function (e) { return (0, exports.wrapElementHandle)(e, controller); })];
|
|
375
|
+
}
|
|
376
|
+
});
|
|
377
|
+
});
|
|
378
|
+
};
|
|
379
|
+
}
|
|
380
|
+
case 'check':
|
|
381
|
+
case 'click':
|
|
382
|
+
case 'dblclick':
|
|
383
|
+
case 'dispatchEvent':
|
|
384
|
+
case 'fill':
|
|
385
|
+
case 'focus':
|
|
386
|
+
case 'hover':
|
|
387
|
+
case 'press':
|
|
388
|
+
case 'scrollIntoViewIfNeeded':
|
|
389
|
+
case 'selectOption':
|
|
390
|
+
case 'selectText':
|
|
391
|
+
case 'setChecked':
|
|
392
|
+
case 'setInputFiles':
|
|
393
|
+
case 'tap':
|
|
394
|
+
case 'type':
|
|
395
|
+
case 'uncheck':
|
|
396
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
397
|
+
case 'contentFrame':
|
|
398
|
+
case 'ownerFrame':
|
|
399
|
+
return function () {
|
|
400
|
+
var args = [];
|
|
401
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
402
|
+
args[_i] = arguments[_i];
|
|
403
|
+
}
|
|
404
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
405
|
+
var frame;
|
|
406
|
+
return __generator(this, function (_a) {
|
|
407
|
+
switch (_a.label) {
|
|
408
|
+
case 0: return [4 /*yield*/, target[prop].apply(target, args)];
|
|
409
|
+
case 1:
|
|
410
|
+
frame = _a.sent();
|
|
411
|
+
if (!frame) {
|
|
412
|
+
return [2 /*return*/, null];
|
|
413
|
+
}
|
|
414
|
+
return [2 /*return*/, (0, exports.wrapFrame)(frame, controller)];
|
|
415
|
+
}
|
|
416
|
+
});
|
|
417
|
+
});
|
|
418
|
+
};
|
|
419
|
+
default:
|
|
420
|
+
return Reflect.get(target, prop, receiver);
|
|
421
|
+
}
|
|
422
|
+
}
|
|
423
|
+
});
|
|
424
|
+
(0, exports.markAsWrapped)(elementHandleProxy);
|
|
425
|
+
return elementHandleProxy;
|
|
426
|
+
};
|
|
427
|
+
exports.wrapElementHandle = wrapElementHandle;
|
|
428
|
+
var wrapFrame = function (frame, controller) {
|
|
429
|
+
if ((0, exports.isWrapped)(frame)) {
|
|
430
|
+
return frame;
|
|
431
|
+
}
|
|
432
|
+
var frameProxy = new Proxy(frame, {
|
|
433
|
+
get: function (target, prop, receiver) {
|
|
434
|
+
var _this = this;
|
|
435
|
+
switch (prop) {
|
|
436
|
+
case '$':
|
|
437
|
+
case 'addScriptTag':
|
|
438
|
+
case 'addStyleTag':
|
|
439
|
+
case 'frameElement':
|
|
440
|
+
case 'waitForSelector':
|
|
441
|
+
return function () {
|
|
442
|
+
var args = [];
|
|
443
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
444
|
+
args[_i] = arguments[_i];
|
|
445
|
+
}
|
|
446
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
447
|
+
var el;
|
|
448
|
+
return __generator(this, function (_a) {
|
|
449
|
+
switch (_a.label) {
|
|
450
|
+
case 0: return [4 /*yield*/, target[prop].apply(target, args)];
|
|
451
|
+
case 1:
|
|
452
|
+
el = _a.sent();
|
|
453
|
+
if (!el) {
|
|
454
|
+
return [2 /*return*/, null];
|
|
455
|
+
}
|
|
456
|
+
return [2 /*return*/, (0, exports.wrapElementHandle)(el, controller)];
|
|
457
|
+
}
|
|
458
|
+
});
|
|
459
|
+
});
|
|
460
|
+
};
|
|
461
|
+
case 'evaluateHandle':
|
|
462
|
+
return function () {
|
|
463
|
+
var args = [];
|
|
464
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
465
|
+
args[_i] = arguments[_i];
|
|
466
|
+
}
|
|
467
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
468
|
+
var el;
|
|
469
|
+
return __generator(this, function (_a) {
|
|
470
|
+
switch (_a.label) {
|
|
471
|
+
case 0: return [4 /*yield*/, target.evaluateHandle.apply(target, args)];
|
|
472
|
+
case 1:
|
|
473
|
+
el = _a.sent();
|
|
474
|
+
return [2 /*return*/, (0, exports.wrapJSHandle)(el, controller)];
|
|
475
|
+
}
|
|
476
|
+
});
|
|
477
|
+
});
|
|
478
|
+
};
|
|
479
|
+
case 'childFrames':
|
|
480
|
+
return function () {
|
|
481
|
+
var args = [];
|
|
482
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
483
|
+
args[_i] = arguments[_i];
|
|
484
|
+
}
|
|
485
|
+
var frames = target.childFrames.apply(target, args);
|
|
486
|
+
return frames.map(function (f) { return (0, exports.wrapFrame)(f, controller); });
|
|
487
|
+
};
|
|
488
|
+
case 'check':
|
|
489
|
+
case 'click':
|
|
490
|
+
case 'dragAndDrop':
|
|
491
|
+
case 'dblclick':
|
|
492
|
+
case 'dispatchEvent':
|
|
493
|
+
case 'fill':
|
|
494
|
+
case 'focus':
|
|
495
|
+
case 'hover':
|
|
496
|
+
case 'press':
|
|
497
|
+
case 'selectOption':
|
|
498
|
+
case 'setChecked':
|
|
499
|
+
case 'setInputFiles':
|
|
500
|
+
case 'tap':
|
|
501
|
+
case 'type':
|
|
502
|
+
case 'uncheck':
|
|
503
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
504
|
+
case 'frameLocator':
|
|
505
|
+
return function () {
|
|
506
|
+
var args = [];
|
|
507
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
508
|
+
args[_i] = arguments[_i];
|
|
509
|
+
}
|
|
510
|
+
var frameLocator = target.frameLocator.apply(target, args);
|
|
511
|
+
return (0, exports.wrapFrameLocator)(frameLocator, controller);
|
|
512
|
+
};
|
|
513
|
+
case 'getByAltText':
|
|
514
|
+
case 'getByLabel':
|
|
515
|
+
case 'getByPlaceholder':
|
|
516
|
+
case 'getByRole':
|
|
517
|
+
case 'getByTestId':
|
|
518
|
+
case 'getByText':
|
|
519
|
+
case 'getByTitle':
|
|
520
|
+
case 'locator':
|
|
521
|
+
return function () {
|
|
522
|
+
var args = [];
|
|
523
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
524
|
+
args[_i] = arguments[_i];
|
|
525
|
+
}
|
|
526
|
+
// @ts-expect-error TypeScript is angry.
|
|
527
|
+
var el = target[prop].apply(target, args);
|
|
528
|
+
return (0, exports.wrapLocator)(el, controller);
|
|
529
|
+
};
|
|
530
|
+
case 'page':
|
|
531
|
+
return function () { return (0, exports.wrapPage)(target.page(), controller); };
|
|
532
|
+
case 'parentFrame':
|
|
533
|
+
return function () {
|
|
534
|
+
var parentFrame = target.parentFrame();
|
|
535
|
+
if (!parentFrame) {
|
|
536
|
+
return null;
|
|
537
|
+
}
|
|
538
|
+
return (0, exports.wrapFrame)(parentFrame, controller);
|
|
539
|
+
};
|
|
540
|
+
default:
|
|
541
|
+
return Reflect.get(target, prop, receiver);
|
|
542
|
+
}
|
|
543
|
+
}
|
|
544
|
+
});
|
|
545
|
+
(0, exports.markAsWrapped)(frameProxy);
|
|
546
|
+
return frameProxy;
|
|
547
|
+
};
|
|
548
|
+
exports.wrapFrame = wrapFrame;
|
|
549
|
+
var wrapFrameLocator = function (frameLocator, controller) {
|
|
550
|
+
if ((0, exports.isWrapped)(frameLocator)) {
|
|
551
|
+
return frameLocator;
|
|
552
|
+
}
|
|
553
|
+
var frameLocatorProxy = new Proxy(frameLocator, {
|
|
554
|
+
get: function (target, prop, receiver) {
|
|
555
|
+
switch (prop) {
|
|
556
|
+
case 'first':
|
|
557
|
+
case 'frameLocator':
|
|
558
|
+
case 'last':
|
|
559
|
+
case 'nth':
|
|
560
|
+
return function () {
|
|
561
|
+
var args = [];
|
|
562
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
563
|
+
args[_i] = arguments[_i];
|
|
564
|
+
}
|
|
565
|
+
// @ts-expect-error TypeScript is angry.
|
|
566
|
+
var frame = target[prop].apply(target, args);
|
|
567
|
+
if (!frame) {
|
|
568
|
+
return null;
|
|
569
|
+
}
|
|
570
|
+
return (0, exports.wrapFrameLocator)(frame, controller);
|
|
571
|
+
};
|
|
572
|
+
case 'locator':
|
|
573
|
+
case 'getByAltText':
|
|
574
|
+
case 'getByLabel':
|
|
575
|
+
case 'getByPlaceholder':
|
|
576
|
+
case 'getByRole':
|
|
577
|
+
case 'getByTestId':
|
|
578
|
+
case 'getByText':
|
|
579
|
+
case 'getByTitle':
|
|
580
|
+
return function () {
|
|
581
|
+
var args = [];
|
|
582
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
583
|
+
args[_i] = arguments[_i];
|
|
584
|
+
}
|
|
585
|
+
// @ts-expect-error TypeScript is angry.
|
|
586
|
+
var el = target[prop].apply(target, args);
|
|
587
|
+
return (0, exports.wrapLocator)(el, controller);
|
|
588
|
+
};
|
|
589
|
+
default:
|
|
590
|
+
return Reflect.get(target, prop, receiver);
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
});
|
|
594
|
+
(0, exports.markAsWrapped)(frameLocatorProxy);
|
|
595
|
+
return frameLocatorProxy;
|
|
596
|
+
};
|
|
597
|
+
exports.wrapFrameLocator = wrapFrameLocator;
|
|
598
|
+
var wrapLocator = function (locator, controller) {
|
|
599
|
+
if ((0, exports.isWrapped)(locator)) {
|
|
600
|
+
return locator;
|
|
601
|
+
}
|
|
602
|
+
var locatorProxy = new Proxy(locator, {
|
|
603
|
+
get: function (target, prop, receiver) {
|
|
604
|
+
var _this = this;
|
|
605
|
+
switch (prop) {
|
|
606
|
+
case 'all':
|
|
607
|
+
return function () {
|
|
608
|
+
var args = [];
|
|
609
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
610
|
+
args[_i] = arguments[_i];
|
|
611
|
+
}
|
|
612
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
613
|
+
var els;
|
|
614
|
+
return __generator(this, function (_a) {
|
|
615
|
+
switch (_a.label) {
|
|
616
|
+
case 0: return [4 /*yield*/, target.all.apply(target, args)];
|
|
617
|
+
case 1:
|
|
618
|
+
els = _a.sent();
|
|
619
|
+
return [2 /*return*/, els.map(function (e) { return (0, exports.wrapLocator)(e, controller); })];
|
|
620
|
+
}
|
|
621
|
+
});
|
|
622
|
+
});
|
|
623
|
+
};
|
|
624
|
+
case 'blur':
|
|
625
|
+
case 'check':
|
|
626
|
+
case 'click':
|
|
627
|
+
case 'dblclick':
|
|
628
|
+
case 'focus':
|
|
629
|
+
case 'hover':
|
|
630
|
+
case 'press':
|
|
631
|
+
case 'tap':
|
|
632
|
+
case 'type':
|
|
633
|
+
case 'dispatchEvent':
|
|
634
|
+
case 'dragTo':
|
|
635
|
+
case 'fill':
|
|
636
|
+
case 'scrollIntoViewIfNeeded':
|
|
637
|
+
case 'setChecked':
|
|
638
|
+
case 'selectOption':
|
|
639
|
+
case 'selectText':
|
|
640
|
+
case 'setInputFiles':
|
|
641
|
+
case 'clear':
|
|
642
|
+
case 'uncheck':
|
|
643
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
644
|
+
case 'elementHandle':
|
|
645
|
+
return function () { return __awaiter(_this, void 0, void 0, function () {
|
|
646
|
+
var el;
|
|
647
|
+
return __generator(this, function (_a) {
|
|
648
|
+
switch (_a.label) {
|
|
649
|
+
case 0: return [4 /*yield*/, target.elementHandle()];
|
|
650
|
+
case 1:
|
|
651
|
+
el = _a.sent();
|
|
652
|
+
if (!el) {
|
|
653
|
+
return [2 /*return*/, null];
|
|
654
|
+
}
|
|
655
|
+
return [2 /*return*/, (0, exports.wrapElementHandle)(el, controller)];
|
|
656
|
+
}
|
|
657
|
+
});
|
|
658
|
+
}); };
|
|
659
|
+
case 'elementHandles':
|
|
660
|
+
return function () { return __awaiter(_this, void 0, void 0, function () {
|
|
661
|
+
var els;
|
|
662
|
+
return __generator(this, function (_a) {
|
|
663
|
+
switch (_a.label) {
|
|
664
|
+
case 0: return [4 /*yield*/, target.elementHandles()];
|
|
665
|
+
case 1:
|
|
666
|
+
els = _a.sent();
|
|
667
|
+
return [2 /*return*/, els.map(function (e) { return (0, exports.wrapElementHandle)(e, controller); })];
|
|
668
|
+
}
|
|
669
|
+
});
|
|
670
|
+
}); };
|
|
671
|
+
case 'evaluateHandle':
|
|
672
|
+
return function () {
|
|
673
|
+
var args = [];
|
|
674
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
675
|
+
args[_i] = arguments[_i];
|
|
676
|
+
}
|
|
677
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
678
|
+
var handle;
|
|
679
|
+
return __generator(this, function (_a) {
|
|
680
|
+
switch (_a.label) {
|
|
681
|
+
case 0: return [4 /*yield*/, target.evaluateHandle.apply(target, args)];
|
|
682
|
+
case 1:
|
|
683
|
+
handle = _a.sent();
|
|
684
|
+
return [2 /*return*/, (0, exports.wrapJSHandle)(handle, controller)];
|
|
685
|
+
}
|
|
686
|
+
});
|
|
687
|
+
});
|
|
688
|
+
};
|
|
689
|
+
case 'filter':
|
|
690
|
+
case 'first':
|
|
691
|
+
case 'last':
|
|
692
|
+
case 'nth':
|
|
693
|
+
case 'locator':
|
|
694
|
+
case 'getByAltText':
|
|
695
|
+
case 'getByLabel':
|
|
696
|
+
case 'getByPlaceholder':
|
|
697
|
+
case 'getByRole':
|
|
698
|
+
case 'getByTestId':
|
|
699
|
+
case 'getByText':
|
|
700
|
+
case 'getByTitle':
|
|
701
|
+
return function () {
|
|
702
|
+
var args = [];
|
|
703
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
704
|
+
args[_i] = arguments[_i];
|
|
705
|
+
}
|
|
706
|
+
// @ts-expect-error TypeScript doesn't like this.
|
|
707
|
+
var el = target[prop].apply(target, args);
|
|
708
|
+
return (0, exports.wrapLocator)(el, controller);
|
|
709
|
+
};
|
|
710
|
+
case 'frameLocator':
|
|
711
|
+
return function () {
|
|
712
|
+
var args = [];
|
|
713
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
714
|
+
args[_i] = arguments[_i];
|
|
715
|
+
}
|
|
716
|
+
// @ts-expect-error TypeScript doesn't like this.
|
|
717
|
+
var frame = target[prop].apply(target, args);
|
|
718
|
+
return (0, exports.wrapFrameLocator)(frame, controller);
|
|
719
|
+
};
|
|
720
|
+
case 'page':
|
|
721
|
+
return function () {
|
|
722
|
+
var page = target[prop]();
|
|
723
|
+
return (0, exports.wrapPage)(page, controller);
|
|
724
|
+
};
|
|
725
|
+
default:
|
|
726
|
+
return Reflect.get(target, prop, receiver);
|
|
727
|
+
}
|
|
728
|
+
}
|
|
729
|
+
});
|
|
730
|
+
(0, exports.markAsWrapped)(locatorProxy);
|
|
731
|
+
return locatorProxy;
|
|
732
|
+
};
|
|
733
|
+
exports.wrapLocator = wrapLocator;
|
|
734
|
+
var wrapJSHandle = function (jsHandle, controller) {
|
|
735
|
+
if ((0, exports.isWrapped)(jsHandle)) {
|
|
736
|
+
return jsHandle;
|
|
737
|
+
}
|
|
738
|
+
var jsHandleProxy = new Proxy(jsHandle, {
|
|
739
|
+
get: function (target, prop, receiver) {
|
|
740
|
+
var _this = this;
|
|
741
|
+
switch (prop) {
|
|
742
|
+
case 'asElement':
|
|
743
|
+
return function () {
|
|
744
|
+
var el = target.asElement();
|
|
745
|
+
if (!el) {
|
|
746
|
+
return null;
|
|
747
|
+
}
|
|
748
|
+
return (0, exports.wrapElementHandle)(el, controller);
|
|
749
|
+
};
|
|
750
|
+
case 'evaluateHandle':
|
|
751
|
+
return function () {
|
|
752
|
+
var args = [];
|
|
753
|
+
for (var _i = 0; _i < arguments.length; _i++) {
|
|
754
|
+
args[_i] = arguments[_i];
|
|
755
|
+
}
|
|
756
|
+
return __awaiter(_this, void 0, void 0, function () {
|
|
757
|
+
var handle;
|
|
758
|
+
return __generator(this, function (_a) {
|
|
759
|
+
switch (_a.label) {
|
|
760
|
+
case 0: return [4 /*yield*/, target.evaluateHandle.apply(target, args)];
|
|
761
|
+
case 1:
|
|
762
|
+
handle = _a.sent();
|
|
763
|
+
return [2 /*return*/, (0, exports.wrapJSHandle)(handle, controller)];
|
|
764
|
+
}
|
|
765
|
+
});
|
|
766
|
+
});
|
|
767
|
+
};
|
|
768
|
+
default:
|
|
769
|
+
return Reflect.get(target, prop, receiver);
|
|
770
|
+
}
|
|
771
|
+
}
|
|
772
|
+
});
|
|
773
|
+
(0, exports.markAsWrapped)(jsHandleProxy);
|
|
774
|
+
return jsHandleProxy;
|
|
775
|
+
};
|
|
776
|
+
exports.wrapJSHandle = wrapJSHandle;
|
|
777
|
+
var wrapKeyboard = function (keyboard, controller) {
|
|
778
|
+
if ((0, exports.isWrapped)(keyboard)) {
|
|
779
|
+
return keyboard;
|
|
780
|
+
}
|
|
781
|
+
var keyboardProxy = new Proxy(keyboard, {
|
|
782
|
+
get: function (target, prop, receiver) {
|
|
783
|
+
switch (prop) {
|
|
784
|
+
case 'down':
|
|
785
|
+
case 'press':
|
|
786
|
+
case 'insertText':
|
|
787
|
+
case 'type':
|
|
788
|
+
case 'up':
|
|
789
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
790
|
+
default:
|
|
791
|
+
return Reflect.get(target, prop, receiver);
|
|
792
|
+
}
|
|
793
|
+
}
|
|
794
|
+
});
|
|
795
|
+
(0, exports.markAsWrapped)(keyboardProxy);
|
|
796
|
+
return keyboardProxy;
|
|
797
|
+
};
|
|
798
|
+
exports.wrapKeyboard = wrapKeyboard;
|
|
799
|
+
var wrapMouse = function (mouse, controller) {
|
|
800
|
+
if ((0, exports.isWrapped)(mouse)) {
|
|
801
|
+
return mouse;
|
|
802
|
+
}
|
|
803
|
+
var mouseProxy = new Proxy(mouse, {
|
|
804
|
+
get: function (target, prop, receiver) {
|
|
805
|
+
switch (prop) {
|
|
806
|
+
case 'click':
|
|
807
|
+
case 'dblclick':
|
|
808
|
+
case 'down':
|
|
809
|
+
case 'move':
|
|
810
|
+
case 'up':
|
|
811
|
+
case 'wheel':
|
|
812
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
813
|
+
default:
|
|
814
|
+
return Reflect.get(target, prop, receiver);
|
|
815
|
+
}
|
|
816
|
+
}
|
|
817
|
+
});
|
|
818
|
+
(0, exports.markAsWrapped)(mouseProxy);
|
|
819
|
+
return mouseProxy;
|
|
820
|
+
};
|
|
821
|
+
exports.wrapMouse = wrapMouse;
|
|
822
|
+
var wrapTouchscreen = function (touchscreen, controller) {
|
|
823
|
+
if ((0, exports.isWrapped)(touchscreen)) {
|
|
824
|
+
return touchscreen;
|
|
825
|
+
}
|
|
826
|
+
var touchscreenProxy = new Proxy(touchscreen, {
|
|
827
|
+
get: function (target, prop, receiver) {
|
|
828
|
+
switch (prop) {
|
|
829
|
+
case 'tap':
|
|
830
|
+
return wrappedCallWithSideEffects(target, prop, controller);
|
|
831
|
+
default:
|
|
832
|
+
return Reflect.get(target, prop, receiver);
|
|
833
|
+
}
|
|
834
|
+
}
|
|
835
|
+
});
|
|
836
|
+
(0, exports.markAsWrapped)(touchscreenProxy);
|
|
837
|
+
return touchscreenProxy;
|
|
838
|
+
};
|
|
839
|
+
exports.wrapTouchscreen = wrapTouchscreen;
|
|
840
|
+
//# sourceMappingURL=playwrightWrapping.js.map
|