feat(napi/minify): return parse errors (#12112)

closes #12101

Author: Boshen

Cargo.lock

@@ -24,7 +24,9 @@ doctest = false
 [dependencies]
 oxc_allocator = { workspace = true }
 oxc_codegen = { workspace = true }
+oxc_diagnostics = { workspace = true }
 oxc_minifier = { workspace = true }
+oxc_napi = { workspace = true }
 oxc_parser = { workspace = true }
 oxc_sourcemap = { workspace = true, features = ["napi", "rayon"] }
 oxc_span = { workspace = true }

napi/minify/Cargo.toml

@@ -103,6 +103,33 @@ export interface MinifyOptions {
 export interface MinifyResult {
   code: string
   map?: SourceMap
+  errors: Array<OxcError>
+}
+export interface Comment {
+  type: 'Line' | 'Block'
+  value: string
+  start: number
+  end: number
+}
+
+export interface ErrorLabel {
+  message?: string
+  start: number
+  end: number
+}
+
+export interface OxcError {
+  severity: Severity
+  message: string
+  labels: Array<ErrorLabel>
+  helpMessage?: string
+  codeframe?: string
+}
+
+export declare const enum Severity {
+  Error = 'Error',
+  Warning = 'Warning',
+  Advice = 'Advice'
 }
 export interface SourceMap {
   file?: string

napi/minify/index.d.ts

@@ -384,3 +384,4 @@ if (!nativeBinding) {
 
 module.exports = nativeBinding
 module.exports.minify = nativeBinding.minify
+module.exports.Severity = nativeBinding.Severity

napi/minify/index.js

@@ -55,3 +55,4 @@ const {
 })
 export default __napiModule.exports
 export const minify = __napiModule.exports.minify
+export const Severity = __napiModule.exports.Severity

napi/minify/minify.wasi-browser.js

@@ -86,3 +86,4 @@ const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule
 })
 module.exports = __napiModule.exports
 module.exports.minify = __napiModule.exports.minify
+module.exports.Severity = __napiModule.exports.Severity

napi/minify/minify.wasi.cjs

@@ -1,4 +1,4 @@
-#![expect(clippy::needless_pass_by_value, clippy::missing_errors_doc)]
+#![expect(clippy::needless_pass_by_value)]
 
 #[cfg(all(
     feature = "allocator",
@@ -16,31 +16,52 @@ use napi_derive::napi;
 
 use oxc_allocator::Allocator;
 use oxc_codegen::{Codegen, CodegenOptions};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_minifier::Minifier;
+use oxc_napi::OxcError;
 use oxc_parser::Parser;
+use oxc_sourcemap::napi::SourceMap;
 use oxc_span::SourceType;
 
-use crate::options::{MinifyOptions, MinifyResult};
+use crate::options::MinifyOptions;
+
+#[derive(Default)]
+#[napi(object)]
+pub struct MinifyResult {
+    pub code: String,
+    pub map: Option<SourceMap>,
+    pub errors: Vec<OxcError>,
+}
 
 /// Minify synchronously.
 #[napi]
 pub fn minify(
     filename: String,
     source_text: String,
     options: Option<MinifyOptions>,
-) -> napi::Result<MinifyResult> {
+) -> MinifyResult {
     let options = options.unwrap_or_default();
 
     let minifier_options = match oxc_minifier::MinifierOptions::try_from(&options) {
         Ok(options) => options,
-        Err(error) => return Err(napi::Error::from_reason(&error)),
+        Err(error) => {
+            return MinifyResult {
+                errors: OxcError::from_diagnostics(
+                    &filename,
+                    &source_text,
+                    vec![OxcDiagnostic::error(error)],
+                ),
+                ..MinifyResult::default()
+            };
+        }
     };
 
     let allocator = Allocator::default();
 
     let source_type = SourceType::from_path(&filename).unwrap_or_default();
 
-    let mut program = Parser::new(&allocator, &source_text, source_type).parse().program;
+    let parser_ret = Parser::new(&allocator, &source_text, source_type).parse();
+    let mut program = parser_ret.program;
 
     let scoping = Minifier::new(minifier_options).build(&allocator, &mut program).scoping;
 
@@ -52,10 +73,14 @@ pub fn minify(
     };
 
     if options.sourcemap == Some(true) {
-        codegen_options.source_map_path = Some(PathBuf::from(filename));
+        codegen_options.source_map_path = Some(PathBuf::from(&filename));
     }
 
     let ret = Codegen::new().with_options(codegen_options).with_scoping(scoping).build(&program);
 
-    Ok(MinifyResult { code: ret.code, map: ret.map.map(oxc_sourcemap::napi::SourceMap::from) })
+    MinifyResult {
+        code: ret.code,
+        map: ret.map.map(oxc_sourcemap::napi::SourceMap::from),
+        errors: OxcError::from_diagnostics(&filename, &source_text, parser_ret.errors),
+    }
 }

napi/minify/src/lib.rs

@@ -4,7 +4,6 @@ use napi::Either;
 use napi_derive::napi;
 
 use oxc_minifier::TreeShakeOptions;
-use oxc_sourcemap::napi::SourceMap;
 use oxc_syntax::es_target::ESTarget;
 
 #[napi(object)]
@@ -192,10 +191,3 @@ impl TryFrom<&MinifyOptions> for oxc_minifier::MinifierOptions {
         Ok(oxc_minifier::MinifierOptions { compress, mangle })
     }
 }
-
-#[napi(object)]
-pub struct MinifyResult {
-    pub code: String,
-
-    pub map: Option<SourceMap>,
-}

napi/minify/src/options.rs

@@ -23,21 +23,29 @@ describe('simple', () => {
         ],
         'version': 3,
       },
+      'errors': [],
     });
   });
 
   it('can turn off everything', () => {
     const ret = minify('test.js', code, { compress: false, mangle: false, codegen: { removeWhitespace: false } });
-    expect(ret).toStrictEqual({
-      'code': 'function foo() {\n\tvar bar;\n\tbar(undefined);\n}\nfoo();\n',
-    });
+    expect(ret.code).toBe(
+      'function foo() {\n\tvar bar;\n\tbar(undefined);\n}\nfoo();\n',
+    );
   });
 
   it('defaults to esnext', () => {
     const code = 'try { foo } catch (e) {}';
     const ret = minify('test.js', code);
     expect(ret.code).toBe('try{foo}catch{}');
   });
+
+  it('returns parser error', () => {
+    const code = 'const';
+    const ret = minify('test.js', code);
+    expect(ret.code).toBe('');
+    expect(ret.errors.length).toBe(1);
+  });
 });
 
 describe('worker', () => {