Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including golang-wasm-async-loader with all npm packages installed. Try it out:

require("webpack/package.json"); // webpack is a peer dependency. var golangWasmAsyncLoader = require("golang-wasm-async-loader")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

golang-wasm-async-loader v0.4.1

Golang WebAssembly loader for webpack that generates an async pattern for working with Go's WebAssembly output

Build Status npm node

Golang WebAssembly Async Loader

Generates a WASM package from Golang and provides an async interface for working with it

Install

npm install --save-dev golang-wasm-async-loader

This is a loader for webpack that is used for generating WebAssembly (aka WASM) bundles from Go.

The JavaScript bridge that is then generated for webpack will expose the WebAssembly functions as a Promise for interacting with.

webpack config

module.exports = {
    ...
    module: {
        rules: [
            {
                test: /\.go/,
                use: ['golang-wasm-async-loader']
            }
        ]
    },
    node: {
        fs: 'empty'
    }
};

Using in your code

You import your Go code just like any other JavaScript module you might be working with. The webpack loader will export a default export that has the functions you registered in Go on it. Unfortunately it currently doesn't provide autocomplete of those function names as they are runtime defined.

import wasm from './main.go'

async function init() {
  const result = await wasm.add(1, 2);
  console.log(result);

  const someValue = await wasm.someValue();
  console.log(someValue);
}

Here's the main.go file:

package main

import (
    "strconv"
    "syscall/js"
    "github.com/aaronpowell/webpack-golang-wasm-async-loader/gobridge"
)

func add(i []js.Value) (interface{},error) {
    ret := 0

    for _, item := range i {
        val, _ := strconv.Atoi(item.String())
        ret += val
    }

    return ret, nil
}

func main() {
    c := make(chan struct{}, 0)

    gobridge.RegisterCallback("add", add)
    gobridge.RegisterValue("someValue", "Hello World")

    <-c
}

How does it work?

As part of this repository a Go package has been created to improve the interop between the Go WASM runtime and work with the async pattern the loader defines.

To do this a function is exported from the package called RegisterCallback which takes two arguments:

  • A string representing the name to register it as in JavaScript (and what you'll call it using)
  • The func to register as a callback
    • The func must has a signature of (args js.Value) (interface{}, error) so you can raise an error if you need

If you want to register a static value that's been created from Go to be available in JavaScript you can do that with RegisterValue, which takes a name and a value. Values are converted to functions that return a Promise so they can be treated asynchronously like function invocations.

In JavaScript a global object is registered as __gobridge__ which the registrations happen against.

Example

You'll find an example of this in action in the example folder.

Licence

MIT

Credit

Aaron Powell

RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free