1#![allow(clippy::all, missing_docs, unused_imports)]
5
6use serde::{Deserialize, Serialize};
7
8use super::*;
9use crate::playwright::connection::{
10 Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
11};
12
13#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
15pub struct PageFrameDetachedEventParams {
16 #[serde(rename = "frame")]
17 pub frame: Ref<Frame>,
18}
19
20#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
22pub struct PageLocatorHandlerTriggeredEventParams {
23 #[serde(rename = "uid")]
24 pub uid: i64,
25}
26
27#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
29pub struct PageRouteEventParams {
30 #[serde(rename = "route")]
31 pub route: Ref<Route>,
32}
33
34#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
36pub struct PageScreencastFrameEventParams {
37 #[serde(rename = "frameId")]
38 pub frame_id: i64,
39 #[serde(rename = "data")]
40 pub data: Binary,
41 #[serde(rename = "timestamp")]
42 pub timestamp: f64,
43 #[serde(rename = "viewportWidth")]
44 pub viewport_width: i64,
45 #[serde(rename = "viewportHeight")]
46 pub viewport_height: i64,
47}
48
49#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
51pub struct PageWebSocketRouteEventParams {
52 #[serde(rename = "webSocketRoute")]
53 pub web_socket_route: Ref<WebSocketRoute>,
54}
55
56#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
58pub struct PageWebSocketEventParams {
59 #[serde(rename = "webSocket")]
60 pub web_socket: Ref<WebSocket>,
61}
62
63#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
65pub struct PageWorkerEventParams {
66 #[serde(rename = "worker")]
67 pub worker: Ref<Worker>,
68}
69
70#[derive(Debug, Clone, PartialEq)]
72pub enum PageEvent {
73 BindingCall(PageBindingCallEventParams),
75 Close,
77 Crash,
79 Download(PageDownloadEventParams),
81 ViewportSizeChanged(PageViewportSizeChangedEventParams),
83 FileChooser(PageFileChooserEventParams),
85 FrameAttached(PageFrameAttachedEventParams),
87 FrameDetached(PageFrameDetachedEventParams),
89 LocatorHandlerTriggered(PageLocatorHandlerTriggeredEventParams),
91 Route(PageRouteEventParams),
93 ScreencastFrame(PageScreencastFrameEventParams),
95 WebSocketRoute(PageWebSocketRouteEventParams),
97 WebSocket(PageWebSocketEventParams),
99 Worker(PageWorkerEventParams),
101 Unknown {
103 method: String,
105 params: serde_json::Value,
107 },
108}
109
110impl ProtocolEvent for PageEvent {
111 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
112 match method {
113 "bindingCall" => Ok(Self::BindingCall(serde_json::from_value(params)?)),
114 "close" => Ok(Self::Close),
115 "crash" => Ok(Self::Crash),
116 "download" => Ok(Self::Download(serde_json::from_value(params)?)),
117 "viewportSizeChanged" => Ok(Self::ViewportSizeChanged(serde_json::from_value(params)?)),
118 "fileChooser" => Ok(Self::FileChooser(serde_json::from_value(params)?)),
119 "frameAttached" => Ok(Self::FrameAttached(serde_json::from_value(params)?)),
120 "frameDetached" => Ok(Self::FrameDetached(serde_json::from_value(params)?)),
121 "locatorHandlerTriggered" => Ok(Self::LocatorHandlerTriggered(serde_json::from_value(params)?)),
122 "route" => Ok(Self::Route(serde_json::from_value(params)?)),
123 "screencastFrame" => Ok(Self::ScreencastFrame(serde_json::from_value(params)?)),
124 "webSocketRoute" => Ok(Self::WebSocketRoute(serde_json::from_value(params)?)),
125 "webSocket" => Ok(Self::WebSocket(serde_json::from_value(params)?)),
126 "worker" => Ok(Self::Worker(serde_json::from_value(params)?)),
127 _ => Ok(Self::Unknown { method: method.to_string(), params }),
128 }
129 }
130}
131
132#[derive(Debug, Clone)]
134pub struct Page {
135 channel: Channel,
136}
137
138impl ChannelType for Page {
139 const INTERFACE: &'static str = "Page";
140 type Initializer = PageInitializer;
141 type Event = PageEvent;
142
143 fn accepts(interface: &str) -> bool {
144 matches!(interface, "Page")
145 }
146
147 fn from_channel(channel: Channel) -> Self {
148 Self { channel }
149 }
150
151 fn channel(&self) -> &Channel {
152 &self.channel
153 }
154}
155
156impl Page {
157 pub async fn add_init_script(&self, params: PageAddInitScriptParams) -> Result<PageAddInitScriptResult, ProtocolError> {
159 self.channel.send("addInitScript", ¶ms).await
160 }
161
162 pub async fn close(&self, params: PageCloseParams) -> Result<(), ProtocolError> {
164 self.channel.send_no_result("close", ¶ms).await
165 }
166
167 pub async fn run_before_unload(&self) -> Result<(), ProtocolError> {
169 self.channel.send_no_result("runBeforeUnload", &serde_json::json!({})).await
170 }
171
172 pub async fn clear_console_messages(&self) -> Result<(), ProtocolError> {
174 self.channel.send_no_result("clearConsoleMessages", &serde_json::json!({})).await
175 }
176
177 pub async fn console_messages(&self, params: PageConsoleMessagesParams) -> Result<PageConsoleMessagesResult, ProtocolError> {
179 self.channel.send("consoleMessages", ¶ms).await
180 }
181
182 pub async fn emulate_media(&self, params: PageEmulateMediaParams) -> Result<(), ProtocolError> {
184 self.channel.send_no_result("emulateMedia", ¶ms).await
185 }
186
187 pub async fn expose_binding(&self, params: PageExposeBindingParams) -> Result<PageExposeBindingResult, ProtocolError> {
189 self.channel.send("exposeBinding", ¶ms).await
190 }
191
192 pub async fn go_back(&self, params: PageGoBackParams) -> Result<PageGoBackResult, ProtocolError> {
194 self.channel.send("goBack", ¶ms).await
195 }
196
197 pub async fn go_forward(&self, params: PageGoForwardParams) -> Result<PageGoForwardResult, ProtocolError> {
199 self.channel.send("goForward", ¶ms).await
200 }
201
202 pub async fn request_gc(&self) -> Result<(), ProtocolError> {
204 self.channel.send_no_result("requestGC", &serde_json::json!({})).await
205 }
206
207 pub async fn register_locator_handler(&self, params: PageRegisterLocatorHandlerParams) -> Result<PageRegisterLocatorHandlerResult, ProtocolError> {
209 self.channel.send("registerLocatorHandler", ¶ms).await
210 }
211
212 pub async fn resolve_locator_handler_no_reply(&self, params: PageResolveLocatorHandlerNoReplyParams) -> Result<(), ProtocolError> {
214 self.channel.send_no_result("resolveLocatorHandlerNoReply", ¶ms).await
215 }
216
217 pub async fn unregister_locator_handler(&self, params: PageUnregisterLocatorHandlerParams) -> Result<(), ProtocolError> {
219 self.channel.send_no_result("unregisterLocatorHandler", ¶ms).await
220 }
221
222 pub async fn reload(&self, params: PageReloadParams) -> Result<PageReloadResult, ProtocolError> {
224 self.channel.send("reload", ¶ms).await
225 }
226
227 pub async fn expect_screenshot(&self, params: PageExpectScreenshotParams) -> Result<PageExpectScreenshotResult, ProtocolError> {
229 self.channel.send("expectScreenshot", ¶ms).await
230 }
231
232 pub async fn screenshot(&self, params: PageScreenshotParams) -> Result<PageScreenshotResult, ProtocolError> {
234 self.channel.send("screenshot", ¶ms).await
235 }
236
237 pub async fn set_extra_http_headers(&self, params: PageSetExtraHTTPHeadersParams) -> Result<(), ProtocolError> {
239 self.channel.send_no_result("setExtraHTTPHeaders", ¶ms).await
240 }
241
242 pub async fn set_network_interception_patterns(&self, params: PageSetNetworkInterceptionPatternsParams) -> Result<(), ProtocolError> {
244 self.channel.send_no_result("setNetworkInterceptionPatterns", ¶ms).await
245 }
246
247 pub async fn set_web_socket_interception_patterns(&self, params: PageSetWebSocketInterceptionPatternsParams) -> Result<(), ProtocolError> {
249 self.channel.send_no_result("setWebSocketInterceptionPatterns", ¶ms).await
250 }
251
252 pub async fn set_viewport_size(&self, params: PageSetViewportSizeParams) -> Result<(), ProtocolError> {
254 self.channel.send_no_result("setViewportSize", ¶ms).await
255 }
256
257 pub async fn keyboard_down(&self, params: PageKeyboardDownParams) -> Result<(), ProtocolError> {
259 self.channel.send_no_result("keyboardDown", ¶ms).await
260 }
261
262 pub async fn keyboard_up(&self, params: PageKeyboardUpParams) -> Result<(), ProtocolError> {
264 self.channel.send_no_result("keyboardUp", ¶ms).await
265 }
266
267 pub async fn keyboard_insert_text(&self, params: PageKeyboardInsertTextParams) -> Result<(), ProtocolError> {
269 self.channel.send_no_result("keyboardInsertText", ¶ms).await
270 }
271
272 pub async fn keyboard_type(&self, params: PageKeyboardTypeParams) -> Result<(), ProtocolError> {
274 self.channel.send_no_result("keyboardType", ¶ms).await
275 }
276
277 pub async fn keyboard_press(&self, params: PageKeyboardPressParams) -> Result<(), ProtocolError> {
279 self.channel.send_no_result("keyboardPress", ¶ms).await
280 }
281
282 pub async fn mouse_move(&self, params: PageMouseMoveParams) -> Result<(), ProtocolError> {
284 self.channel.send_no_result("mouseMove", ¶ms).await
285 }
286
287 pub async fn mouse_down(&self, params: PageMouseDownParams) -> Result<(), ProtocolError> {
289 self.channel.send_no_result("mouseDown", ¶ms).await
290 }
291
292 pub async fn mouse_up(&self, params: PageMouseUpParams) -> Result<(), ProtocolError> {
294 self.channel.send_no_result("mouseUp", ¶ms).await
295 }
296
297 pub async fn mouse_click(&self, params: PageMouseClickParams) -> Result<(), ProtocolError> {
299 self.channel.send_no_result("mouseClick", ¶ms).await
300 }
301
302 pub async fn mouse_wheel(&self, params: PageMouseWheelParams) -> Result<(), ProtocolError> {
304 self.channel.send_no_result("mouseWheel", ¶ms).await
305 }
306
307 pub async fn touchscreen_tap(&self, params: PageTouchscreenTapParams) -> Result<(), ProtocolError> {
309 self.channel.send_no_result("touchscreenTap", ¶ms).await
310 }
311
312 pub async fn clear_page_errors(&self) -> Result<(), ProtocolError> {
314 self.channel.send_no_result("clearPageErrors", &serde_json::json!({})).await
315 }
316
317 pub async fn page_errors(&self, params: PagePageErrorsParams) -> Result<PagePageErrorsResult, ProtocolError> {
319 self.channel.send("pageErrors", ¶ms).await
320 }
321
322 pub async fn pdf(&self, params: PagePdfParams) -> Result<PagePdfResult, ProtocolError> {
324 self.channel.send("pdf", ¶ms).await
325 }
326
327 pub async fn requests(&self) -> Result<PageRequestsResult, ProtocolError> {
329 self.channel.send("requests", &serde_json::json!({})).await
330 }
331
332 pub async fn start_js_coverage(&self, params: PageStartJSCoverageParams) -> Result<(), ProtocolError> {
334 self.channel.send_no_result("startJSCoverage", ¶ms).await
335 }
336
337 pub async fn stop_js_coverage(&self) -> Result<PageStopJSCoverageResult, ProtocolError> {
339 self.channel.send("stopJSCoverage", &serde_json::json!({})).await
340 }
341
342 pub async fn start_css_coverage(&self, params: PageStartCSSCoverageParams) -> Result<(), ProtocolError> {
344 self.channel.send_no_result("startCSSCoverage", ¶ms).await
345 }
346
347 pub async fn stop_css_coverage(&self) -> Result<PageStopCSSCoverageResult, ProtocolError> {
349 self.channel.send("stopCSSCoverage", &serde_json::json!({})).await
350 }
351
352 pub async fn bring_to_front(&self) -> Result<(), ProtocolError> {
354 self.channel.send_no_result("bringToFront", &serde_json::json!({})).await
355 }
356
357 pub async fn pick_locator(&self) -> Result<PagePickLocatorResult, ProtocolError> {
359 self.channel.send("pickLocator", &serde_json::json!({})).await
360 }
361
362 pub async fn cancel_pick_locator(&self) -> Result<(), ProtocolError> {
364 self.channel.send_no_result("cancelPickLocator", &serde_json::json!({})).await
365 }
366
367 pub async fn hide_highlight(&self) -> Result<(), ProtocolError> {
369 self.channel.send_no_result("hideHighlight", &serde_json::json!({})).await
370 }
371
372 pub async fn screencast_show_overlay(&self, params: PageScreencastShowOverlayParams) -> Result<PageScreencastShowOverlayResult, ProtocolError> {
374 self.channel.send("screencastShowOverlay", ¶ms).await
375 }
376
377 pub async fn screencast_remove_overlay(&self, params: PageScreencastRemoveOverlayParams) -> Result<(), ProtocolError> {
379 self.channel.send_no_result("screencastRemoveOverlay", ¶ms).await
380 }
381
382 pub async fn screencast_chapter(&self, params: PageScreencastChapterParams) -> Result<(), ProtocolError> {
384 self.channel.send_no_result("screencastChapter", ¶ms).await
385 }
386
387 pub async fn screencast_set_overlay_visible(&self, params: PageScreencastSetOverlayVisibleParams) -> Result<(), ProtocolError> {
389 self.channel.send_no_result("screencastSetOverlayVisible", ¶ms).await
390 }
391
392 pub async fn screencast_show_actions(&self, params: PageScreencastShowActionsParams) -> Result<(), ProtocolError> {
394 self.channel.send_no_result("screencastShowActions", ¶ms).await
395 }
396
397 pub async fn screencast_hide_actions(&self) -> Result<(), ProtocolError> {
399 self.channel.send_no_result("screencastHideActions", &serde_json::json!({})).await
400 }
401
402 pub async fn screencast_start(&self, params: PageScreencastStartParams) -> Result<PageScreencastStartResult, ProtocolError> {
404 self.channel.send("screencastStart", ¶ms).await
405 }
406
407 pub async fn screencast_frame_ack(&self, params: PageScreencastFrameAckParams) -> Result<(), ProtocolError> {
409 self.channel.send_no_result("screencastFrameAck", ¶ms).await
410 }
411
412 pub async fn screencast_stop(&self) -> Result<(), ProtocolError> {
414 self.channel.send_no_result("screencastStop", &serde_json::json!({})).await
415 }
416
417 pub async fn update_subscription(&self, params: PageUpdateSubscriptionParams) -> Result<(), ProtocolError> {
419 self.channel.send_no_result("updateSubscription", ¶ms).await
420 }
421
422 pub async fn set_dock_tile(&self, params: PageSetDockTileParams) -> Result<(), ProtocolError> {
424 self.channel.send_no_result("setDockTile", ¶ms).await
425 }
426
427 pub async fn web_storage_items(&self, params: PageWebStorageItemsParams) -> Result<PageWebStorageItemsResult, ProtocolError> {
429 self.channel.send("webStorageItems", ¶ms).await
430 }
431
432 pub async fn web_storage_get_item(&self, params: PageWebStorageGetItemParams) -> Result<PageWebStorageGetItemResult, ProtocolError> {
434 self.channel.send("webStorageGetItem", ¶ms).await
435 }
436
437 pub async fn web_storage_set_item(&self, params: PageWebStorageSetItemParams) -> Result<(), ProtocolError> {
439 self.channel.send_no_result("webStorageSetItem", ¶ms).await
440 }
441
442 pub async fn web_storage_remove_item(&self, params: PageWebStorageRemoveItemParams) -> Result<(), ProtocolError> {
444 self.channel.send_no_result("webStorageRemoveItem", ¶ms).await
445 }
446
447 pub async fn web_storage_clear(&self, params: PageWebStorageClearParams) -> Result<(), ProtocolError> {
449 self.channel.send_no_result("webStorageClear", ¶ms).await
450 }
451}