Instance.fromModule constructor

Instance.fromModule(
  1. Module module, {
  2. Map<String, Map<String, Object>>? importMap,
  3. Object? importObject,
})

Synchronously instantiates compiled WebAssembly Module.

Some runtimes do not allow synchronous instantiation of modules bigger than 4 KB in the main thread.

Unexpected imports may cause a LinkError.

A runtime exception in the start function (when present) will throw a RuntimeError.

Imports could be provided via either importMap parameter like this:

final importMap = {
  'env': {
    'log': allowInterop(print)
  }
}

final instance = Instance.fromModule(module, importMap: importMap);

or via importObject parameter which must be a JsObject:

import 'package:js/js.dart';

@JS()
@anonymous
abstract class MyImports {
  external factory MyImports({MyEnv env});
}

@JS()
@anonymous
abstract class MyEnv {
  external factory MyEnv({Function log});
}

final importObject = MyImports(env: MyEnv(log: allowInterop(print)));
final instance = Instance.fromModule(module, importObject: importObject);

Implementation

factory Instance.fromModule(Module module,
    {Map<String, Map<String, Object>>? importMap, Object? importObject}) {
  try {
    return Instance._(
        _Instance(module.jsObject, _reifyImports(importMap, importObject)),
        module);
    // ignore: avoid_catches_without_on_clauses
  } catch (e) {
    if (instanceof(e, _linkError)) {
      throw LinkError(getProperty(e, 'message'));
    } else if (instanceof(e, _runtimeError)) {
      throw RuntimeError(getProperty(e, 'message'));
    }
    rethrow;
  }
}