Is it possible to rust data type to JsObject?

[bubbajoe]

I saw the class example here, but it's not quite what I was looking for.

I am trying to return an object from a NativeFunction and I wanted to know if it was possible to take that rust struct data type and turn into a JsObject/JsValue?

[jedel1043]

You can construct a JsObject from anything that implements Trace. Generally, you just need to add some derives to it and add a marker if the type has other types that don't implement Trace but that you're sure they don't contain any Gc pointers.

#[derive(Trace, Finalize, JsData)]
#[boa_gc(unsafe_empty_trace)]
struct MyType {
    field1: TypeWithoutTrace,
    field2: TypeWithoutTrace,
}

Of course, if you can implement Trace on TypeWithoutTrace it's much better because the derive works without the unsafe_empty_trace marker.

After that, just construct an object with the data you require:

let data = MyType { field1: TypeWithoutTrace::new(), field2: TypeWithoutTrace::new() };
let obj = JsObject::from_proto_and_data(prototype, data)

You'll have to pick a prototype for the object though. Generally, context.intrinsics().constructors().object().prototype() works well for almost all use cases, but if you want or don't need the Object prototype, you can just pass None to it.

To get the inner data, you can do object.downcast_ref/mut::<MyType>() if you want a direct reference to it, or object.downcast::<MyType>() if you want to convert the whole JsObject into JsObject<MyType>, which gives info to JsObject about its inner type, making it possible to access the inner data without having to downcast_ref/mut.

[jedel1043]

Oh, if you want to expose Rust data to JS code, I think Class is better for your use case. You can initialize the inner data in the Class::data_constructor method, then add a getter for that data on the Class::init method.

[jedel1043]

By the way, the previous method didn't work because inner JsObject data is not exposed to JS by default, it only stores data that can be accessed again from Rust code.

[bubbajoe]

Sorry, maybe my requirements a bit confusing, I am trying to return a struct value from rust that can be used in JS from a native_function. Everything that I have tried so far results in a seemingly empty object with no fields or functions.

Or perhaps I didn't understand you correctly, but this is my most recent trial using the Person class in the example

fn native_func(_this: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
    let obj = JsObject::from_proto_and_data(
        context.intrinsics().constructors().object().prototype(),
        // using the same Person class from examples
        person::Person::data_constructor(
            &JsValue::undefined(),
            &[js_string!("John").into(), JsValue::new(30)],
            context,
        )?,
    );
    Ok(obj.into())
}

Then i get...

let obj = native_func()
console.log(
  res.inheritedProperty,
  res.staticProperty,
  JSON.stringify(res, null, 2)
);
// undefined undefined {}

[jedel1043]

Ahhh, right. To construct an instance of Person you need to call either Class::from_data (if you already have the data you want to initialize) or Class::construct, if you want to construct from JS args. That will set the correct prototype, since you're setting it to Object in the snippet you provided.

fn native_func(_this: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
    let from_data = Person::from_data(Person::new(), context)?;
    let new_target = context.get_global_class::<Self>().expect("must have the class registered").constructor();
    let from_args = Person::construct(&new_target, &[js_string!("John").into(), JsValue::new(30)],
            context);
    // more code
}

[bubbajoe]

Thanks, I got it to work. Is it possible create a property which can be updated from JS.

For example, referencing the classes code from examples

const person = new Person("John", 30);
// Hello my name is John, I'm 30 years old
person.name = "Jay"
person.sayHello()
// Hello my name is Jay, I'm 30 years old

[jedel1043]

If what you want is to set the inner data using a setter, you can add a setter on Class::init and use JsObject::downcast_mut::<MyType>() to get a mutable reference to the inner data that you can modify.

On the other hand, if what you want is just to set a normal JS property on the object holding the Rust data, you can initialize those on the Class::object_constructor, which will set them as common object properties.