eoka 0.6.0

Stealth browser automation for Rust. Puppeteer/Playwright alternative with anti-bot bypass.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use tokio::sync::OwnedMutexGuard;

use super::{dispatch_coordinated_mouse_event, input_state_error, HeldInputState};
use crate::cdp::{MouseEventType, Session};
use crate::error::Result;
use crate::page::MouseButton;

pub(crate) struct DragInput {
    session: Session,
    state: OwnedMutexGuard<HeldInputState>,
}

impl DragInput {
    pub(crate) async fn acquire(session: &Session) -> Result<Self> {
        let state = session.held_input().lock_owned().await;
        if state.mouse_buttons.contains_key(&MouseButton::Left) {
            return Err(input_state_error("mouse button is already held"));
        }
        Ok(Self {
            session: session.clone(),
            state,
        })
    }

    pub(crate) async fn move_to(&mut self, x: f64, y: f64) -> Result<()> {
        dispatch_coordinated_mouse_event(
            &self.session,
            MouseEventType::MouseMoved,
            x,
            y,
            None,
            None,
            self.state.mouse_button_mask(),
        )
        .await?;
        for position in self.state.mouse_buttons.values_mut() {
            *position = (x, y);
        }
        Ok(())
    }

    pub(crate) async fn press(&mut self, x: f64, y: f64) -> Result<()> {
        let buttons = self
            .state
            .reserve_mouse_down(MouseButton::Left, (x, y))
            .map_err(input_state_error)?;
        dispatch_coordinated_mouse_event(
            &self.session,
            MouseEventType::MousePressed,
            x,
            y,
            Some(MouseButton::Left),
            Some(1),
            buttons,
        )
        .await
    }

    pub(crate) async fn release(&mut self, x: f64, y: f64) -> Result<()> {
        let buttons = self
            .state
            .mouse_up_mask(MouseButton::Left)
            .map_err(input_state_error)?;
        let result = dispatch_coordinated_mouse_event(
            &self.session,
            MouseEventType::MouseReleased,
            x,
            y,
            Some(MouseButton::Left),
            Some(1),
            buttons,
        )
        .await;
        self.state.finish_mouse_up(MouseButton::Left);
        result
    }
}