Skip to main content

dnet_js/transferable/
mod.rs

1//! Transport of data with [Transferable] data over underlying transports
2//! implementing [PostMessage].
3
4pub mod utils;
5
6pub mod typed_array;
7
8use std::{
9    cell::RefCell,
10    fmt::{Debug, Display},
11    marker::PhantomData,
12    pin::Pin,
13    rc::Rc,
14    task::{self, Poll},
15};
16
17use futures::{channel::oneshot, stream::FusedStream, Sink, Stream};
18use js_sys::{Array, JsString};
19use js_utils::{
20    event::{EventListener, When},
21    JsError,
22};
23use wasm_bindgen::{JsCast, JsValue};
24use web_sys::{Event, EventTarget, MessageEvent};
25
26use crate::transferable::utils::{
27    construct_message_object, is_transport_message, message_payload, transport_name_matches,
28    Payload,
29};
30
31use super::{state::State, PostMessage};
32
33/// Data with [transferable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).
34pub struct WithTransferable {
35    /// Data to transfer.
36    pub data: JsValue,
37
38    /// Array of [transferable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects) objects.
39    pub transfer: Array,
40}
41
42/// Trait that needs to be implemented for data to be able to be
43/// transferred over [TransferableTransport].
44pub trait Transferable {
45    /// Additional "context" needed to perform conversion.
46    type Context;
47
48    /// Conversion error.
49    type Error;
50
51    /// Convert into [WithTransferable].
52    fn prepare_for_transfer(
53        self,
54        context: &mut Self::Context,
55    ) -> Result<WithTransferable, Self::Error>;
56
57    /// Reconstruct from [JsValue].
58    fn reconstruct(object: JsValue, context: &mut Self::Context) -> Result<Self, Self::Error>
59    where
60        Self: Sized;
61}
62
63/// Trait for types that can be converted into [Transferable] data.
64pub trait IntoTransferable<Context, Error> {
65    /// Type of output ([Transferable]) data.
66    type Output: Transferable<Context = Context, Error = Error>;
67
68    /// Convert into [Transferable] data.
69    fn into_transferable(self) -> Self::Output;
70}
71
72/// Trait for types that can be reconstructed from [Transferable] data.
73pub trait FromTransferable<Context, Error> {
74    /// Type of input ([Transferable]) data.
75    type Input: Transferable<Context = Context, Error = Error>;
76
77    /// Reconstruct from [Transferable] data.
78    fn from_transferable(input: Self::Input) -> Self;
79}
80
81/// [TransferableTransport] error.
82#[derive(Debug)]
83pub enum Error<TransferableError> {
84    /// Ran not inside a web worker.
85    NotInWorker,
86
87    /// Error occurred during sending a message.
88    SendingError(JsError),
89
90    /// Malformed message received.
91    MalformedMessage,
92
93    /// Failed to prepare data for transfer/reconstruct the data.
94    TransferableError(TransferableError),
95
96    /// Error occurred in worker.
97    WorkerError(Event),
98
99    /// Message error occurred.
100    MessageError(MessageEvent),
101
102    /// Other error occurred.
103    Other(JsError),
104}
105
106impl<TransferableError> Display for Error<TransferableError>
107where
108    TransferableError: Display,
109{
110    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
111        match self {
112            Error::NotInWorker => write!(f, "not inside a (right type of) worker"),
113            Error::SendingError(error) => write!(f, "failed to send message: {error}"),
114            Error::MalformedMessage => write!(f, "malformed message received"),
115            Error::TransferableError(error) => {
116                write!(f, "error occurred  while converting transferable: {error}")
117            }
118            Error::WorkerError(error) => write!(f, "error occurred in worker: {error:?}"),
119            Error::MessageError(error) => write!(f, "message error occurred: {error:?}"),
120            Error::Other(error) => write!(f, "other error occurred: {error}"),
121        }
122    }
123}
124
125impl<TransferableError> std::error::Error for Error<TransferableError> where
126    TransferableError: Debug + Display
127{
128}
129
130/// Transport of data with [Transferable] data over underlying transports
131/// implementing [PostMessage].
132pub struct TransferableTransport<T, Context, Incoming, Outgoing, Error>
133where
134    T: JsCast + AsRef<EventTarget> + PostMessage,
135    Incoming: FromTransferable<Context, Error>,
136    Outgoing: IntoTransferable<Context, Error>,
137    Error: std::error::Error + 'static,
138{
139    target: Rc<T>,
140    name: Option<String>,
141    name_js: Option<JsString>,
142    state: Rc<RefCell<State<JsValue, self::Error<Error>>>>,
143    context: RefCell<Context>,
144    open_receiver: Option<oneshot::Receiver<()>>,
145
146    #[cfg(feature = "logging")]
147    logger: Rc<RefCell<dnet_base::Logger>>,
148
149    _message_listener: EventListener<T, MessageEvent>,
150    _error_listener: EventListener<T, Event>,
151    _message_error_listener: EventListener<T, MessageEvent>,
152    _incoming: PhantomData<Incoming>,
153    _outgoing: PhantomData<Outgoing>,
154}
155
156impl<T, Context, Incoming, Outgoing, Error>
157    TransferableTransport<T, Context, Incoming, Outgoing, Error>
158where
159    T: JsCast + AsRef<EventTarget> + PostMessage,
160    Incoming: FromTransferable<Context, Error>,
161    Outgoing: IntoTransferable<Context, Error>,
162    Error: std::error::Error + 'static,
163{
164    /// Create new [TransferableTransport] wrapping provided target implementing [PostMessage].
165    pub async fn new(
166        target: &Rc<T>,
167        name: Option<String>,
168        context: Context,
169        wait_for_open: bool,
170    ) -> Result<Self, self::Error<Error>> {
171        let (open_sender, open_receiver) = oneshot::channel();
172        let open_sender = Rc::new(RefCell::new(Some(open_sender)));
173
174        let state = Rc::new(RefCell::new(State::new()));
175
176        #[cfg(feature = "logging")]
177        let logger = Rc::new(RefCell::new(if let Some(name) = name.as_ref() {
178            dnet_base::Logger::new_for_already_named::<Self>(&name)
179        } else {
180            dnet_base::Logger::new::<Self>()
181        }));
182
183        let target = target.clone();
184
185        #[cfg(feature = "logging")]
186        let logger_clone = logger.clone();
187
188        let state_clone = state.clone();
189        let name_js = name.clone().map(JsString::from);
190        let name_js_clone = name_js.clone();
191        let open_sender_clone = open_sender.clone();
192
193        let message_listener = target
194            .when("message", move |event: MessageEvent| {
195                let data = event.data();
196                if !(is_transport_message(&data)
197                    && transport_name_matches(&data, name_js_clone.as_ref()))
198                {
199                    return;
200                }
201
202                if let Some(payload) = message_payload(&data) {
203                    match payload {
204                        Payload::Open => {
205                            if let Some(notifier) = open_sender_clone.take() {
206                                let _ = notifier.send(());
207                            } else {
208                                unreachable!("open message received twice!")
209                            }
210                        }
211                        Payload::Close => {
212                            state_clone.borrow_mut().close();
213                        }
214                        Payload::Object(js_value) => {
215                            #[cfg(feature = "logging")]
216                            logger_clone.borrow().log_message_arrived_unknown(None);
217
218                            state_clone.borrow_mut().message(js_value);
219                        }
220                    }
221                } else {
222                    let error = self::Error::MalformedMessage;
223
224                    #[cfg(feature = "logging")]
225                    logger_clone.borrow().log_message_arrived_failure(&error);
226
227                    state_clone.borrow_mut().error(error);
228                }
229            })
230            .map_err(self::Error::Other)?;
231
232        let state_clone = state.clone();
233        let error_listener = target
234            .when("error", move |event: Event| {
235                state_clone
236                    .borrow_mut()
237                    .error(self::Error::WorkerError(event));
238            })
239            .map_err(self::Error::Other)?;
240
241        let state_clone = state.clone();
242        let message_error_listener = target
243            .when("messageerror", move |event: MessageEvent| {
244                state_clone
245                    .borrow_mut()
246                    .error(self::Error::MessageError(event));
247            })
248            .map_err(self::Error::Other)?;
249
250        let context = RefCell::new(context);
251
252        let mut transport = TransferableTransport {
253            target,
254            name,
255            name_js,
256            state,
257            context,
258            open_receiver: Some(open_receiver),
259
260            #[cfg(feature = "logging")]
261            logger,
262
263            _message_listener: message_listener,
264            _error_listener: error_listener,
265            _message_error_listener: message_error_listener,
266            _incoming: PhantomData,
267            _outgoing: PhantomData,
268        };
269        transport.send_open();
270        if wait_for_open {
271            transport.wait_for_open().await;
272        }
273
274        Ok(transport)
275    }
276
277    /// Name of the transport.
278    pub fn name(&self) -> Option<&str> {
279        self.name.as_deref()
280    }
281
282    /// Wait for transport open.
283    pub async fn wait_for_open(&mut self) {
284        if let Some(open_receiver) = self.open_receiver.take() {
285            let _ = open_receiver.await;
286
287            #[cfg(feature = "logging")]
288            self.logger.borrow().log_open_success();
289        }
290    }
291
292    fn send_message(&self, message: Outgoing) -> Result<(), self::Error<Error>> {
293        let WithTransferable { data, transfer } = message
294            .into_transferable()
295            .prepare_for_transfer(&mut self.context.borrow_mut())
296            .map_err(self::Error::TransferableError)?;
297
298        let message = construct_message_object(self.name_js.as_ref(), Payload::Object(data));
299
300        self.target
301            .post_message_with_transfer(&message, &transfer)
302            .map_err(|error| self::Error::SendingError(error.into()))?;
303
304        Ok(())
305    }
306
307    fn send_open(&self) {
308        let message = construct_message_object(self.name_js.as_ref(), Payload::Open);
309        let _ = self.target.post_message(&message);
310    }
311
312    fn send_close(&self) {
313        let message = construct_message_object(self.name_js.as_ref(), Payload::Close);
314        let _ = self.target.post_message(&message);
315    }
316}
317
318impl<T, Context, Incoming, Outgoing, Error> Drop
319    for TransferableTransport<T, Context, Incoming, Outgoing, Error>
320where
321    T: JsCast + AsRef<EventTarget> + PostMessage,
322    Incoming: FromTransferable<Context, Error>,
323    Outgoing: IntoTransferable<Context, Error>,
324    Error: std::error::Error + 'static,
325{
326    fn drop(&mut self) {
327        self.send_close();
328    }
329}
330
331impl<T, Context, Incoming, Outgoing, Error> Sink<Outgoing>
332    for TransferableTransport<T, Context, Incoming, Outgoing, Error>
333where
334    T: JsCast + AsRef<EventTarget> + PostMessage,
335    Incoming: FromTransferable<Context, Error>,
336    Outgoing: IntoTransferable<Context, Error>,
337    Error: std::error::Error + 'static,
338{
339    type Error = dnet_base::Error<self::Error<Error>>;
340
341    fn poll_ready(
342        self: Pin<&mut Self>,
343        _cx: &mut task::Context<'_>,
344    ) -> Poll<Result<(), Self::Error>> {
345        let result = Poll::Ready(Ok(()));
346
347        #[cfg(feature = "logging")]
348        self.logger.borrow().log_ready(&result);
349
350        result
351    }
352
353    fn start_send(self: Pin<&mut Self>, item: Outgoing) -> Result<(), Self::Error> {
354        let result = if self.state.borrow().closed {
355            Err(dnet_base::Error::Closed)
356        } else {
357            self.send_message(item).map_err(dnet_base::Error::Other)
358        };
359
360        #[cfg(feature = "logging")]
361        self.logger
362            .borrow()
363            .log_sending::<Outgoing, _>(&result, None);
364
365        result
366    }
367
368    fn poll_flush(
369        self: Pin<&mut Self>,
370        _cx: &mut task::Context<'_>,
371    ) -> Poll<Result<(), Self::Error>> {
372        let result = if self.state.borrow().closed {
373            Poll::Ready(Err(dnet_base::Error::Closed))
374        } else {
375            Poll::Ready(Ok(()))
376        };
377
378        #[cfg(feature = "logging")]
379        self.logger.borrow().log_flush(&result);
380
381        result
382    }
383
384    fn poll_close(
385        self: Pin<&mut Self>,
386        _cx: &mut task::Context<'_>,
387    ) -> Poll<Result<(), Self::Error>> {
388        let result = if self.state.borrow().closed {
389            Poll::Ready(Err(dnet_base::Error::Closed))
390        } else {
391            self.send_close();
392            self.state.borrow_mut().close();
393            Poll::Ready(Ok(()))
394        };
395
396        #[cfg(feature = "logging")]
397        self.logger.borrow().log_close(&result);
398
399        result
400    }
401}
402
403impl<T, Context, Incoming, Outgoing, Error> Stream
404    for TransferableTransport<T, Context, Incoming, Outgoing, Error>
405where
406    T: JsCast + AsRef<EventTarget> + PostMessage,
407    Incoming: FromTransferable<Context, Error>,
408    Outgoing: IntoTransferable<Context, Error>,
409    Error: std::error::Error + 'static,
410{
411    type Item = Result<Incoming, self::Error<Error>>;
412
413    fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
414        let mut state = self.state.borrow_mut();
415        let result = if state.is_terminated() {
416            Poll::Ready(None)
417        } else if let Some(item) = state.incoming.pop_front() {
418            Poll::Ready(Some(item.and_then(|item| {
419                <Incoming::Input>::reconstruct(item, &mut self.context.borrow_mut())
420                    .map_err(self::Error::TransferableError)
421                    .map(|item| Incoming::from_transferable(item))
422            })))
423        } else {
424            state.update_waker_with(cx.waker());
425            Poll::Pending
426        };
427
428        #[cfg(feature = "logging")]
429        self.logger.borrow().log_receiving(&result, None);
430
431        result
432    }
433}
434
435impl<T, Context, Incoming, Outgoing, Error> FusedStream
436    for TransferableTransport<T, Context, Incoming, Outgoing, Error>
437where
438    T: JsCast + AsRef<EventTarget> + PostMessage,
439    Incoming: FromTransferable<Context, Error>,
440    Outgoing: IntoTransferable<Context, Error>,
441    Error: std::error::Error + 'static,
442{
443    fn is_terminated(&self) -> bool {
444        self.state.borrow().is_terminated()
445    }
446}
447
448#[cfg(feature = "logging")]
449impl<T, Context, Incoming, Outgoing, Error> dnet_base::Logging
450    for TransferableTransport<T, Context, Incoming, Outgoing, Error>
451where
452    T: JsCast + AsRef<EventTarget> + PostMessage,
453    Incoming: FromTransferable<Context, Error>,
454    Outgoing: IntoTransferable<Context, Error>,
455    Error: std::error::Error + 'static,
456{
457    const KIND: &'static str = "Transferable";
458
459    fn with_logger<F, R>(&self, f: F) -> R
460    where
461        F: FnOnce(&dnet_base::Logger) -> R,
462    {
463        f(&self.logger.borrow())
464    }
465
466    fn with_logger_mut<F, R>(&mut self, f: F) -> R
467    where
468        F: FnOnce(&mut dnet_base::Logger) -> R,
469    {
470        f(&mut self.logger.borrow_mut())
471    }
472}
473
474#[cfg(test)]
475mod tests {
476    use std::rc::Rc;
477
478    use dnet_base::Receive;
479    use dnet_codecs::{bincode, BincodeCodec};
480    use dnet_macros::IntoTransferable;
481    use dnet_tests::dtest_configure;
482    use futures::{join, SinkExt};
483    use js_sys::{ArrayBuffer, Uint32Array};
484    use wasm_bindgen_test::wasm_bindgen_test;
485    use web_sys::{MessageChannel, MessagePort};
486
487    use crate::{wrapper, TransferableTransport};
488
489    dtest_configure!();
490
491    type Context = wrapper::Context<BincodeCodec>;
492    type Error = wrapper::Error<bincode::EncodeError, bincode::DecodeError>;
493
494    async fn create_transports<I, O>() -> (
495        TransferableTransport<MessagePort, Context, I, O, Error>,
496        TransferableTransport<MessagePort, Context, O, I, Error>,
497    )
498    where
499        I: crate::FromTransferable<Context, Error> + crate::IntoTransferable<Context, Error>,
500        O: crate::FromTransferable<Context, Error> + crate::IntoTransferable<Context, Error>,
501    {
502        let channel = MessageChannel::new().unwrap();
503
504        let left_port = Rc::new(channel.port1());
505        let right_port = Rc::new(channel.port2());
506
507        let left = TransferableTransport::new(
508            &left_port,
509            None,
510            Context::new(BincodeCodec::default()),
511            true,
512        );
513        let right = TransferableTransport::new(
514            &right_port,
515            None,
516            Context::new(BincodeCodec::default()),
517            true,
518        );
519
520        left_port.start();
521        right_port.start();
522
523        let (left, right) = join!(left, right);
524        let left = left.unwrap();
525        let right = right.unwrap();
526
527        (left, right)
528    }
529
530    #[wasm_bindgen_test]
531    async fn test_into_transferable_struct_unnamed_fields() {
532        #[derive(Debug, IntoTransferable)]
533        struct Message(Vec<u32>, #[transferable] ArrayBuffer);
534
535        #[derive(Debug, IntoTransferable)]
536        struct Empty {}
537
538        let (mut left, mut right) = create_transports::<Empty, Message>().await;
539
540        dnet_tests::init_logging(&mut left, &mut right);
541
542        let ints = vec![1, 2, 3];
543
544        let array = Uint32Array::new_with_length(3);
545        array.copy_from(&[4, 5, 6]);
546
547        let message = Message(ints.clone(), array.buffer());
548
549        left.send(message).await.unwrap();
550        let received = right.receive().await.unwrap();
551
552        assert_eq!(received.0, ints);
553        assert_eq!(Uint32Array::new(&received.1).to_vec(), vec![4, 5, 6]);
554    }
555
556    #[wasm_bindgen_test]
557    async fn test_into_transferable_struct() {
558        #[derive(Debug, IntoTransferable)]
559        struct Message {
560            ints: Vec<u32>,
561
562            #[transferable]
563            array_buffer_1: ArrayBuffer,
564
565            #[transferable]
566            array_buffer_2: ArrayBuffer,
567        }
568
569        #[derive(Debug, IntoTransferable)]
570        struct Empty {}
571
572        let (mut left, mut right) = create_transports::<Empty, Message>().await;
573
574        dnet_tests::init_logging(&mut left, &mut right);
575
576        let ints = vec![1, 2, 3];
577
578        let array_1 = Uint32Array::new_with_length(3);
579        array_1.copy_from(&[4, 5, 6]);
580
581        let array_2 = Uint32Array::new_with_length(3);
582        array_2.copy_from(&[7, 8, 9]);
583
584        let message = Message {
585            ints: ints.clone(),
586            array_buffer_1: array_1.buffer(),
587            array_buffer_2: array_2.buffer(),
588        };
589
590        left.send(message).await.unwrap();
591        let received = right.receive().await.unwrap();
592
593        assert_eq!(received.ints, ints);
594        assert_eq!(
595            Uint32Array::new(&received.array_buffer_1).to_vec(),
596            vec![4, 5, 6]
597        );
598        assert_eq!(
599            Uint32Array::new(&received.array_buffer_2).to_vec(),
600            vec![7, 8, 9]
601        );
602    }
603
604    #[wasm_bindgen_test]
605    async fn test_into_transferable_nested_struct() {
606        #[derive(Debug, IntoTransferable)]
607        struct Message {
608            ints: Vec<u32>,
609
610            #[transferable]
611            array_buffer: ArrayBuffer,
612        }
613
614        #[derive(Debug, IntoTransferable)]
615        struct Wrapper {
616            #[into_transferable]
617            message_1: Message,
618
619            #[into_transferable]
620            message_2: Message,
621
622            ints: Vec<u32>,
623        }
624
625        #[derive(Debug, IntoTransferable)]
626        struct Wrapper2 {
627            #[into_transferable]
628            wrapper: Wrapper,
629        }
630
631        #[derive(Debug, IntoTransferable)]
632        struct Empty {}
633
634        let (mut left, mut right) = create_transports::<Empty, Wrapper2>().await;
635
636        dnet_tests::init_logging(&mut left, &mut right);
637
638        let ints_1 = vec![1, 2, 3];
639        let ints_2 = vec![4, 5, 6];
640        let ints_3 = vec![7, 8, 9];
641
642        let array_1 = Uint32Array::new_with_length(3);
643        array_1.copy_from(&[10, 11, 12]);
644
645        let array_2 = Uint32Array::new_with_length(3);
646        array_2.copy_from(&[13, 14, 15]);
647
648        let wrapper = Wrapper {
649            message_1: Message {
650                ints: ints_1.clone(),
651                array_buffer: array_1.buffer(),
652            },
653            message_2: Message {
654                ints: ints_2.clone(),
655                array_buffer: array_2.buffer(),
656            },
657            ints: ints_3,
658        };
659        let wrapper_2 = Wrapper2 { wrapper };
660
661        left.send(wrapper_2).await.unwrap();
662        let received = right.receive().await.unwrap();
663
664        assert_eq!(received.wrapper.message_1.ints, ints_1);
665        assert_eq!(received.wrapper.message_2.ints, ints_2);
666        assert_eq!(
667            Uint32Array::new(&received.wrapper.message_1.array_buffer).to_vec(),
668            vec![10, 11, 12]
669        );
670        assert_eq!(
671            Uint32Array::new(&received.wrapper.message_2.array_buffer).to_vec(),
672            vec![13, 14, 15]
673        );
674    }
675
676    #[wasm_bindgen_test]
677    async fn test_into_transferable_enum() {
678        #[derive(Debug, IntoTransferable)]
679        enum Message {
680            Variant1 {
681                ints: Vec<u32>,
682
683                #[transferable]
684                array_buffer_1: ArrayBuffer,
685
686                #[transferable]
687                array_buffer_2: ArrayBuffer,
688            },
689            Variant2 {
690                ints: Vec<u32>,
691            },
692            Variant3 {
693                #[transferable]
694                array_buffer: ArrayBuffer,
695            },
696            Variant4,
697        }
698
699        #[derive(Debug, IntoTransferable)]
700        struct Empty {}
701
702        let (mut left, mut right) = create_transports::<Empty, Message>().await;
703
704        dnet_tests::init_logging(&mut left, &mut right);
705
706        let ints = vec![1, 2, 3];
707
708        let array_1 = Uint32Array::new_with_length(3);
709        array_1.copy_from(&[4, 5, 6]);
710
711        let array_2 = Uint32Array::new_with_length(3);
712        array_2.copy_from(&[7, 8, 9]);
713
714        let message = Message::Variant1 {
715            ints: ints.clone(),
716            array_buffer_1: array_1.buffer(),
717            array_buffer_2: array_2.buffer(),
718        };
719
720        left.send(message).await.unwrap();
721        let received = right.receive().await.unwrap();
722
723        if let Message::Variant1 {
724            ints: ints_received,
725            array_buffer_1,
726            array_buffer_2,
727        } = received
728        {
729            assert_eq!(ints_received, ints);
730            assert_eq!(Uint32Array::new(&array_buffer_1).to_vec(), vec![4, 5, 6]);
731            assert_eq!(Uint32Array::new(&array_buffer_2).to_vec(), vec![7, 8, 9]);
732        } else {
733            panic!("unexpected variant received");
734        }
735
736        let ints = vec![10, 11, 12];
737        left.send(Message::Variant2 { ints: ints.clone() })
738            .await
739            .unwrap();
740        let received = right.receive().await.unwrap();
741
742        if let Message::Variant2 {
743            ints: ints_received,
744        } = received
745        {
746            assert_eq!(ints_received, ints);
747        } else {
748            panic!("unexpected variant received");
749        }
750
751        let array = Uint32Array::new_with_length(3);
752        array.copy_from(&[13, 14, 15]);
753
754        left.send(Message::Variant3 {
755            array_buffer: array.buffer(),
756        })
757        .await
758        .unwrap();
759        let received = right.receive().await.unwrap();
760
761        if let Message::Variant3 { array_buffer } = received {
762            assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![13, 14, 15]);
763        } else {
764            panic!("unexpected variant received");
765        }
766
767        left.send(Message::Variant4).await.unwrap();
768        let received = right.receive().await.unwrap();
769
770        if !matches!(received, Message::Variant4) {
771            panic!("unexpected variant received");
772        }
773    }
774
775    #[wasm_bindgen_test]
776    async fn test_into_transferable_nested_enum() {
777        #[derive(Debug, IntoTransferable)]
778        struct Message {
779            ints: Vec<u32>,
780
781            #[transferable]
782            array_buffer: ArrayBuffer,
783        }
784
785        #[derive(Debug, IntoTransferable)]
786        enum Message2 {
787            Variant1 {
788                ints: Vec<u32>,
789
790                #[transferable]
791                array_buffer: ArrayBuffer,
792            },
793
794            Variant2 {
795                #[into_transferable]
796                message: Message,
797            },
798        }
799
800        #[derive(Debug, IntoTransferable)]
801        struct Empty {}
802
803        let (mut left, mut right) = create_transports::<Empty, Message2>().await;
804
805        dnet_tests::init_logging(&mut left, &mut right);
806
807        let ints = vec![1, 2, 3];
808
809        let array = Uint32Array::new_with_length(3);
810        array.copy_from(&[4, 5, 6]);
811
812        let message = Message2::Variant1 {
813            ints: ints.clone(),
814            array_buffer: array.buffer(),
815        };
816
817        left.send(message).await.unwrap();
818        let received = right.receive().await.unwrap();
819
820        if let Message2::Variant1 {
821            ints: ints_received,
822            array_buffer,
823        } = received
824        {
825            assert_eq!(ints_received, ints);
826            assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![4, 5, 6]);
827        } else {
828            panic!("unexpected variant received");
829        }
830
831        let ints = vec![7, 8, 9];
832
833        let array = Uint32Array::new_with_length(3);
834        array.copy_from(&[10, 11, 12]);
835
836        let message = Message2::Variant2 {
837            message: Message {
838                ints: ints.clone(),
839                array_buffer: array.buffer(),
840            },
841        };
842        left.send(message).await.unwrap();
843        let received = right.receive().await.unwrap();
844
845        if let Message2::Variant2 {
846            message:
847                Message {
848                    ints: ints_received,
849                    array_buffer,
850                },
851        } = received
852        {
853            assert_eq!(ints_received, ints);
854            assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![10, 11, 12]);
855        } else {
856            panic!("unexpected variant received");
857        }
858    }
859
860    #[wasm_bindgen_test]
861    async fn test_into_transferable_enum_unnamed_fields() {
862        #[derive(Debug, IntoTransferable)]
863        enum Message {
864            Variant1(Vec<u32>, #[transferable] ArrayBuffer),
865            Variant2(Vec<u32>),
866            Variant3 {
867                #[transferable]
868                some_field: ArrayBuffer,
869            },
870            Variant4,
871        }
872
873        #[derive(Debug, IntoTransferable)]
874        struct Empty {}
875
876        let (mut left, mut right) = create_transports::<Empty, Message>().await;
877
878        dnet_tests::init_logging(&mut left, &mut right);
879
880        let ints = vec![1, 2, 3];
881
882        let array = Uint32Array::new_with_length(3);
883        array.copy_from(&[4, 5, 6]);
884
885        let message = Message::Variant1(ints.clone(), array.buffer());
886
887        left.send(message).await.unwrap();
888        let received = right.receive().await.unwrap();
889
890        if let Message::Variant1(ints_received, array_buffer) = received {
891            assert_eq!(ints_received, ints);
892            assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![4, 5, 6]);
893        } else {
894            panic!("unexpected variant received");
895        }
896
897        let ints = vec![10, 11, 12];
898        left.send(Message::Variant2(ints.clone())).await.unwrap();
899        let received = right.receive().await.unwrap();
900
901        if let Message::Variant2(ints_received) = received {
902            assert_eq!(ints_received, ints);
903        } else {
904            panic!("unexpected variant received");
905        }
906
907        let array = Uint32Array::new_with_length(3);
908        array.copy_from(&[13, 14, 15]);
909
910        left.send(Message::Variant3 {
911            some_field: array.buffer(),
912        })
913        .await
914        .unwrap();
915        let received = right.receive().await.unwrap();
916
917        if let Message::Variant3 {
918            some_field: array_buffer,
919        } = received
920        {
921            assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![13, 14, 15]);
922        } else {
923            panic!("unexpected variant received");
924        }
925
926        left.send(Message::Variant4).await.unwrap();
927        let received = right.receive().await.unwrap();
928
929        if !matches!(received, Message::Variant4) {
930            panic!("unexpected variant received");
931        }
932    }
933}