[oden-js] Get module exports

oden-js/src/context.rs

@@ -106,6 +106,14 @@ impl ContextRef {
         unsafe { sys::JS_EnableBignumExt(self.ctx, if enable { 1 } else { 0 }) }
     }
 
+    pub fn load_module(&self, input: &str, filename: &str) -> Result<Value> {
+        let val = self.eval(input, filename, EvalType::Module, EvalFlags::COMPILE_ONLY)?;
+        assert!(val.is_module());
+        val.eval_function(self)?;
+
+        Ok(val)
+    }
+
     /// Evaluate the specified JavaScript code.
     pub fn eval(
         &self,
@@ -482,4 +490,23 @@ mod tests {
             .unwrap();
         assert_eq!(String::from("UNSAFE"), result.to_string(&ctx).unwrap());
     }
+
+    #[test]
+    fn modules_with_exports() {
+        let ctx = Context::new(Runtime::new());
+        let module = ctx
+            .load_module("const foo = 123; export { foo };", "main.js")
+            .expect("Could not load!");
+        assert_eq!(module.value_type(), ValueType::Module);
+
+        let foo = module
+            .get_module_export(&ctx, "foo")
+            .expect("Could not get export");
+        assert_eq!(String::from("123"), foo.to_string(&ctx).unwrap());
+
+        let bar = module
+            .get_module_export(&ctx, "bar")
+            .expect("Could not get export");
+        assert!(bar.is_undefined());
+    }
 }

oden-js/src/value.rs

@@ -1,6 +1,6 @@
 use crate::{AtomRef, ContextRef, Error, Result, Runtime, RustFunction};
 use oden_js_sys as sys;
-use std::ffi::CStr;
+use std::ffi::{CStr, CString};
 use std::fmt;
 use std::ops::{Deref, DerefMut};
 
@@ -309,6 +309,25 @@ impl ValueRef {
 
         Ok(result)
     }
+
+    pub fn get_module_export(&self, ctx: &ContextRef, export: &str) -> Result<Value> {
+        if self.value_type() != ValueType::Module {
+            return Err(Error::InvalidType {
+                expected: ValueType::Bool,
+                found: self.value_type(),
+            });
+        }
+
+        let c_value = match CString::new(export) {
+            Ok(cs) => Ok(cs),
+            Err(_) => Err(Error::UnexpectedNul),
+        }?;
+
+        unsafe {
+            let module = sys::JS_ValueGetPtr(self.val) as *mut sys::JSModuleDef;
+            ctx.check_exception(sys::JS_GetModuleExport(ctx.ctx, module, c_value.into_raw()))
+        }
+    }
 }
 
 impl<'ctx> fmt::Debug for ValueRef {