如果您有一个泛型结构体，例如

use serde::Serialize;
use typescript_definitions::TypeScriptify;
#[derive(Serialize, TypeScriptify)]
pub struct Value<T> {
    value: T
}

则需要选择一个具体类型来生成 TypeScript：Value<i32>::type_script_ify()。具体类型无关紧要，只要它遵守 Rust 限制即可；输出仍然将是泛型 export type Value<T> { value: T }。

目前 TypeScript 中的类型界限被丢弃。

因此，使用 TypeScriptify，您必须创建一些二进制文件，通过 println! 或类似的语句，将输出 TypeScript 库文件。我想您在这里有更多的控制...但这会复杂化您的 Cargo.toml 文件和您的代码。

功能

正如我们之前所说，typescript-descriptions 宏会将静态字符串和其他垃圾污染您的代码。因此，默认情况下，它们只能在调试模式下工作。

如果您确实想在发布代码中提供 T::type_script_ify()，则更改您的 Cargo.toml 文件：

[dependencies.typescript-definitions]
version = "0.1"
features = ["export-typescript"]

## OR

typescript-definitions = { version="0.1",  features=["export-typescript"]  }

据我所知，TypescriptDescription 生成的字符串即使在调试模式下也无法在 wasm-bindgen 调用中存活。因此，您的 *.wasm 文件是干净的。尽管如此，您仍需要在发布模式下添加 --features=export-typescript 以生成任何内容。

Serde 属性。

请参阅 Serde 文档。

typescript-definitions 尝试遵循 serde 属性的含义，如 #[serde(tag="type")] 和 #[serde(tag="tag", content="fields")]。

在 0.1.8 之前，我们为枚举有隐式的默认标签 "kind"。现在没有（尽管我们仍然在 NewTypes 上有隐式的 transparent）。

Serde 属性理解

• rename，rename_all
• 标签:
• 内容:
• skip：（typescript-definitions 默认也会跳过 PhantomData 字段 ... 对不起，幽灵）
• serialize_with="typescript_definitions::as_byte_string"
• transparent：NewTypes 自动为透明。具有单个字段的结构可以标记为透明。

serialize_with，如果放置在 [u8] 或 Vec<u8> 字段上，将把该字段视为字符串。（并且 serde_json 将输出数组的 \xdd 编码字符串。或者您可以创建自己的...只需确保将其命名为 as_byte_string）

use serde::Serialize;
use typescript_definitions::{TypeScriptify, TypeScriptifyTrait};

#[derive(Serialize, TypeScriptify)]
struct S {
     #[serde(serialize_with="typescript_definitions::as_byte_string")]
     #[ts(ts_type="string")]
     image : Vec<u8>,
     buffer: &'static [u8],
}

println!("{}", S::type_script_ify());

打印 export type S = { image: string, buffer: number[] };。

Serde 属性理解但 拒绝

• flatten（这将产生恐慌）。可能永远不会修复。

所有其他内容都将被忽略。

如果您有专门的序列化，那么您将不得不告诉 typescript-definitions 结果是什么 ... 请参阅下一节。

typescript-definition 属性

有两种方式可以干预以纠正 TypeScript 输出。

• ts_as：这是一个Rust路径，指向另一个Rust类型，该值将按此方式序列化。
• ts_type：应使用的typescript类型。

例如，某些类型，例如 chrono::DateTime，将以不可见的方式自行序列化。您需要通知 typescript-definitions，即

use serde::Serialize;
use typescript_definitions::{TypeScriptify, TypeScriptifyTrait};
// with features=["serde"]
use chrono::{DateTime, Local, Utc};
// with features=["serde-1"]
use arrayvec::ArrayVec;

#[derive(Serialize, TypeScriptify)]
pub struct Chrono {
    #[ts(ts_type="string")]
    pub local: DateTime<Local>,
    #[ts(ts_as="str")]
    pub utc: DateTime<Utc>,
    #[ts(ts_as="[u8]")]
    pub ip4_addr1 : ArrayVec<[u8; 4]>,
    #[ts(ts_type="number[]")]
    pub ip4_addr2 : ArrayVec<[u8; 4]>
}

类型守卫

参见 类型守卫。

typescript-definitions 类型守卫提供了一种快速失败的防御性检查，以确保随机的JSON对象与给定的 typescript-definitions 类型的布局和类型一致。

要启用它们，更改您的依赖项如下

typescript-definitions = { version="^0.1.10", features=["type-guards"] }

使用 on 功能，您可以关闭任何结构/枚举的守卫生成，方法是在 #[ts(guard=false)] 属性中。

如果您的结构体有一个长的数据列表，如 Vec<data>，则可以使用字段属性 #[ts(array_check="first")] 阻止对整个数组的类型检查，它将只检查第一行。

示例

use serde::Serialize;
use typescript_definitions::{TypeScriptify, TypeScriptifyTrait};
#[derive(TypeScriptify)]
pub struct Maybe {
    maybe : Option<String>
}

println!("{}", Maybe::type_script_guard().unwrap());

将在通过 prettier 处理后打印（

export const isMaybe = (obj: any): obj is Maybe => {
  if (obj == undefined) return false;
  if (obj.maybe === undefined) return false;
  {
    const val = obj.maybe;
    if (!(val === null)) {
      if (!(typeof val === "string")) return false;
    }
  }
  return true;
};

限制

JSON的限制

例如，非字符串键的映射：这是

use wasm_bindgen::prelude::*;
use serde::Serialize;
use std::collections::HashMap;
use typescript_definitions::TypescriptDefinition;
#[derive(Serialize, TypescriptDefinition)]
pub struct IntMap {
    pub intmap: HashMap<i32, i32>,
}

将生成

export type IntMap = { intmap: { [key: number]: number } };

但TypeScript编译器将对此进行检查

let v : IntMap = { intmap: {  "6": 6, 4: 4 } };

因此，生成的守卫也会检查整数键是否为 (+key !== NaN)。

use wasm_bindgen::prelude::*;
use serde::Serialize;
use typescript_definitions::TypescriptDefinition;

#[derive(Serialize, TypescriptDefinition)]
pub struct Value<T> {
    pub value: T,
}

#[derive(Serialize, TypescriptDefinition)]
pub struct DependsOnValue {
    pub value: Vec<Value<i32>>,
}

use wasm_bindgen::prelude::*;
use serde::Serialize;
use typescript_definitions::TypescriptDefinition;

#[derive(Serialize, TypescriptDefinition)]
pub struct Value<T> {
    pub value: T,
}

#[derive(Serialize, TypescriptDefinition)]
pub struct DependsOnValue {
    #[ts(ts_guard="{value: number[]}")]
    pub value: Value<Vec<i32>>,
}

const isT = <T>(o: any, typename: string): o is T => {
    // typename is the stringified type that we are
    // expecting e.g. `number` or `{a: number, b: string}[]` etc.
    // 
    if (typename !== "number[]") return false;
    if (!Array.isArray(o)) return false;
    for (let v of o) {
        if (typeof v !== "number") return false;
    }
    return true
}

use serde::Serialize;
use typescript_definitions::{TypeScriptify, TypeScriptifyTrait};
#[derive(Serialize, TypeScriptify)]
/// This is some API Event.
struct Event {
    what : String,
    pos : Vec<(i32,i32)>
}

assert_eq!(Event::type_script_ify(), "\
// This is some API Event.
export type Event = { what: string; pos: [ number , number ][] };"
)

// #[cfg(target_arch="wasm32")]
use wasm_bindgen::prelude::*;
use serde::Serialize;
use typescript_definitions::{TypescriptDefinition};
#[derive(Serialize)]
struct B<T> {q: T}

#[derive(Serialize, TypescriptDefinition)]
struct A {
    x : f64,
    b: B<f64>,
}

enum Color {
    Red,
    Green,
    Blue
}

enum Color {
    Red = "Red",
    Green ="Green",
    Blue = "Blue"
}

use std::borrow::Cow as Pig;
use typescript_definitions::{TypeScriptify,TypeScriptifyTrait};

#[derive(TypeScriptify)]
struct S<'a> {
    pig: Pig<'a, str>,
}
println!("{}", S::type_script_ify());