Enum TsType 

pub enum TsType {
    Base(String),
    Paren(Box<TsType>),
    Array(Box<TsType>),
    Tuple(Vec<TsType>),
    Union(Vec<TsType>),
    Intersection(Vec<TsType>),
    Generic(Box<TsType>, Vec<TsType>),
    IndexedAccess(Box<TsType>, Box<TsType>),
}

A TypeScript type.

This type is used to represent TypeScript types in a Rust-friendly way.

Note: This is not an exhaustive representation of TypeScript types.

Variants

Base(String)

A single type, e.g., string.

Paren(Box<TsType>)

Array(Box<TsType>)

Tuple(Vec<TsType>)

Union(Vec<TsType>)

Intersection(Vec<TsType>)

Generic(Box<TsType>, Vec<TsType>)

A generic type with arguments, e.g., Set<string, number>.

IndexedAccess(Box<TsType>, Box<TsType>)

A type with an indexing key type, e.g., Car["make"].

Implementations

impl TsType

pub fn is_union_with(&self, other: &Self) -> bool

Find out if this type is a union with another type

pub fn contains(&self, other: &Self) -> bool

Find out if this type contains another type e.g. (string | number)[] contains string

pub fn as_generic(self, args: Vec<Self>) -> Self

convert this type to a generic with arguments

pub fn property(self, key: Self) -> Self

convert this type to an indexed access type with a key

pub fn in_array(self) -> Self

place this type in an array

pub fn in_parens(self) -> Self

place this type in parentheses

pub fn or(self, other: Self) -> Self

union this type with another

pub fn and(self, other: Self) -> Self

intersect this type with another

pub fn join(self, other: Self) -> Result<Self, &'static str>

Attempts to join this type with a right hand type. This is used during parsing and may not be intuitive for general use.

pub fn from_ts_str(str: &str) -> Result<Self, TsTypeError>

Attempts to parse a TypeScript type from a typescript string.

Returns a TsTypeError if the string is empty or contains an unexpected character.

Example

use ts_type::TsType;

let type1 = TsType::from_ts_str("string | number").unwrap();
let type2 = TsType::Union(vec![
    TsType::Base("string".to_string()),
    TsType::Base("number".to_string()),
])
assert_eq!(type1, type2);

Trait Implementations

impl Clone for TsType

fn clone(&self) -> TsType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TsType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TsType

fn default() -> Self

Returns the “default value” for a type.

impl Display for TsType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for TsType

type Err = TsTypeError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for TsType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TsType

fn eq(&self, other: &TsType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&Type> for TsType

type Error = TsTypeError

The type returned in the event of a conversion error.

fn try_from(ty: &Type) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for TsType

impl StructuralPartialEq for TsType