✨ Settle on wasm api design

... by implementing `UserId` as an example, on both the Rust and the
TypeScript sides, since it's one of the simplest packets.

`tsify-next` is used with `wasm-bindgen` for bindgen. One alternative
that has been considered is using pure `wasm-bindgen`, but that does not
support Rust-style `enum`s. We could use `serde-wasm-bindgen` to
overcome that limitation, but doing so requires that we return
`JsValue`s on the wasm-js boundary, which prevents strong typing and
`.d.ts` generation. To return our `struct`s directly, we have to
implement `IntoWasmAbi` and other traits manually, which is not quite
ergonomic, and still does not allow `.d.ts` generation. `tsify-next`
helps generate those trait implementations, as well as the `.d.ts` file,
so it's considered the best solution at present.

Note that `tsify-next` is a successor of `tsify`. The latter has been
unmaintained for over 1.5 years at the time of this commit. We could
switch to `tsify` if it gets updated in the future.

Furthermore, if `wasm-bindgen` adds support for Rust-style `enum`s, we
could stop using `tsify-next` (see ref for the tracking issue).

`ts-rs` has also been considered, but it does not generate the
`wasm-bindgen::convert` traits, and generates each `struct`s and `enum`s
into their own `.d.ts` files, which is quite messy.

Ref: rustwasm/wasm-bindgen#2407

Author: shniubobo

Cargo.lock

@@ -9,8 +9,8 @@ crate-type = ["cdylib"]
 [dependencies]
 pgp = { version = "0.14.2", features = ["wasm"] }
 serde = { version = "1.0.216", features = ["derive"] }
-serde-wasm-bindgen = "0.6.5"
 thiserror = "2.0.8"
+tsify-next = { version = "0.5.4", features = ["js"], default-features = false }
 wasm-bindgen = "0.2.99"
 
 [dev-dependencies]

pgpvis-core/Cargo.toml

@@ -1,51 +1,80 @@
-use std::collections::HashMap;
 use std::iter::Iterator;
 
-use pgp::{armor::Dearmor, packet::PacketParser};
-use serde::{Deserialize, Serialize};
+use pgp::{
+    armor::Dearmor,
+    packet::{PacketParser, PacketTrait},
+};
+use serde::Serialize;
+use tsify_next::{declare, Tsify};
 use wasm_bindgen::prelude::*;
 
-#[derive(Debug, Serialize, Deserialize)]
-struct ParseOutput(HashMap<String, String>);
+#[declare]
+pub type Message = Vec<Packet>;
 
-impl From<HashMap<String, String>> for ParseOutput {
-    fn from(value: HashMap<String, String>) -> Self {
-        Self(value)
+#[derive(Debug, Serialize, Tsify)]
+#[tsify(into_wasm_abi)]
+pub enum Packet {
+    UserId(UserId),
+    Unknown,
+}
+
+impl From<pgp::packet::Packet> for Packet {
+    fn from(value: pgp::packet::Packet) -> Self {
+        use pgp::packet::Packet as RpgpPacket;
+        match value {
+            RpgpPacket::UserId(user_id) => Self::UserId(user_id.into()),
+            _ => Self::Unknown,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Tsify)]
+pub struct UserId {
+    pub packet_version: Version,
+    pub id: String,
+}
+
+impl From<pgp::packet::UserId> for UserId {
+    fn from(value: pgp::packet::UserId) -> Self {
+        Self {
+            packet_version: value.packet_version().into(),
+            id: value.id().to_string(),
+        }
     }
 }
 
-impl TryFrom<ParseOutput> for JsValue {
-    type Error = Error;
+#[derive(Debug, Serialize, Tsify)]
+pub enum Version {
+    Old,
+    New,
+}
 
-    fn try_from(value: ParseOutput) -> Result<Self, Self::Error> {
-        Ok(serde_wasm_bindgen::to_value(&value)?)
+impl From<pgp::types::Version> for Version {
+    fn from(value: pgp::types::Version) -> Self {
+        match value {
+            pgp::types::Version::Old => Self::Old,
+            pgp::types::Version::New => Self::New,
+        }
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 enum Error {
-    #[error("failed to serialize to JsValue")]
-    Serialization(#[from] serde_wasm_bindgen::Error),
     #[error("failed to parse packet")]
     Parse(#[from] pgp::errors::Error),
 }
 
-#[wasm_bindgen(js_name = parse_armored)]
-pub fn parse_armored_js(message: &str) -> Result<JsValue, JsError> {
-    Ok(parse_armored(message)?.try_into()?)
-}
-
-fn parse_armored(message: &str) -> Result<ParseOutput, Error> {
+#[wasm_bindgen]
+pub fn parse_armored(message: &str) -> Result<Message, JsError> {
     let dearmor = Dearmor::new(message.as_bytes());
     let packet_parser = PacketParser::new(dearmor);
-    let parse_output: HashMap<_, _> = packet_parser
-        .enumerate()
+    let parse_output: Result<Vec<Packet>, Error> = packet_parser
         .map(|packet| match packet {
-            (idx, Ok(packet)) => (idx.to_string(), format!("{packet:?}")),
-            (idx, Err(err)) => (idx.to_string(), Error::from(err).to_string()),
+            Ok(packet) => Ok(packet.into()),
+            Err(err) => Err(err.into()),
         })
         .collect();
-    Ok(parse_output.into())
+    Ok(parse_output?)
 }
 
 #[cfg(test)]
@@ -57,6 +86,12 @@ mod tests {
     #[wasm_bindgen_test]
     fn test_parse_armored_js() {
         let parse_output = parse_armored(include_str!("../tests/data/linus.gpg.asc")).unwrap();
-        console_log!("{parse_output:#?}")
+        for packet in parse_output {
+            if let Packet::UserId(user_id) = packet {
+                let packet_version = user_id.packet_version;
+                let id = user_id.id;
+                console_log!("{packet_version:?}: {id}");
+            }
+        }
     }
 }

pgpvis-core/src/lib.rs

@@ -1,16 +1,37 @@
 <script setup lang="ts">
-import { ref } from "vue";
+import { computed, ref } from "vue";
 
-import { parse_armored } from "pgpvis-core";
+import { type Message, parse_armored } from "pgpvis-core";
 
 const message = ref("");
-const packets = ref<Map<string, string>>();
+const packets = ref<Message>();
+
+const user_ids = computed(() => {
+  if (packets.value === undefined) {
+    return [];
+  }
+
+  const user_ids = [];
+  for (let packet of packets.value) {
+    if (packet === "Unknown") {
+      continue;
+    }
+    if ("UserId" in packet) {
+      user_ids.push(packet.UserId);
+    }
+  }
+  return user_ids;
+});
+
+function parse() {
+  packets.value = parse_armored(message.value);
+}
 </script>
 
 <template>
   <textarea v-model="message"></textarea>
-  <button @click="packets = parse_armored(message)">Parse</button>
-  <li v-for="[index, packet] in packets" :key="index">{{ index }} | {{ packet }}</li>
+  <button @click="parse">Parse</button>
+  <li v-for="(user_id, index) in user_ids" :key="index">{{ user_id.id }}</li>
 </template>
 
 <style scoped></style>