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

use accessory::Accessors;
use wasm_bindgen::{prelude::*, JsCast};
use web_sys::{IdbOpenDbRequest, IdbRequest};

use crate::idb_database::IdbDatabase;
use crate::prelude::IdbTransaction;

/// The DB version has changed
#[derive(Debug, Accessors)]
pub struct IdbVersionChangeEvent {
    event: web_sys::IdbVersionChangeEvent,

    /// Database associated with the version change
    #[access(get)]
    db: IdbDatabase,

    req: IdbOpenDbRequest,
}

pub(crate) type IdbVersionChangeCallback =
    Closure<dyn FnMut(web_sys::IdbVersionChangeEvent) -> Result<(), JsValue> + 'static>;

impl IdbVersionChangeEvent {
    pub(crate) fn new(event: web_sys::IdbVersionChangeEvent) -> Self {
        let req: IdbOpenDbRequest = event
            .target()
            .expect("Failed to unwrap IdbOpenDbRequest event target")
            .unchecked_into();
        let base_db: web_sys::IdbDatabase = req
            .result()
            .expect("Failed to unwrap IdbOpenDbRequest result")
            .unchecked_into();

        Self {
            event,
            db: IdbDatabase::new(base_db),
            req,
        }
    }

    pub(crate) fn wrap_callback<F>(cb: F) -> IdbVersionChangeCallback
    where
        F: Fn(&Self) -> Result<(), JsValue> + 'static,
    {
        let b = Box::new(move |event: web_sys::IdbVersionChangeEvent| cb(&Self::new(event)));
        Closure::wrap(b)
    }

    /// Old DB version; set to 0 on new DBs
    #[inline]
    #[must_use]
    pub fn old_version(&self) -> f64 {
        self.event.old_version()
    }

    /// New DB version
    #[inline]
    #[must_use]
    pub fn new_version(&self) -> f64 {
        self.event
            .new_version()
            .expect("Unable to unwrap new version")
    }

    /// Transaction associated with the version change
    #[inline]
    #[must_use]
    pub fn transaction(&self) -> IdbTransaction {
        let inner = self
            .req
            .unchecked_ref::<IdbRequest>()
            .transaction()
            .expect("Failed to unwrap IdbOpenDbRequest transaction");

        IdbTransaction::new(inner, &self.db)
    }
}

impl AsRef<IdbDatabase> for IdbVersionChangeEvent {
    #[inline]
    fn as_ref(&self) -> &IdbDatabase {
        self.db()
    }
}