wasm-bindgen/wasm-bindgen

Features

• JavaScript Interop - Exposes internal Rust functions as callable modules for execution within JavaScript environments.
• WebAssembly Glue Code Generators - Automatically generates the necessary JavaScript and WebAssembly glue code to facilitate high-level communication between Rust and the browser.
• Complex Data Type Exchange - Enables the exchange of complex objects, strings, and classes beyond simple numeric types.
• Type-Safe Binding Generators - Generates static TypeScript type definitions to ensure data consistency and provide autocomplete when calling modules from JavaScript.
• Linear Memory Managers - Reads and writes data to a shared contiguous buffer to exchange strings and objects between the host and module.
• Foreign Function Bindings - Invokes native functions and web APIs from within Rust source code by defining external bindings.
• Host Function Exposure - Allows compiled modules to call external JavaScript logic and system APIs for tasks such as DOM manipulation.
• JavaScript Interoperability - Facilitates high-level communication and data exchange between compiled Rust modules and the host JavaScript environment.
• Module Interface Exports - Exposes functions and classes from a compiled WebAssembly module so they can be called by the host environment.
• Language Interoperability Automation - Automates the conversion of data types and function calls between Rust and JavaScript.
• WebAssembly Bridges - Provides a high-level bridge for exporting functions and exchanging complex data types between WebAssembly and JavaScript.
• Cross-Language Type Export - Generates JavaScript classes and type definitions from internal Rust structures to maintain consistency.
• Type Conversion and Casting - Transforms data between JavaScript values and Rust types, including primitives, strings, and vectors.
• Type Definition Generators - Automatically synthesizes static TypeScript type definitions from compiled Rust structures for use in external environments.
• Host Environment Integration - Embeds functions and objects from the host environment into Rust source code for use within compiled modules.
• Shared Memory Buffers - Provides shared memory buffers and atomic operations to coordinate execution across multiple web worker threads.
• Async Runtime Bridges - Translates asynchronous handles between the host event loop and the guest runtime to allow cross-environment awaiting.
• Asynchronous Promise Interfaces - Provides mechanisms to bridge JavaScript promises and Rust futures for cross-environment asynchronous operations.
• Cross-Language Prototype Mapping - Creates prototype chains between exported structures to support method dispatch and instance checks in JavaScript.
• ES Module Integrations - Provides a compatibility layer to import and use compiled WebAssembly modules as standard ECMAScript modules.
• JavaScript Multi-Threading - Synchronizes memory and atomics between web workers and browser threads to enable multi-threaded execution.
• Attribute-Based Mappings - Uses source-level metadata attributes to automate the generation of function signatures and type mappings.
• Runtime Exception Handling - Wraps exported functions to catch JavaScript exceptions and translate them into native Rust error types.
• Cross-Runtime Closure Wrapping - Wraps internal Rust closures for use in the host environment with options for ownership transfer.
• Cross-Runtime Exception Translation - Intercepts native Wasm traps and JavaScript errors to translate them into language-specific error types across the boundary.
• TypeScript Type Definitions - Creates automatic TypeScript type bindings to provide autocomplete and static checking for compiled modules.
• Foreign Function Interface - Facilitates interaction between Wasm and JavaScript.

Star 历史