The "module" is now an async function that loads and initializes Sql.js

I am purposefully not checking in the compiled assets just yet until this stabilizes

Author: Taytay

coffee/output-post.js

@@ -1,2 +1,5 @@
 
-}.bind(this));
+}).bind(this);
+
+Module['preRun'] = Module['preRun'] || [];
+Module['preRun'].push(runCompiledCode);

coffee/output-pre.js

@@ -1,4 +1,4 @@
 
 
 // Wait for preRun to run, and then finish our initialization
-Module['preRunHasRun'].then(function(){
+var runCompiledCode = (function() {

js/shell-post.js

@@ -1,10 +1,15 @@
- 
-  return Module;
-})(Module);
-
-if (typeof exports === 'object' && typeof module === 'object')
-    module.exports = Module;
-else if (typeof define === 'function' && define['amd'])
-    define([], function() { return Module; });
-else if (typeof exports === 'object')
-    exports["Module"] = Module;
+
+
+        // The shell-pre.js and emcc-generated code goes above
+        return Module;
+    }); // The end of the promise being returned
+
+  return initSqlJsPromise;
+} // The end of our initSqlJs function
+
+// This will allow the module to be used in ES6 or CommonJS
+initSqlJs.default = initSqlJs;
+if (typeof exports === 'object' && typeof module === 'object'){
+    module.exports = initSqlJs;
+}
+

js/shell-pre.js

@@ -1,36 +1,52 @@
+
 // We are modularizing this manually because the current modularize setting in Emscripten has some issues:
 // https://github.com/kripken/emscripten/issues/5820
-var Module = (function(Module) {
-  
-    // If Module already exists, use it
-    var Module = typeof Module !== 'undefined' ? Module : {};
-    
-    Module['preRunHasRun'] = new Promise(function(resolve){
-      // TODO: Add on to any postRun objects already there
-      Module['preRun'] = function(){
-        // When Emscripted calls preRun, this resolves
-        resolve();
-      }
-    }.bind(this));
-    
-    var postRunHasRun = Module['postRunHasRun'] = new Promise(function(resolve){
-      // TODO: Add on to any postRun objects already there
-      Module['postRun'] = function(){
-        // When Emscripted calls postRun, this resolves
-        resolve();
-      }
-    }.bind(this));
-    
-    // This is a promise that a module loader can listen for 
-    Module['ready'] = new Promise(function(resolve, reject){
-      // TODO: Add on to any onAbort function already there
-      Module['onAbort'] = function(what){
-        reject(new Error(what));
-      }
-  
-      return postRunHasRun.then(function(){
-        resolve(Module);
-      }.bind(this));
-  
-    }.bind(this));
+// This module exports a promise that loads and resolves to the actual sql.js module.
+// That way, this module can't be used before the WASM is finished loading.
+
+
+// So the first thing that this module does is define a place for the loadedModule to reside
+
+// We are going to define a function that a user will call to start loading initializing our Sql.js library
+// However, that function might be called multiple times, and on subsequent calls, we want it to return the same module that it's already loaded once before.
+
+var initSqlJsPromise = undefined;
+
+var initSqlJs = function (moduleConfig) {
+
+    if (initSqlJsPromise){
+      return initSqlJsPromise;
+    }
+    // If we're here, we've never called this function before
+    initSqlJsPromise = new Promise((resolveModule) => {
+
+        // We are modularizing this manually because the current modularize setting in Emscripten has some issues:
+        // https://github.com/kripken/emscripten/issues/5820
+
+        // The way to affect the loading of emcc compiled modules is to create a variable called `Module` and add
+        // properties to it, like `preRun`, `postRun`, etc
+        // We are using that to get notified when the WASM has finished loading.
+        // Only then will we return our promise
+
+        // If they passed in a moduleConfig object, use that
+        // Otherwise, initialize Module to the empty object
+        var Module = typeof moduleConfig !== 'undefined' ? moduleConfig : {};
+
+        // EMCC only allows for a single onAbort function (not an array of functions)
+        // So if the user defined their own onAbort function, we remember it and call it
+        var originalOnAbortFunction = Module['onAbort'];
+        Module['onAbort'] = function (errorThatCausedAbort) {
+            reject(new Error(errorThatCausedAbort));
+            if (originalOnAbortFunction){
+              originalOnAbortFunction(errorThatCausedAbort);
+            }
+        };
 
+        Module['postRun'] = Module['postRun'] || [];
+        Module['postRun'].push(function () {
+            // When Emscripted calls postRun, this promise resolves with the built Module
+            resolveModule(Module);
+        });
+        
+        // The emcc-generated code and shell-post.js code goes below,
+        // meaning that all of it runs inside of this promise. If anything throws an exception, our promise will abort

test/all.js

@@ -2,8 +2,9 @@ var fs = require("fs");
 Error.stackTraceLimit = 200;
 var target = process.argv[2];
 var file = target ? "../js/sql-"+target+".js" : "../js/sql.js";
-var sqlModule = require(file);
-sqlModule.ready.then((sql)=>{
+var initSqlJs = require(file);
+
+initSqlJs().then((sql)=>{
   var files = fs.readdirSync(__dirname);
   for (var i=0; i<files.length; i++) {
     var file = files[i];

test/load_sql_file.js

@@ -1,11 +1,11 @@
 module.exports = function(sqlFileTarget){
     var sqlFileTarget = process.argv[2];
-    var file = sqlFileTarget ? "../js/sql-"+sqlFileTarget+".js" : "../js/sql.js";
+    var sqlJsLib = sqlFileTarget ? "../js/sql-"+sqlFileTarget+".js" : "../js/sql.js";
     begin = new Date();
-    var sqlModule = require(file);
-    return sqlModule.ready.then((sql)=>{
+    var initSqlJs = require(sqlJsLib);
+    return initSqlJs().then((sql)=>{
         end = new Date();
-        console.log(`Loaded and inited ${file} in ${end -begin}ms`);
+        console.log(`Loaded and inited ${sqlJsLib} in ${end -begin}ms`);
         return sql;
     });
 }

test/test_errors.js

@@ -50,7 +50,7 @@ exports.test = function(sql, assert) {
 
   assert.throws(function(){
     stmt.run([3]);
-  }, "Statements should'nt be able to execute after the database is closed");
+  }, "Statements shouldn't be able to execute after the database is closed");
 };
 
 if (module == require.main) {