Crate stdweb

Source
Expand description

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§

Attribute Macros§