deno_ipcs 0.2.0

ipcs implementation for Deno
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.


use deno_core::error::AnyError;

use deno_core::{op2};

use deno_core::OpState;

use events_manager::EventsManager;
use messages::{SentToWindowMessage,IpcMessage};
use serde::Deserialize;
use serde::Serialize;
use uuid::Uuid;
use std::cell::RefCell;

use std::rc::Rc;

use tokio::sync::mpsc::{self};



pub mod messages;
pub mod events_manager;



pub type IpcSender = async_channel::Sender<IpcMessage>;
pub type IpcReceiver = async_channel::Receiver<IpcMessage>;

deno_core::extension!(
  deno_ipcs,
  ops = [
    listen_event,
    send_to_host
  ],
   esm_entry_point = "ext:deno_ipcs/01_ipcs.js",
    esm  = [ "01_ipcs.js"],
    options = {
        sender:IpcSender,
        events_manager:EventsManager
    },
    state = |state, options| {
        state.put(options.sender);
        state.put(options.events_manager);

  },
);
#[derive(Serialize, Deserialize, Debug)]
struct EventListen {
    name: String,
}

#[op2(async)]
#[serde]
async fn listen_event(
    state: Rc<RefCell<OpState>>,
    #[serde]  event: EventListen
) -> Result<serde_json::Value, AnyError> {
    let (listener, mut receiver) = mpsc::channel(1);
    let listener_id = Uuid::new_v4();

    let events_manager: EventsManager = {
        let state: std::cell::Ref<'_, OpState> = state.try_borrow()?;

        state.try_borrow::<EventsManager>().unwrap().clone()
    };
    events_manager
        .listen_on(event.name.clone(), listener_id, listener)
        .await;
    let event_response = receiver.recv().await;

    events_manager.unlisten_from(event.name, listener_id).await;
    Ok(event_response.unwrap())
}
#[op2(async)]
async fn send_to_host(
    state: Rc<RefCell<OpState>>,
    #[serde] args: SentToWindowMessage,
) -> Result<(), AnyError> {
    let sender: IpcSender = {
        let state = state.try_borrow()?;
        state
            .try_borrow::<IpcSender>()
            .unwrap()
            .clone()
    };

    sender
        .send(IpcMessage::SentToWindow(args))
        .await
        .unwrap();
    Ok(())
}