[][src]Crate stdweb

The goal of this crate is to provide Rust bindings to the Web APIs and to allow a high degree of interoperability between Rust and JavaScript.

Examples

You can directly embed JavaScript code into Rust:

let message = "Hello, 世界!";
let result = js! {
    alert( @{message} );
    return 2 + 2 * 2;
};

println!( "2 + 2 * 2 = {:?}", result );

Closures are also supported:

let print_hello = |name: String| {
    println!( "Hello, {}!", name );
};

js! {
    var print_hello = @{print_hello};
    print_hello( "Bob" );
    print_hello.drop(); // Necessary to clean up the closure on Rust's side.
}

You can also pass arbitrary structures thanks to serde:

#[derive(Serialize)]
struct Person {
    name: String,
    age: i32
}

js_serializable!( Person );

js! {
    var person = @{person};
    console.log( person.name + " is " + person.age + " years old." );
};

This crate also exposes a number of Web APIs, for example:

let button = document().query_selector( "#hide-button" ).unwrap().unwrap();
button.add_event_listener( move |_: ClickEvent| {
    for anchor in document().query_selector_all( "#main a" ) {
        js!( @{anchor}.style = "display: none;"; );
    }
});

Exposing Rust functions to JavaScript is supported too:

#[js_export]
fn hash( string: String ) -> String {
    let mut hasher = Sha1::new();
    hasher.update( string.as_bytes() );
    hasher.digest().to_string()
}

Then you can do this from Node.js:

var hasher = require( "hasher.js" ); // Where `hasher.js` is generated from Rust code.
console.log( hasher.hash( "Hello world!" ) );

Or you can take the same .js file and use it in a web browser:

<script src="hasher.js"></script>
<script>
    Rust.hasher.then( function( hasher ) {
        console.log( hasher.hash( "Hello world!" ) );
    });
</script>

If you're using Parcel you can also use our experimental Parcel plugin; first do this in your existing Parcel project:

$ npm install --save parcel-plugin-cargo-web

And then simply:

import hasher from "./hasher/Cargo.toml";
console.log( hasher.hash( "Hello world!" ) );

Modules

serde

A module with serde-related APIs.

traits

A module containing reexports of all of our interface traits.

unstable

A module containing stable counterparts to currently unstable Rust features.

web

A module with bindings to the Web APIs.

Macros

console

Calls methods on the JavaScript console object.

js

Embeds JavaScript code into your Rust program.

js_deserializable

A macro which makes it possible to convert an instance of a given type implementing Serde's Deserialize into a Value using TryInto.

js_serializable

A macro which makes it possible to pass an instance of a given type implementing Serde's Serialize into the js! macro.

Structs

Array

A type representing a JavaScript array.

DiscardOnDrop

If you have a value which implements Discard, you can use DiscardOnDrop::new(value) which will wrap the value. When the wrapper is dropped it will automatically call value.discard().

Mut

A wrapper for passing FnMut callbacks into the js! macro.

Null

A unit type representing JavaScript's null.

Number

A type representing a JavaScript number.

Object

A type representing a JavaScript object.

Once

A wrapper for passing FnOnce callbacks into the js! macro.

Reference

A type representing a reference to a JavaScript value.

Symbol

A type representing a JavaScript Symbol.

Undefined

A unit type representing JavaScript's undefined.

UnsafeTypedArray

A wrapper type for exposing raw Rust slices as TypedArrays at zero cost without copying.

Enums

Value

A type representing a JavaScript value.

Traits

InstanceOf

A trait to check whenever a given Reference is of a certain type.

JsSerialize

A trait for types which can be serialized through the js! macro.

ReferenceType

A trait for types which wrap a reference to a JavaScript object.

Functions

event_loop

Runs Emscripten's event loop.

initialize

Initializes the library.

Attribute Macros

async_test