fix(edward) loadremote (#257)

Author: coderaiser

bower.json

@@ -17,7 +17,6 @@
     "modules"
   ],
   "dependencies": {
-    "loadremote": "~1.2.0",
     "ace-builds": "^1.4.6"
   }
 }

client/edward.js

@@ -1,6 +1,5 @@
 /* global ace */
 /* global join */
-/* global loadRemote */
 
 'use strict';
 
@@ -10,6 +9,7 @@ const {createPatch} = require('daffy');
 const exec = require('execon');
 const Emitify = require('emitify');
 const load = require('load.js');
+const loadremote = require('./loadremote');
 const wraptile = require('wraptile');
 const smalltalk = require('smalltalk');
 const jssha = require('jssha');
@@ -110,14 +110,14 @@ Edward.prototype._init = function(fn) {
 
     exec.series([
         loadFiles,
-        (callback) => {
-            loadRemote('socket', {
+        async (callback) => {
+            await loadremote('socket', {
                 name : 'io',
                 prefix: this._SOCKET_PATH,
-            }, (error) => {
-                !error && initSocket();
-                callback();
             });
+            
+            initSocket();
+            callback();
         },
         async () => {
             this._Emitter = Emitify();
@@ -574,9 +574,8 @@ Edward.prototype._loadFiles = function(callback) {
     const DIR = this._DIR;
 
     exec.series([
-        function(callback) {
+        async function(callback) {
             const obj = {
-                loadRemote  : getModulePath('loadremote', 'lib'),
                 join        : '/join/join.js',
             };
 
@@ -588,29 +587,32 @@ Edward.prototype._loadFiles = function(callback) {
                     return PREFIX + obj[name];
                 });
 
-            exec.if(!scripts.length, callback, () => {
-                load.parallel(scripts, callback);
-            });
+            if (scripts.lengths)
+                return callback();
+            
+            await load.parallel(scripts);
+            callback();
         },
 
-        function(callback) {
-            loadRemote.load('ace', {prefix: PREFIX}, callback);
+        async function(callback) {
+            await loadremote('ace', {prefix: PREFIX});
+            callback();
         },
 
-        function(callback) {
+        async function(callback) {
             const ace = DIR + 'ace-builds/src-min/';
             const url = PREFIX + join([
                 'language_tools',
                 'searchbox',
                 'modelist',
             ].map((name) => {
                 return 'ext-' + name;
-            })
-                .map((name) => {
-                    return ace + name + '.js';
-                }));
+            }).map((name) => {
+                return ace + name + '.js';
+            }));
 
-            load.js(url, callback);
+            await load.js(url);
+            callback();
         },
 
         function() {

client/loadremote.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const load = require('load.js');
+const tryToCatch = require('try-to-catch');
+const once = require('once');
+
+const loadModules = once(async (prefix) => {
+    const url = prefix + '/modules.json';
+    return await load.json(url);
+});
+
+const loadOptions = once(async (prefix) => {
+    const url = prefix + '/options.json';
+    return await load.json(url);
+});
+
+const on = async (remote) => {
+    const [error] = await tryToCatch(load.parallel, remote);
+    
+    if (error)
+        await off();
+};
+
+const off = async function(local) {
+    await load.parallel(local);
+};
+
+module.exports = async (name, options = {}) => {
+    const o = options;
+    
+    const {
+        prefix = '',
+    } = o;
+    
+    if (o.name && global[o.name])
+        return;
+    
+    const promises = [
+        loadModules(prefix),
+        loadOptions(prefix),
+    ];
+    
+    const [error, [modules, config]] = await tryToCatch(Promise.all.bind(Promise), promises);
+    
+    let remoteTmpls;
+    let local;
+    
+    if (error)
+        return alert(`Error: could not load module or config: ${error.message}`);
+    
+    const online = config.online && navigator.onLine;
+    const module = binom(name, modules);
+    const isArray = Array.isArray(module.local);
+    const {version} = module;
+    
+    if (isArray) {
+        remoteTmpls = module.remote;
+        local = module.local;
+    } else {
+        remoteTmpls = [module.remote];
+        local = [module.local];
+    }
+    
+    local = local.map((url) => {
+        return prefix + url;
+    });
+    
+    const remote = remoteTmpls.map((tmpl) => {
+        return tmpl.replace(/{{\sversion\s}}/g, version);
+    });
+    
+    if (!online)
+        return await off(local);
+    
+    await on(remote);
+};
+
+function binom(name, array) {
+    let ret;
+    
+    if (typeof name !== 'string')
+        throw Error('name should be string!');
+    
+    if (!Array.isArray(array))
+        throw Error('array should be array!');
+    
+    array.some((item) => {
+        const is = item.name === name;
+        
+        if (is)
+            ret = item;
+        
+        return is;
+    });
+    
+    return ret;
+}
+