refactor(typescript): refactor to ts (fixes #56) (#100)

* ⚙️refactor (typescript): refactor to ts (fixes #56)

* lint stuff

* change lint settings

* fix

* lint again

* finish transform.ts

Author: mathe42

.prettierignore

@@ -0,0 +1 @@
+test/tests/namespace-import/asc.ts

.prettierrc

@@ -0,0 +1,7 @@
+{
+  "trailingComma": "none",
+  "semi": true,
+  "arrowParens": "avoid",
+  "printWidth": 80,
+  "bracketSpacing": true
+}

examples/quickstart/browser-puppeteer.js

@@ -13,8 +13,8 @@ const http = require("http");
 // Host a static server of the local directory
 // https://nodejs.org/en/knowledge/HTTP/servers/how-to-serve-static-files/
 http
-  .createServer(function(req, res) {
-    fs.readFile(__dirname + req.url, function(err, data) {
+  .createServer(function (req, res) {
+    fs.readFile(__dirname + req.url, function (err, data) {
       if (err) {
         res.writeHead(404);
         res.end(JSON.stringify(err));
@@ -53,10 +53,7 @@ http
   // Listen to JS Console messages, log them, and resolve our promise on an expected message
   page.on("console", message => {
     console.log(
-      `${message
-        .type()
-        .substr(0, 3)
-        .toUpperCase()} ${message.text()}`
+      `${message.type().substr(0, 3).toUpperCase()} ${message.text()}`
     );
 
     if (message.text() === "AsBind: Hello World!") {

examples/quickstart/browser.js

@@ -17,9 +17,8 @@ const asyncTask = async () => {
   const asBindInstance = await AsBind.instantiate(wasmBuffer);
 
   // You can now use your wasm / as-bind instance!
-  const response = asBindInstance.exports.myExportedFunctionThatTakesAString(
-    "Hello World!"
-  );
+  const response =
+    asBindInstance.exports.myExportedFunctionThatTakesAString("Hello World!");
   console.log(response); // AsBind: Hello World!
 };
 asyncTask();

examples/quickstart/nodejs.js

@@ -11,9 +11,8 @@ const asyncTask = async () => {
   const asBindInstance = await AsBind.instantiate(wasm);
 
   // You can now use your wasm / as-bind instance!
-  const response = asBindInstance.exports.myExportedFunctionThatTakesAString(
-    "Hello World!"
-  );
+  const response =
+    asBindInstance.exports.myExportedFunctionThatTakesAString("Hello World!");
   console.log(response); // AsBind: Hello World!
 };
 asyncTask();

examples/quickstart/package-lock.json

@@ -1,5 +1,7 @@
 const fs = require("fs");
-const compiled = new WebAssembly.Module(fs.readFileSync(__dirname + "/build/optimized.wasm"));
+const compiled = new WebAssembly.Module(
+  fs.readFileSync(__dirname + "/build/optimized.wasm")
+);
 const imports = {
   env: {
     abort: () => {}
@@ -9,8 +11,7 @@ const wasmInstance = new WebAssembly.Instance(compiled, imports);
 wasmInstance.exports._asbind_add = wasmInstance.exports.add;
 wasmInstance.exports.add = (x, y) => {
   console.log(wasmInstance.exports._asbind_add(x, y));
-}
+};
 
 console.log(wasmInstance.exports);
 console.log(wasmInstance.exports.add(3, 2));
-

index.js

@@ -1,13 +1,19 @@
 // Class for asbind instances
-
 import { asbindInstantiate, asbindInstantiateSync } from "./instantiate";
 import { bindImportFunction, bindExportFunction } from "./bind-function";
-import { isReservedExportKey } from "./reserved-export-keys";
+import {
+  TypeDef,
+  WebAssemblyModuleStreaming,
+  WebAssemblyModuleSync,
+  WebAssemblyLoaderResult
+} from "../types";
+
+import { ASUtil } from "@assemblyscript/loader";
 
 const SECTION_NAME = "as-bind_bindings";
 
 // Basically a deep-copy, but can be limited in levels.
-function copyObject(obj, { depth = Number.POSITIVE_INFINITY } = {}) {
+function copyObject<T>(obj: T, { depth = Number.POSITIVE_INFINITY } = {}): T {
   if (depth <= 0 || !obj || typeof obj !== "object") {
     return obj;
   }
@@ -16,21 +22,22 @@ function copyObject(obj, { depth = Number.POSITIVE_INFINITY } = {}) {
       key,
       copyObject(val, { depth: depth - 1 })
     ])
-  );
+  ) as T;
 }
 
-async function compileStreaming(source) {
+async function compileStreaming(source: WebAssemblyModuleStreaming) {
   source = await Promise.resolve(source);
   if (typeof Response !== "undefined" && source instanceof Response) {
     if (WebAssembly.compileStreaming) {
       return WebAssembly.compileStreaming(source);
     }
     source = await source.arrayBuffer();
   }
-  return WebAssembly.compile(source);
+
+  return WebAssembly.compile(source as BufferSource);
 }
 
-function extractTypeDescriptor(module) {
+function extractTypeDescriptor(module: WebAssembly.Module): TypeDef {
   const sections = WebAssembly.Module.customSections(module, SECTION_NAME);
   const str = new TextDecoder("utf8").decode(new Uint8Array(sections[0]));
   try {
@@ -41,20 +48,20 @@ function extractTypeDescriptor(module) {
 }
 
 export default class AsbindInstance {
-  constructor() {
-    this.unboundExports = {};
-    this.exports = {};
-    this.importObject = {};
-  }
+  exports: Record<string, never> | ASUtil = {};
+  importObject: WebAssembly.Imports = {};
+  typeDescriptor: TypeDef;
+  module: WebAssembly.Module;
+  loadedModule: WebAssemblyLoaderResult;
 
-  getTypeId(typeName) {
+  getTypeId(typeName: string) {
     if (typeName in this.typeDescriptor.typeIds) {
       return this.typeDescriptor.typeIds[typeName].id;
     }
     throw Error(`Unknown type ${JSON.stringify(typeName)}`);
   }
 
-  getTypeSize(typeName) {
+  getTypeSize(typeName: string) {
     if (typeName in this.typeDescriptor.typeIds) {
       return this.typeDescriptor.typeIds[typeName].byteSize;
     }
@@ -78,7 +85,10 @@ export default class AsbindInstance {
     }
   }
 
-  async _instantiate(source, importObject) {
+  async _instantiate(
+    source: WebAssemblyModuleStreaming,
+    importObject: WebAssembly.Imports
+  ) {
     this.module = await compileStreaming(source);
 
     this._validate();
@@ -89,7 +99,10 @@ export default class AsbindInstance {
     this._instantiateBindUnboundExports();
   }
 
-  _instantiateSync(source, importObject) {
+  _instantiateSync(
+    source: WebAssemblyModuleSync,
+    importObject: WebAssembly.Imports
+  ) {
     this.module = new WebAssembly.Module(source);
 
     this._validate();
@@ -99,7 +112,7 @@ export default class AsbindInstance {
     this._instantiateBindUnboundExports();
   }
 
-  _instantiateBindImportFunctions(importObject) {
+  _instantiateBindImportFunctions(importObject: WebAssembly.Imports) {
     this.importObject = copyObject(importObject, { depth: 2 });
 
     for (const [moduleName, moduleDescriptor] of Object.entries(
@@ -111,13 +124,12 @@ export default class AsbindInstance {
         this.importObject[moduleName][
           `__asbind_unbound_${importedFunctionName}`
         ] = importObject[moduleName][importedFunctionName];
-        this.importObject[moduleName][
-          importedFunctionName
-        ] = bindImportFunction(
-          this,
-          importObject[moduleName][importedFunctionName],
-          descriptor
-        );
+        this.importObject[moduleName][importedFunctionName] =
+          bindImportFunction(
+            this,
+            importObject[moduleName][importedFunctionName] as Function,
+            descriptor
+          );
       }
     }
   }

lib/as-bind.d.ts

@@ -1,3 +1,6 @@
+import { TypeDefFn } from "../types";
+import AsbindInstance from "./asbind-instance";
+
 import {
   getAscToJsConverterForType,
   getJsToAscConverterForType
@@ -12,9 +15,9 @@ function getFunctionFromKeyPath(baseObject, keys) {
 }
 
 export function bindImportFunction(
-  asbindInstance,
-  importedFunction,
-  importedFunctionDescriptor
+  asbindInstance: AsbindInstance,
+  importedFunction: Function,
+  importedFunctionDescriptor: TypeDefFn
 ) {
   // Grab type converter functions according to the type descriptor
   const argumentConverterFunctions = importedFunctionDescriptor.parameters.map(
@@ -26,7 +29,7 @@ export function bindImportFunction(
 
   // Create a wrapper function that applies the correct converter function to arguments and
   // return value respectively.
-  return function(...args) {
+  return function (...args) {
     if (args.length != argumentConverterFunctions.length) {
       throw Error(
         `Expected ${argumentConverterFunctions.length} arguments, got ${args.length}`
@@ -51,9 +54,9 @@ export function bindImportFunction(
 // Function that takes in an asbind instance, and the key to the export function on the
 // abindInstance.exports object, to be wrapped and then re-assigned to the asbindInstance.exports.
 export function bindExportFunction(
-  asbindInstance,
-  exportedFunction,
-  exportedFunctionDescriptor
+  asbindInstance: AsbindInstance,
+  exportedFunction: Function,
+  exportedFunctionDescriptor: TypeDefFn
 ) {
   // Grab type converter functions according to the type descriptor
   const argumentConverterFunctions = exportedFunctionDescriptor.parameters.map(