px-wsdom-ts-parse 0.0.6

for the wsdom crate, and potentially other uses
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

use winnow::{
    combinator::{alt, delimited, opt, preceded, separated_pair, terminated},
    token::one_of,
    PResult, Parser,
};

use super::{
    field::Field,
    method::Method,
    ts_type::TsType,
    util::{token, token_word, word1, Parsable},
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Member<'a> {
    Method(Method<'a>),
    Field(Field<'a>),
    Getter(Getter<'a>),
    Setter(Setter<'a>),
}
impl<'a> Parsable<'a> for Member<'a> {
    fn parse(input: &mut &'a str) -> PResult<Self> {
        terminated(
            alt((
                Method::parse.map(Self::Method),
                Field::parse.map(Self::Field),
                Getter::parse.map(Self::Getter),
                Setter::parse.map(Self::Setter),
            )),
            opt(token(one_of((',', ';')))),
        )
        .parse_next(input)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Getter<'a> {
    pub name: &'a str,
    pub ret: TsType<'a>,
}

impl<'a> Parsable<'a> for Getter<'a> {
    fn parse(input: &mut &'a str) -> PResult<Self> {
        preceded(
            token_word("get"),
            separated_pair(word1, (token('('), token(')'), token(':')), TsType::parse),
        )
        .map(|(name, ret)| Self { name, ret })
        .parse_next(input)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Setter<'a> {
    pub name: &'a str,
    pub arg_name: &'a str,
    pub arg_ty: TsType<'a>,
}

impl<'a> Parsable<'a> for Setter<'a> {
    fn parse(input: &mut &'a str) -> PResult<Self> {
        preceded(
            token_word("set"),
            (
                word1,
                delimited(
                    token('('),
                    separated_pair(word1, token(':'), TsType::parse),
                    token(')'),
                ),
            ),
        )
        .map(|(name, (arg_name, arg_ty))| Self {
            name,
            arg_name,
            arg_ty,
        })
        .parse_next(input)
    }
}