Merge pull request #18 from torch2424/post-launch-improvements

Post launch improvements

Author: torch2424

README.md

@@ -19,12 +19,14 @@ Isomorphic library to handle passing high-level data structures between Assembly
 - [Features](#features)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [Additional Examples](#additional-examples)
 - [Supported Data Types](#supported-data-types)
 - [Supported AssemblyScript Runtime Variants](#supported-assemblyscript-runtime-variants)
 - [Reference API](#reference-api)
 - [Motivation](#motivation)
 - [Performance](#performance)
 - [Projects using as-bind](#projects-using-as-bind)
+- [FAQ and Common Issues](#faq-and-common-issues)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -102,6 +104,53 @@ 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)*
+
+## Additional Examples
+
+## Passing a high-level type to a an exported function, and returning a high-level type
+
+[See the Quick Start](#quick-start)
+
+## Passing a high-level type to an imported function
+
+In this example, we will implement a `console.log` that we can call from AssemblyScript!
+
+**AssemblyScript**
+
+Inside of `myWasmFileName.ts`:
+
+```
+declare function consoleLog(message: string): void;
+
+export function myExportedFunctionThatWillCallConsoleLog(): void {
+  consoleLog("Hello from AS!");
+}
+```
+
+**JavaScript**
+
+```
+import { AsBind } from "as-bind";
+
+const wasm = fetch("./path-to-my-wasm.wasm");
+
+const asyncTask = async () => {
+  // Instantiate the wasm file, and pass in our importObject
+  const asBindInstance = await AsBind.instantiate(wasm, {
+    myWasmFileName: {
+      consoleLog: message => {
+        console.log(message);
+      }
+    }
+  });
+
+  // Should call consoleLog, and log: "Hello from AS!"
+  asBindInstance.exports.myExportedFunctionThatWillCallConsoleLog(); 
+};
+asyncTask();
+```
+
 ## Supported Data Types
 
 **TL;DR:** Currently Numbers, Strings, and Typed Arrays are supported. Returning a high-level data type from an imported JavaScript function, and passing AssemblyScript Classes will be coming later.
@@ -225,6 +274,14 @@ In the future, these types of high-level data passing tools will not be needed f
 
 _If you're project is using as-bind, and you would like to be featured here. Please open a README with links to your project, and if appropriate, explaining how as-bind is being used._ 😊
 
+## FAQ and Common Issues
+
+> I am calling my exports, but it is not returning the types that I am returning? It seems to be returning pointers?
+
+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!*
+
 ## Contributing
 
 Contributions are definitely welcome! Feel free to open a PR for small fixes such as typos and things. Larger fixes, or new features should start out as an issue for discussion, in which then a PR should be made. 🥳

lib/bind-function.js

@@ -85,9 +85,10 @@ export function bindImportFunction(
     });
 
     // Call the import function
-    originalImport.apply(null, argumentsWithReplacedRefs);
+    const response = originalImport.apply(null, argumentsWithReplacedRefs);
 
-    // TODO: Returning from Import functions is not supported by asbind :(
+    // TODO: Returning High-level types from Import functions is not supported by asbind :(
+    return response;
   };
 
   // Initialize the state of our function

test/assembly/test.ts

@@ -52,7 +52,6 @@ export function mapFloat64Array(array: Float64Array): Float64Array {
   return array.map((value: f64) => value * 2);
 }
 
-// NOTE: Asbind does not support return types on import object functions
 declare function testImportString(value: string): void;
 export function callTestImportString(value: string): void {
   testImportString(value);
@@ -66,6 +65,12 @@ export function callTestImportTwoStrings(
   testImportTwoStrings(valueOne, valueTwo);
 }
 
+declare function testImportReturnNumber(): i32;
+export function callTestImportReturnNumber(): i32 {
+  let response: i32 = testImportReturnNumber();
+  return response;
+}
+
 declare function testImportInt8Array(value: Int8Array): void;
 export function callTestImportInt8Array(value: Int8Array): void {
   testImportInt8Array(value);

test/assembly/test.wasm

@@ -9,6 +9,7 @@ describe("asbind", () => {
     test: {
       testImportString: () => {},
       testImportTwoStrings: () => {},
+      testImportReturnNumber: () => -1,
       testImportInt8Array: () => {},
       testImportUint8Array: () => {},
       testImportInt16Array: () => {},
@@ -160,6 +161,7 @@ describe("asbind", () => {
           testImportTwoStrings: (value1, value2) => {
             testImportCalledWith = [value1, value2];
           },
+          testImportReturnNumber: () => -1,
           testImportInt8Array: importObjectFunction,
           testImportUint8Array: importObjectFunction,
           testImportInt16Array: importObjectFunction,
@@ -192,6 +194,11 @@ describe("asbind", () => {
       assert.equal(testImportCalledWith[1], "asbind2");
     });
 
+    it("should allow numbers to be returned from the importObject", () => {
+      const response = asbindInstance.exports.callTestImportReturnNumber();
+      assert.equal(response, -1);
+    });
+
     // TypedArrays
     [
       "Int8Array",
@@ -234,6 +241,7 @@ describe("asbind", () => {
           testImportTwoStrings: (value1, value2) => {
             testImportCalledWith = [value1, value2];
           },
+          testImportReturnNumber: () => -1,
           testImportInt8Array: importObjectFunction,
           testImportUint8Array: importObjectFunction,
           testImportInt16Array: importObjectFunction,