Enum anagolay_support::WasmArtifactSubType

pub enum WasmArtifactSubType {
    Cjs,
    Esm,
    Wasm,
    Web,
}

WASM artifacts commonly produced for a published entity. The subtype should be passed as parameter of the entity-defined artifact type enumeration, like in the example:

Examples

use codec::{Decode, Encode};
use anagolay_support::{ArtifactType, WasmArtifactSubType};

#[derive(Encode, Decode, Clone, PartialEq, Eq)]
enum OperationArtifactType {
  Wasm(WasmArtifactSubType), Docs, Git
}
impl ArtifactType for OperationArtifactType {}
#[derive(Encode, Decode, Clone, PartialEq, Eq)]
enum WorkflowArtifactType {
  Wasm(WasmArtifactSubType), Docs, Git
}
impl ArtifactType for WorkflowArtifactType {}

let op_esm_artifact_type = OperationArtifactType::Wasm(WasmArtifactSubType::Esm);
let wf_esm_artifact_type = WorkflowArtifactType::Wasm(WasmArtifactSubType::Esm);

Variants

Cjs

CommonJS module for the direct use in the nodejs env which doesn’t have the ESM support. When Nodejs has native ESM support this should be used only for the legacy versions. Check here the Nodejs ESM status.

Esm

Native ES module, usually used with bundler software like webpack. You can use this just by including it, the wasm will be instantiated on require time. Example can be found here and official docs here. For the official NODEJS support see this doc If you want to use this with nodejs, use the bundler.

Wasm

Just a compiled WASM file without any acompanied JS or .d.ts files. You have to do all things manual.

Web

This is an ES module with manual instantiation of the wasm. It doesn’t include polyfills More info is on the wasm-pack doc website and wasm-bindgen

Example in Javascript

import init, { execute } from './op-file'
async function main() {
  await init() //initialize wasm
  const e = execute([new Uint8Array(7)], new Map())
  console.log(e.decode());
}
main().catch(console.error)

Trait Implementations

impl Clone for WasmArtifactSubType

fn clone(&self) -> WasmArtifactSubType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WasmArtifactSubType

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for WasmArtifactSubType

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for WasmArtifactSubType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Encode for WasmArtifactSubType

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq<WasmArtifactSubType> for WasmArtifactSubType

fn eq(&self, other: &WasmArtifactSubType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for WasmArtifactSubType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl EncodeLike<WasmArtifactSubType> for WasmArtifactSubType

impl Eq for WasmArtifactSubType

impl StructuralEq for WasmArtifactSubType

impl StructuralPartialEq for WasmArtifactSubType