Struct ComponentEncoder

pub struct ComponentEncoder { /* private fields */ }

An encoder of components based on wit interface definitions.

Implementations

impl ComponentEncoder

pub fn module(self, module: &[u8]) -> Result<Self>

Set the core module to encode as a component. This method will also parse any component type information stored in custom sections inside the module, and add them as the interface, imports, and exports. It will also add any producers information inside the component type information to the core module.

pub fn validate(self, validate: bool) -> Self

Sets whether or not the encoder will validate its output.

pub fn merge_imports_based_on_semver(self, merge: bool) -> Self

Sets whether to merge imports based on semver to the specified value.

This affects how when to WIT worlds are merged together, for example from two different libraries, whether their imports are unified when the semver version ranges for interface allow it.

This is enabled by default.

pub fn reject_legacy_names(self, reject: bool) -> Self

Sets whether to reject the historical mangling/name scheme for core wasm imports/exports as they map to the component model.

The wit-component crate supported a different set of names prior to WebAssembly/component-model#378 and this can be used to disable this support.

This is disabled by default.

pub fn adapter(self, name: &str, bytes: &[u8]) -> Result<Self>

Specifies a new adapter which is used to translate from a historical wasm ABI to the canonical ABI and the interface provided.

This is primarily used to polyfill, for example, wasi_snapshot_preview1 with a component-model using interface. The name provided is the module name of the adapter that is being polyfilled, for example "wasi_snapshot_preview1".

The bytes provided is a core wasm module which implements the name interface in terms of the interface interface. This core wasm module is severely restricted in its shape, for example it cannot have any data segments or element segments.

The interface provided is the component-model-using-interface that the wasm module specified by bytes imports. The bytes will then import interface and export functions to get imported from the module name in the core wasm that’s being wrapped.

pub fn library( self, name: &str, bytes: &[u8], library_info: LibraryInfo, ) -> Result<Self>

Specifies a shared-everything library to link into the component.

Unlike adapters, libraries may have data and/or element segments, but they must operate on an imported memory and table, respectively. In this case, the correct amount of space is presumed to have been statically allocated in the main module’s memory and table at the offsets which the segments target, e.g. as arranged by super::linking::Linker.

Libraries are treated similarly to adapters, except that they are not “minified” the way adapters are, and instantiation is controlled declaratively via the library_info parameter.

pub fn realloc_via_memory_grow(self, value: bool) -> Self

True if the realloc and stack allocation should use memory.grow The default is to use the main module realloc Can be useful if cabi_realloc cannot be called before the host runtime is initialized.

pub fn import_name_map(self, map: HashMap<String, String>) -> Self

The instance import name map to use.

This is used to rename instance imports in the final component.

For example, if there is an instance import foo:bar/baz and it is desired that the import actually be an unlocked-dep name, then foo:bar/baz can be mapped to unlocked-dep=<a:b/c@{>=x.y.z}>.

Note: the replacement names are not validated during encoding unless the validate option is set to true.

pub fn encode(&mut self) -> Result<Vec<u8>>

Encode the component and return the bytes.

Trait Implementations

impl Default for ComponentEncoder

fn default() -> ComponentEncoder

Returns the “default value” for a type.