Merge pull request #23 from torch2424/instantiate-sync

Added sync instantiate and some other folder cleanup

Author: torch2424

README.md

@@ -104,7 +104,7 @@ const asyncTask = async () => {
 asyncTask();
 ```
 
-*Did the quick start not work for you, or you are noticing some weird behavior? Please see the [FAQ and Common Issues](#faq-and-common-issues)*
+_Did the quick start not work for you, or you are noticing some weird behavior? Please see the [FAQ and Common Issues](#faq-and-common-issues)_
 
 ## Additional Examples
 
@@ -146,7 +146,7 @@ const asyncTask = async () => {
   });
 
   // Should call consoleLog, and log: "Hello from AS!"
-  asBindInstance.exports.myExportedFunctionThatWillCallConsoleLog(); 
+  asBindInstance.exports.myExportedFunctionThatWillCallConsoleLog();
 };
 asyncTask();
 ```
@@ -208,6 +208,20 @@ This function is the equivalent to the [AssemblyScript Loader instantiate](https
 
 - A [WebAssembly importObject](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_objects/WebAssembly/instantiateStreaming), which would have all of your imported functions that can be called from within your AssemblyScript module.
 
+##### instantiateSync
+
+```typescript
+AsBind.instantiate: (
+  moduleOrBuffer: (
+    WebAssembly.Module |
+    BufferSource
+  ),
+  imports?: WasmImports
+) => AsBindInstance`
+```
+
+This is a synchronous version of `AsBind.instantiate`. This does not accept a promise-like as it's module, and returns an AsBindInstance instead of a Promise that resolves an AsBindInstance. **This is only reccomended for use in testing or development**. Please see the Documentation sections for `AsBind.instantiate` for more information.
+
 #### Instance Properties
 
 An AsBindInstance is vaugley similar to a [WebAssembly instance](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance).
@@ -280,7 +294,7 @@ _If you're project is using as-bind, and you would like to be featured here. Ple
 
 This is probably because you are not adding the as-bind entry file. Please see the [Quick Start](#quick-start) on how to compile your AssemblyScript module with this entry file. If this still does not work, please take a look at the [Supported Types](#supported-types) to ensure what type you are trying to pass will work.
 
-*Didn't find a solution to your problem? Feel free to open an issue!*
+_Didn't find a solution to your problem? Feel free to open an issue!_
 
 ## Contributing
 

lib/asbind-instance.js renamed to lib/asbind-instance/asbind-instance.js

@@ -1,6 +1,6 @@
 // Class for asbind instances
 
-import { asbindInstantiate } from "./instantiate";
+import { asbindInstantiate, asbindInstantiateSync } from "./instantiate";
 import { bindImportFunction, bindExportFunction } from "./bind-function";
 import { isReservedExportKey } from "./reserved-export-keys";
 
@@ -36,6 +36,28 @@ export default class AsbindInstance {
   }
 
   async _instantiate(source, importObject) {
+    // Bind our import function
+    this._instantiateBindImportFunctions(importObject);
+
+    // Instantiate the module through the loader
+    const unboundExports = await asbindInstantiate(source, this.importObject);
+
+    // Bind our unbound exports
+    this._instantiateBindUnboundExports(unboundExports);
+  }
+
+  _instantiateSync(source, importObject) {
+    // Bind our import function
+    this._instantiateBindImportFunctions(importObject);
+
+    // Instantiate the module through the loader
+    const unboundExports = asbindInstantiateSync(source, this.importObject);
+
+    // Bind our unbound exports
+    this._instantiateBindUnboundExports(unboundExports);
+  }
+
+  _instantiateBindImportFunctions(importObject) {
     // Set our import object, as we will need it to store type caching
     this.importObject = importObject;
 
@@ -54,9 +76,11 @@ export default class AsbindInstance {
         );
       }
     );
+  }
 
-    // Instantiate the module through the loader
-    this.unboundExports = await asbindInstantiate(source, this.importObject);
+  _instantiateBindUnboundExports(unboundExports) {
+    // Set our unbound exports
+    this.unboundExports = unboundExports;
 
     // Wrap appropriate the appropriate export functions
     this.exports = {};

lib/bind-function.js renamed to lib/asbind-instance/bind-function.js

@@ -23,3 +23,7 @@ export async function asbindInstantiate(source, importObject) {
 
   return wasmInstanceExports;
 }
+
+export function asbindInstantiateSync(source, importObject) {
+  return loader.instantiateSync(source, importObject);
+}

lib/instantiate.js renamed to lib/asbind-instance/instantiate.js

@@ -1,5 +1,5 @@
 import packageJson from "../package.json";
-import AsbindInstance from "./asbind-instance";
+import AsbindInstance from "./asbind-instance/asbind-instance";
 
 export const AsBind = {
   // General asbind versionn
@@ -10,6 +10,12 @@ export const AsBind = {
     let asbindInstance = new AsbindInstance();
     await asbindInstance._instantiate(source, importObject);
     return asbindInstance;
+  },
+
+  instantiateSync: (source, importObject) => {
+    let asbindInstance = new AsbindInstance();
+    asbindInstance._instantiateSync(source, importObject);
+    return asbindInstance;
   }
 };
 

lib/reserved-export-keys.js renamed to lib/asbind-instance/reserved-export-keys.js

@@ -35,6 +35,16 @@ describe("asbind", () => {
       assert(asbindInstance.exports.__release !== undefined, true);
     });
 
+    it("should instantiateSync WebAssembly.Module", async () => {
+      const wasmModule = await WebAssembly.compile(wasmBytes);
+      asbindInstance = AsBind.instantiateSync(wasmModule, baseImportObject);
+
+      assert(asbindInstance.exports !== undefined, true);
+      assert(asbindInstance.exports.helloWorld !== undefined, true);
+      assert(asbindInstance.exports.__alloc !== undefined, true);
+      assert(asbindInstance.exports.__release !== undefined, true);
+    });
+
     it("should instantiate Uint8Array", async () => {
       asbindInstance = await AsBind.instantiate(wasmBytes, baseImportObject);
 
@@ -44,6 +54,15 @@ describe("asbind", () => {
       assert(asbindInstance.exports.__release !== undefined, true);
     });
 
+    it("should instantiateSync Uint8Array", async () => {
+      asbindInstance = AsBind.instantiateSync(wasmBytes, baseImportObject);
+
+      assert(asbindInstance.exports !== undefined, true);
+      assert(asbindInstance.exports.helloWorld !== undefined, true);
+      assert(asbindInstance.exports.__alloc !== undefined, true);
+      assert(asbindInstance.exports.__release !== undefined, true);
+    });
+
     it("should instantiate Promise/Response", async () => {
       // Mock our Browser Response, and Wasm Instantiate streaming for response
       global.WebAssembly.instantiateStreaming = async (response, imports) => {