browser_commander/playwright/protocol/
electron_application.rs1#![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 ElectronApplicationInitializer {
16 #[serde(rename = "context")]
17 pub context: Ref<BrowserContext>,
18}
19
20#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
22pub struct ElectronApplicationBrowserWindowParams {
23 #[serde(rename = "page")]
24 pub page: Ref<Page>,
25}
26
27#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
29pub struct ElectronApplicationBrowserWindowResult {
30 #[serde(rename = "handle")]
31 pub handle: Ref<JSHandle>,
32}
33
34#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
36pub struct ElectronApplicationEvaluateExpressionParams {
37 #[serde(rename = "expression")]
38 pub expression: String,
39 #[serde(rename = "isFunction", default, skip_serializing_if = "Option::is_none")]
40 pub is_function: Option<bool>,
41 #[serde(rename = "arg")]
42 pub arg: SerializedArgument,
43}
44
45#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
47pub struct ElectronApplicationEvaluateExpressionResult {
48 #[serde(rename = "value")]
49 pub value: SerializedValue,
50}
51
52#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
54pub struct ElectronApplicationEvaluateExpressionHandleParams {
55 #[serde(rename = "expression")]
56 pub expression: String,
57 #[serde(rename = "isFunction", default, skip_serializing_if = "Option::is_none")]
58 pub is_function: Option<bool>,
59 #[serde(rename = "arg")]
60 pub arg: SerializedArgument,
61}
62
63#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
65pub struct ElectronApplicationEvaluateExpressionHandleResult {
66 #[serde(rename = "handle")]
67 pub handle: Ref<JSHandle>,
68}
69
70#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
71pub enum ElectronApplicationUpdateSubscriptionParamsEvent {
72 #[default]
73 #[serde(rename = "console")]
74 Console,
75}
76
77#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
79pub struct ElectronApplicationUpdateSubscriptionParams {
80 #[serde(rename = "event")]
81 pub event: ElectronApplicationUpdateSubscriptionParamsEvent,
82 #[serde(rename = "enabled")]
83 pub enabled: bool,
84}
85
86#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
88pub struct ElectronApplicationConsoleEventParams {
89 #[serde(flatten)]
91 pub console_message: ConsoleMessage,
92}
93
94#[derive(Debug, Clone, PartialEq)]
96pub enum ElectronApplicationEvent {
97 Close,
99 Console(ElectronApplicationConsoleEventParams),
101 Unknown {
103 method: String,
105 params: serde_json::Value,
107 },
108}
109
110impl ProtocolEvent for ElectronApplicationEvent {
111 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
112 match method {
113 "close" => Ok(Self::Close),
114 "console" => Ok(Self::Console(serde_json::from_value(params)?)),
115 _ => Ok(Self::Unknown { method: method.to_string(), params }),
116 }
117 }
118}
119
120#[derive(Debug, Clone)]
122pub struct ElectronApplication {
123 channel: Channel,
124}
125
126impl ChannelType for ElectronApplication {
127 const INTERFACE: &'static str = "ElectronApplication";
128 type Initializer = ElectronApplicationInitializer;
129 type Event = ElectronApplicationEvent;
130
131 fn accepts(interface: &str) -> bool {
132 matches!(interface, "ElectronApplication")
133 }
134
135 fn from_channel(channel: Channel) -> Self {
136 Self { channel }
137 }
138
139 fn channel(&self) -> &Channel {
140 &self.channel
141 }
142}
143
144impl ElectronApplication {
145 pub async fn browser_window(&self, params: ElectronApplicationBrowserWindowParams) -> Result<ElectronApplicationBrowserWindowResult, ProtocolError> {
147 self.channel.send("browserWindow", ¶ms).await
148 }
149
150 pub async fn evaluate_expression(&self, params: ElectronApplicationEvaluateExpressionParams) -> Result<ElectronApplicationEvaluateExpressionResult, ProtocolError> {
152 self.channel.send("evaluateExpression", ¶ms).await
153 }
154
155 pub async fn evaluate_expression_handle(&self, params: ElectronApplicationEvaluateExpressionHandleParams) -> Result<ElectronApplicationEvaluateExpressionHandleResult, ProtocolError> {
157 self.channel.send("evaluateExpressionHandle", ¶ms).await
158 }
159
160 pub async fn update_subscription(&self, params: ElectronApplicationUpdateSubscriptionParams) -> Result<(), ProtocolError> {
162 self.channel.send_no_result("updateSubscription", ¶ms).await
163 }
164}