rpgx_wasm/eucl/
rect.rs

1use crate::{
2    prelude::{WasmCoordinates, WasmShape},
3    traits::WasmWrapper,
4};
5use rpgx::prelude::Rect;
6use wasm_bindgen::prelude::*;
7
8#[wasm_bindgen(js_name = Rect)]
9#[derive(Clone, Debug, PartialEq, Eq)]
10pub struct WasmRect {
11    inner: Rect,
12}
13
14impl WasmWrapper<Rect> for WasmRect {
15    fn from_inner(inner: Rect) -> Self {
16        WasmRect { inner }
17    }
18
19    fn inner(&self) -> &Rect {
20        &self.inner
21    }
22
23    fn into_inner(self) -> Rect {
24        self.inner
25    }
26}
27
28#[wasm_bindgen(js_class = Rect)]
29impl WasmRect {
30    #[wasm_bindgen(constructor)]
31    pub fn new(origin: &WasmCoordinates, shape: &WasmShape) -> WasmRect {
32        WasmRect {
33            inner: Rect::new(origin.inner().clone(), *shape.inner()),
34        }
35    }
36
37    #[wasm_bindgen(js_name = fromShape)]
38    pub fn from_shape(shape: &WasmShape) -> WasmRect {
39        WasmRect {
40            inner: Rect::from_shape(*shape.inner()),
41        }
42    }
43
44    #[wasm_bindgen(js_name = fromOrigin)]
45    pub fn from_origin(origin: &WasmCoordinates) -> WasmRect {
46        WasmRect {
47            inner: Rect::from_origin(origin.inner().clone()),
48        }
49    }
50
51    #[wasm_bindgen(js_name = fromXYWH)]
52    pub fn from_xywh(x: u32, y: u32, width: u32, height: u32) -> WasmRect {
53        WasmRect {
54            inner: Rect::from_xywh(x, y, width, height),
55        }
56    }
57
58    #[wasm_bindgen(js_name = fromMany)]
59    pub fn from_many(rects: Vec<WasmRect>) -> Result<WasmRect, JsValue> {
60        let inner_rects: Vec<Rect> = rects.into_iter().map(|r| r.inner).collect();
61        match Rect::from_many(inner_rects) {
62            Ok(rect) => Ok(WasmRect { inner: rect }),
63            _ => Err(JsValue::from_str("RectError::EmptyRectList")),
64        }
65    }
66
67    #[wasm_bindgen(getter)]
68    pub fn origin(&self) -> WasmCoordinates {
69        WasmCoordinates::from_inner(self.inner.origin)
70    }
71
72    #[wasm_bindgen(getter)]
73    pub fn shape(&self) -> WasmShape {
74        WasmShape::from_inner(self.inner.shape)
75    }
76
77    #[wasm_bindgen(js_name = asMany)]
78    pub fn into_many(&self) -> Vec<WasmRect> {
79        self.inner
80            .into_many()
81            .into_iter()
82            .map(|r| WasmRect { inner: r })
83            .collect()
84    }
85
86    #[wasm_bindgen(js_name = asBlock)]
87    pub fn into_single(&self) -> Vec<WasmRect> {
88        self.inner
89            .into_single()
90            .into_iter()
91            .map(|r| WasmRect { inner: r })
92            .collect()
93    }
94
95    #[wasm_bindgen(js_name = asPerimeter)]
96    pub fn into_perimeter(&self, offset: u32, size: u32) -> Vec<WasmRect> {
97        self.inner
98            .into_perimeter(offset, size)
99            .into_iter()
100            .map(|r| WasmRect { inner: r })
101            .collect()
102    }
103
104    #[wasm_bindgen(js_name = asBisector)]
105    pub fn into_bisector(&self, offset: u32, size: u32) -> Vec<WasmRect> {
106        self.inner
107            .into_bisector(offset, size)
108            .into_iter()
109            .map(|r| WasmRect { inner: r })
110            .collect()
111    }
112
113    #[wasm_bindgen(js_name = asCenter)]
114    pub fn into_center(&self, offset: u32, size: u32) -> Vec<WasmRect> {
115        self.inner
116            .into_center(offset, size)
117            .into_iter()
118            .map(|r| WasmRect { inner: r })
119            .collect()
120    }
121
122    #[wasm_bindgen(js_name = asRhombus)]
123    pub fn into_rhombus(&self, dial: u32) -> Vec<WasmRect> {
124        self.inner
125            .into_rhombus(dial)
126            .into_iter()
127            .map(|r| WasmRect { inner: r })
128            .collect()
129    }
130
131    #[wasm_bindgen(js_name = asCircle)]
132    pub fn into_circle(&self) -> Vec<WasmRect> {
133        self.inner
134            .into_circle()
135            .into_iter()
136            .map(|r| WasmRect { inner: r })
137            .collect()
138    }
139
140    #[wasm_bindgen(js_name = asOdds)]
141    pub fn into_odds(&self) -> Vec<WasmRect> {
142        self.inner
143            .into_odds()
144            .into_iter()
145            .map(|r| WasmRect { inner: r })
146            .collect()
147    }
148
149    #[wasm_bindgen(js_name = asEvens)]
150    pub fn into_evens(&self) -> Vec<WasmRect> {
151        self.inner
152            .into_evens()
153            .into_iter()
154            .map(|r| WasmRect { inner: r })
155            .collect()
156    }
157}