Binding for injected bundles as modules?

[ghost]

I want to

1. Define Javascript from Rust WASM
2. Inject it into the document from WASM as a module
3. Bind to the injected Javascript from rust

Is there a good way to do this already?

I noticed when searching, it is possible to inline ESM modules by creating blobs in the browser then linking to them. I also think inlining the bundle as a &'static str might be a solution. (and there was an issue opened related to supporting that, but I don't think there was progress made)

I just want to create bindings that do not require someone using them to use a bundler. I think the easiest way at the moment is to just use a CDN, (I wrote bindings for someone else's question using a CDN as an example) but I would prefer to have them injected from rust because it seems more reliable.

[ghost]

I commented in #3659 showing how I accomplished it.

I think this is a good way. I'm just commenting an example I created when adding dynamic import to another project. (as it wasn't obvious to me on how to fully complete it)

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen]
    pub type HelloWorldModule;

    #[wasm_bindgen(method, js_name = "helloWorld")]
    pub fn hello_world(this: &HelloWorldModule);

}

pub async fn load_dynamic_hello_world() -> HelloWorldModule {
    let module_as_str = r#"export function helloWorld() { console.log("Hello World!"); }"#;

    let from_data = Array::new();
    from_data.push(&module_as_str.into());

    let mut type_set: BlobPropertyBag = BlobPropertyBag::new();
    type_set.type_("application/javascript");

    let blob = Blob::new_with_str_sequence_and_options(&from_data, &type_set).unwrap();
    let module_address = web_sys::Url::create_object_url_with_blob(&blob).unwrap();

    let module_promise: Promise = js_sys::eval(&format!(r#"import ("{}")"#, module_address))
        .unwrap()
        .into();

    let module = JsFuture::from(module_promise).await.unwrap();

    let as_hello_world: HelloWorldModule = module.into();
    as_hello_world.hello_world();

    as_hello_world
}

I like it better than inline_js= as I think it's likely this will work more frequently with different rust frameworks. This is because inline_js bindings require the creator of the framework to explicitly support them.

The bindings are still not perfect though, because runtime modules require a different binding format. This results in different code, or unoptimized code when using only parts of a module for versions that try to include a package manager like NPM as an optional build. I'm closing this though, because this answered my question.