feat(ts/fast-strip): Throw js object instead of map (#10186)

**Related issue:**

 - Closes #10180

Author: kdy1

bindings/binding_typescript_wasm/__tests__/__snapshots__/transform.js.snap

@@ -1,13 +1,13 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`transform in strip-only mode should not emit 'Caused by: failed to parse' 1`] = `
-Map {
-  "code" => "InvalidSyntax",
-  "column" => 23,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "await isn't allowed in non-async function",
-  "snippet" => "Promise",
+{
+  "code": "InvalidSyntax",
+  "column": 23,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "await isn't allowed in non-async function",
+  "snippet": "Promise",
 }
 `;
 
@@ -38,24 +38,24 @@ exports[`transform in strip-only mode should remove declare enum 3`] = `
 `;
 
 exports[`transform in strip-only mode should report correct error for syntax error 1`] = `
-Map {
-  "code" => "InvalidSyntax",
-  "column" => 25,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "Expected ';', '}' or <eof>",
-  "snippet" => "syntax",
+{
+  "code": "InvalidSyntax",
+  "column": 25,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "Expected ';', '}' or <eof>",
+  "snippet": "syntax",
 }
 `;
 
 exports[`transform in strip-only mode should report correct error for unsupported syntax 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 0,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "TypeScript enum is not supported in strip-only mode",
-  "snippet" => "enum Foo {
+{
+  "code": "UnsupportedSyntax",
+  "column": 0,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "TypeScript enum is not supported in strip-only mode",
+  "snippet": "enum Foo {
                     a, b    
                     }",
 }
@@ -115,79 +115,79 @@ exports[`transform in strip-only mode should strip type declarations 1`] = `
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters a module 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 0,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
-  "snippet" => "module foo",
+{
+  "code": "UnsupportedSyntax",
+  "column": 0,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet": "module foo",
 }
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters a module 2`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 8,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
-  "snippet" => "module foo",
+{
+  "code": "UnsupportedSyntax",
+  "column": 8,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet": "module foo",
 }
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters a namespace 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 0,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "TypeScript namespace declaration is not supported in strip-only mode",
-  "snippet" => "namespace Foo { export const m = 1; }",
+{
+  "code": "UnsupportedSyntax",
+  "column": 0,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "TypeScript namespace declaration is not supported in strip-only mode",
+  "snippet": "namespace Foo { export const m = 1; }",
 }
 `;
 
 exports[`transform in strip-only mode should throw an error when it encounters an enum 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 0,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "TypeScript enum is not supported in strip-only mode",
-  "snippet" => "enum Foo {}",
+{
+  "code": "UnsupportedSyntax",
+  "column": 0,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "TypeScript enum is not supported in strip-only mode",
+  "snippet": "enum Foo {}",
 }
 `;
 
 exports[`transform in transform mode shoud throw an object even with deprecatedTsModuleAsError = true 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 0,
-  "filename" => "<anon>",
-  "line" => 1,
-  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
-  "snippet" => "module F",
+{
+  "code": "UnsupportedSyntax",
+  "column": 0,
+  "filename": "<anon>",
+  "line": 1,
+  "message": "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet": "module F",
 }
 `;
 
 exports[`transform in transform mode should throw an error when it encounters a declared module 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 8,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
-  "snippet" => "module foo",
+{
+  "code": "UnsupportedSyntax",
+  "column": 8,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet": "module foo",
 }
 `;
 
 exports[`transform in transform mode should throw an error when it encounters a module 1`] = `
-Map {
-  "code" => "UnsupportedSyntax",
-  "column" => 0,
-  "filename" => "test.ts",
-  "line" => 1,
-  "message" => "\`module\` keyword is not supported. Use \`namespace\` instead.",
-  "snippet" => "module foo",
+{
+  "code": "UnsupportedSyntax",
+  "column": 0,
+  "filename": "test.ts",
+  "line": 1,
+  "message": "\`module\` keyword is not supported. Use \`namespace\` instead.",
+  "snippet": "module foo",
 }
 `;
 

bindings/binding_typescript_wasm/src/lib.rs

@@ -56,11 +56,11 @@ pub fn transform_sync(input: JsValue, options: JsValue) -> Result<JsValue, JsVal
 
     match result {
         Ok(v) => Ok(serde_wasm_bindgen::to_value(&v)?),
-        Err(v) => Err(serde_wasm_bindgen::to_value(&v[0])?),
+        Err(errors) => Err(serde_wasm_bindgen::to_value(&errors[0])?),
     }
 }
 
-fn operate(input: String, options: Options) -> Result<TransformOutput, Vec<serde_json::Value>> {
+fn operate(input: String, options: Options) -> Result<TransformOutput, Vec<JsonDiagnostic>> {
     let cm = Lrc::new(SourceMap::default());
 
     try_with_json_handler(cm.clone(), |handler| {
@@ -70,11 +70,11 @@ fn operate(input: String, options: Options) -> Result<TransformOutput, Vec<serde
 
 #[derive(Clone)]
 struct LockedWriter {
-    errors: Arc<Mutex<Vec<serde_json::Value>>>,
+    errors: Arc<Mutex<Vec<JsonDiagnostic>>>,
     cm: Lrc<SourceMap>,
 }
 
-fn try_with_json_handler<F, Ret>(cm: Lrc<SourceMap>, op: F) -> Result<Ret, Vec<serde_json::Value>>
+fn try_with_json_handler<F, Ret>(cm: Lrc<SourceMap>, op: F) -> Result<Ret, Vec<JsonDiagnostic>>
 where
     F: FnOnce(&Handler) -> Result<Ret, Error>,
 {
@@ -127,19 +127,16 @@ impl Emitter for LockedWriter {
         let filename = loc.as_ref().map(|loc| loc.file.name.to_string());
 
         let error = JsonDiagnostic {
-            code: error_code,
-            message: &d.message[0].0,
-            snippet: snippet.as_deref(),
-            filename: filename.as_deref(),
+            code: error_code.map(|s| s.to_string()),
+            message: d.message[0].0.to_string(),
+            snippet,
+            filename,
             line: loc.as_ref().map(|loc| loc.line),
             column: loc.as_ref().map(|loc| loc.col_display),
             children,
         };
 
-        self.errors
-            .lock()
-            .unwrap()
-            .push(serde_json::to_value(&error).unwrap());
+        self.errors.lock().unwrap().push(error);
     }
 
     fn take_diagnostics(&mut self) -> Vec<String> {
@@ -148,31 +145,31 @@ impl Emitter for LockedWriter {
 }
 
 #[derive(Serialize)]
-struct JsonDiagnostic<'a> {
+struct JsonDiagnostic {
     /// Error code
     #[serde(skip_serializing_if = "Option::is_none")]
-    code: Option<&'a str>,
-    message: &'a str,
+    code: Option<String>,
+    message: String,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    snippet: Option<&'a str>,
+    snippet: Option<String>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    filename: Option<&'a str>,
+    filename: Option<String>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     line: Option<usize>,
     #[serde(skip_serializing_if = "Option::is_none")]
     column: Option<usize>,
 
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    children: Vec<JsonSubdiagnostic<'a>>,
+    children: Vec<JsonSubdiagnostic>,
 }
 
 #[derive(Serialize)]
-struct JsonSubdiagnostic<'a> {
-    message: &'a str,
-    snippet: Option<&'a str>,
-    filename: &'a str,
+struct JsonSubdiagnostic {
+    message: String,
+    snippet: Option<String>,
+    filename: String,
     line: usize,
 }