Enum typescript_type_def::type_expr::TypeInfo

pub enum TypeInfo {
    Native(NativeTypeInfo),
    Defined(DefinedTypeInfo),
}

A description of the type information required to produce a TypeScript type definition.

Variants

Native(NativeTypeInfo)

This info describes a “native” TypeScript type which does not require a type definition.

Defined(DefinedTypeInfo)

This info describes a “defined” TypeScript type which does require a type definition.

Implementations

impl TypeInfo

pub fn write_ref_expr<W>(
    &'static self,
    writer: W,
    root_namespace: Option<&str>
) -> Result<()> where
    W: Write, 

Writes a Typescript type expression referencing this type to the given writer.

This method is meant to be used in generated code referencing types defined in a module created with write_definition_file. The root_namespace option should be set to the qualified name of the import of that module.

Example

use serde::Serialize;
use std::io::Write;
use typescript_type_def::{write_definition_file, TypeDef};

#[derive(Serialize, TypeDef)]
struct Foo<T> {
    a: T,
}

let ts_module = {
    let mut buf = Vec::new();
    // types.ts contains type definitions written using write_definition_file
    writeln!(&mut buf, "import * as types from './types';").unwrap();
    writeln!(&mut buf).unwrap();
    write!(&mut buf, "export function myAPI(foo: ").unwrap();
    let foo_type_info = &<Foo<Vec<u8>> as TypeDef>::INFO;
    foo_type_info.write_ref_expr(&mut buf, Some("types")).unwrap();
    writeln!(&mut buf, ") {{}}").unwrap();
    String::from_utf8(buf).unwrap()
};
assert_eq!(
    ts_module,
    r#"import * as types from './types';

export function myAPI(foo: types.Foo<(types.U8)[]>) {}
"#
);

Trait Implementations

impl Clone for TypeInfo

fn clone(&self) -> TypeInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeInfo

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

Formats the value using the given formatter.

impl Copy for TypeInfo