Merge in next branch

.github/workflows/on-pull-request.yml

@@ -0,0 +1,77 @@
+name: Build and Test
+
+on:
+    push:
+        branches: [main, next]
+    pull_request:
+        branches: ["*"]
+
+jobs:
+    build:
+        name: Build
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout sources
+              uses: actions/checkout@v3
+
+            - name: Install toolchain
+              uses: actions-rs/toolchain@v1
+              with:
+                  profile: minimal
+                  toolchain: stable
+                  override: true
+
+            - name: Check
+              uses: actions-rs/cargo@v1
+              with:
+                  command: check
+
+            - name: Build
+              uses: actions-rs/cargo@v1
+              with:
+                  command: build
+    test:
+        name: Test
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout sources
+              uses: actions/checkout@v3
+
+            - name: Install toolchain
+              uses: actions-rs/toolchain@v1
+              with:
+                  profile: minimal
+                  toolchain: stable
+                  override: true
+                  components: rustfmt
+
+            - name: Add cargo-expand
+              run: cargo install cargo-expand
+
+            - name: Test
+              uses: actions-rs/cargo@v1
+              with:
+                  command: test
+    lint:
+        name: Lint
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout sources
+              uses: actions/checkout@v3
+
+            - name: Install toolchain
+              uses: actions-rs/toolchain@v1
+              with:
+                  profile: minimal
+                  toolchain: stable
+                  override: true
+                  components: rustfmt, clippy
+
+            - name: Cargo fmt
+              uses: actions-rs/cargo@v1
+              with:
+                  command: fmt
+                  args: --all -- --check

README.md

@@ -1,6 +1,6 @@
-# Tsify
+# Tsify-next
 
-Tsify is a library for generating TypeScript definitions from Rust code.
+Tsify-next is a library for generating TypeScript definitions from Rust code. The original [Tsify](https://github.com/madonoharu/tsify) appears to be in hybernation mode, so this for incorporates updates until main Tsify project comes back to life.
 
 Using this with [`wasm-bindgen`](https://github.com/rustwasm/wasm-bindgen) will automatically output the types to `.d.ts`.
 

src/lib.rs

@@ -2,15 +2,28 @@
 
 #[cfg(all(feature = "json", not(feature = "js")))]
 pub use gloo_utils::format::JsValueSerdeExt;
+#[cfg(feature = "js")]
+pub use serde_wasm_bindgen;
 pub use tsify_macros::*;
 #[cfg(feature = "wasm-bindgen")]
 use wasm_bindgen::{JsCast, JsValue};
 
+pub struct SerializationConfig {
+    pub missing_as_null: bool,
+    pub hashmap_as_object: bool,
+    pub large_number_types_as_bigints: bool,
+}
+
 pub trait Tsify {
     #[cfg(feature = "wasm-bindgen")]
     type JsType: JsCast;
 
     const DECL: &'static str;
+    const SERIALIZATION_CONFIG: SerializationConfig = SerializationConfig {
+        missing_as_null: false,
+        hashmap_as_object: false,
+        large_number_types_as_bigints: false,
+    };
 
     #[cfg(all(feature = "json", not(feature = "js")))]
     #[inline]
@@ -36,7 +49,12 @@ pub trait Tsify {
     where
         Self: serde::Serialize,
     {
-        serde_wasm_bindgen::to_value(self).map(JsCast::unchecked_from_js)
+        let config = <Self as Tsify>::SERIALIZATION_CONFIG;
+        let serializer = serde_wasm_bindgen::Serializer::new()
+            .serialize_missing_as_null(config.missing_as_null)
+            .serialize_maps_as_objects(config.hashmap_as_object)
+            .serialize_large_number_types_as_bigints(config.large_number_types_as_bigints);
+        self.serialize(&serializer).map(JsCast::unchecked_from_js)
     }
 
     #[cfg(feature = "js")]

tests/affixes.rs

@@ -0,0 +1,116 @@
+#![allow(dead_code)]
+
+use indoc::indoc;
+use pretty_assertions::assert_eq;
+use tsify::Tsify;
+
+#[test]
+fn test_prefix() {
+    type MyType = u32;
+
+    #[derive(Tsify)]
+    #[tsify(type_prefix = "Special")]
+    struct PrefixedStruct {
+        // Make sure that prefix isn't applied to builtin types
+        x: u32,
+        y: MyType,
+    }
+
+    assert_eq!(
+        PrefixedStruct::DECL,
+        indoc! {"
+            export interface SpecialPrefixedStruct {
+                x: number;
+                y: SpecialMyType;
+            }"
+        }
+    );
+
+    #[derive(Tsify)]
+    #[tsify(type_prefix = "Special")]
+    enum PrefixedEnum {
+        VariantA(MyType),
+        VariantB(u32),
+    }
+
+    assert_eq!(
+        PrefixedEnum::DECL,
+        indoc! {"
+            export type SpecialPrefixedEnum = { VariantA: SpecialMyType } | { VariantB: number };"
+        }
+    );
+}
+
+#[test]
+fn test_suffix() {
+    type MyType = u32;
+
+    #[derive(Tsify)]
+    #[tsify(type_suffix = "Special")]
+    struct SuffixedStruct {
+        // Make sure that prefix isn't applied to builtin types
+        x: u32,
+        y: MyType,
+    }
+
+    assert_eq!(
+        SuffixedStruct::DECL,
+        indoc! {"
+            export interface SuffixedStructSpecial {
+                x: number;
+                y: MyTypeSpecial;
+            }"
+        }
+    );
+
+    #[derive(Tsify)]
+    #[tsify(type_suffix = "Special")]
+    enum SuffixedEnum {
+        VariantA(MyType),
+        VariantB(u32),
+    }
+
+    assert_eq!(
+        SuffixedEnum::DECL,
+        indoc! {"
+            export type SuffixedEnumSpecial = { VariantA: MyTypeSpecial } | { VariantB: number };"
+        }
+    );
+}
+
+#[test]
+fn test_prefix_suffix() {
+    type MyType = u32;
+
+    #[derive(Tsify)]
+    #[tsify(type_prefix = "Pre", type_suffix = "Suf")]
+    struct DoubleAffixedStruct {
+        // Make sure that prefix isn't applied to builtin types
+        x: u32,
+        y: MyType,
+    }
+
+    assert_eq!(
+        DoubleAffixedStruct::DECL,
+        indoc! {"
+            export interface PreDoubleAffixedStructSuf {
+                x: number;
+                y: PreMyTypeSuf;
+            }"
+        }
+    );
+
+    #[derive(Tsify)]
+    #[tsify(type_prefix = "Pre", type_suffix = "Suf")]
+    enum DoubleAffixedEnum {
+        VariantA(MyType),
+        VariantB(u32),
+    }
+
+    assert_eq!(
+        DoubleAffixedEnum::DECL,
+        indoc! {"
+            export type PreDoubleAffixedEnumSuf = { VariantA: PreMyTypeSuf } | { VariantB: number };"
+        }
+    );
+}