@shijiu/jsview 1.9.779 → 1.9.782

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shijiu/jsview",
-  "version": "1.9.779",
+  "version": "1.9.782",
   "bin": {
     "jsview-post-build": "./tools/jsview-post-build.js",
     "jsview-post-install": "./tools/jsview-post-install.js"

package/tools/index.js

@@ -0,0 +1,209 @@
+module.exports = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {} };
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function setArg (key, val) {
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+    
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            setArg(m[1], m[2]);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
+                setArg(key, next);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true');
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next)
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2));
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
+                    setArg(key, args[i+1]);
+                    i++;
+                }
+                else if (args[i+1] && /true|false/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true');
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true);
+                }
+            }
+        }
+        else {
+            argv._.push(
+                flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+            );
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function setKey (obj, keys, value) {
+    var o = obj;
+    for (var i = 0; i < keys.length-1; i++) {
+        var key = keys[i];
+        if (key === '__proto__') return;
+        if (o[key] === undefined) o[key] = {};
+        if (o[key] === Object.prototype || o[key] === Number.prototype
+            || o[key] === String.prototype) o[key] = {};
+        if (o[key] === Array.prototype) o[key] = [];
+        o = o[key];
+    }
+
+    var key = keys[keys.length - 1];
+    if (key === '__proto__') return;
+    if (o === Object.prototype || o === Number.prototype
+        || o === String.prototype) o = {};
+    if (o === Array.prototype) o = [];
+    if (o[key] === undefined || typeof o[key] === 'boolean') {
+        o[key] = value;
+    }
+    else if (Array.isArray(o[key])) {
+        o[key].push(value);
+    }
+    else {
+        o[key] = [ o[key], value ];
+    }
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+

package/tools/jsview-common.js

@@ -4,8 +4,91 @@
 const fs = require('fs');
 const path = require('path');
 
-function parseArguments(beginWithHyphen = true)
+function printArgumentsUsages(requiredUsages, optionalUsages, helpUsages)
 {
+  let maxLength = 0;
+  for (const usage in requiredUsages) {
+    maxLength = (maxLength > usage.length ? maxLength : usage.length);
+  }
+  for (const usage in optionalUsages) {
+    maxLength = (maxLength > usage.length ? maxLength : usage.length);
+  }
+  for (const usage in helpUsages) {
+    maxLength = (maxLength > usage.length ? maxLength : usage.length);
+  }
+
+  console.log('Usages:');
+  for (const usage in requiredUsages) {
+    const spaceLength = maxLength - usage.length;
+    console.log();
+    console.log('  ' + usage + ':  ' + ' '.repeat(spaceLength) + '[Required] ' + requiredUsages[usage]);
+  }
+  for (const usage in optionalUsages) {
+    const spaceLength = maxLength - usage.length;
+    console.log();
+    console.log('  ' + usage + ':  ' + ' '.repeat(spaceLength) + '[Optional] ' + optionalUsages[usage]);
+  }
+  for (const usage in helpUsages) {
+    const spaceLength = maxLength - usage.length;
+    console.log();
+    console.log('  ' + usage + ':  ' + ' '.repeat(spaceLength) + helpUsages[usage]);
+  }
+  console.log();
+}
+
+function parseArguments(requiredUsages = {},
+                        optionalUsages = {},
+                        withoutUnparsed = true)
+{
+  const formatKey = (key) => {
+    let formattedKey = key.trim().replace(/^-*/, '');
+    formattedKey = formattedKey.replace(/-(.)/g, (x) => x[1].toUpperCase())
+    return formattedKey;
+  };
+  const formatValue = (value) => {
+    let formattedValue = (typeof(value) === 'string' ? value.trim() : value);
+    if (value === undefined
+    || value === null
+    || value === 'undefined'
+    || value === 'null'
+    || value === '') {
+      formattedValue = null;
+    }
+    return formattedValue;
+  }
+  const checkAliases = (aliases, options) => {
+    const formattedAliases = [];
+    for (const alias of aliases) {
+      const fmtAlias = formatKey(alias);
+      formattedAliases.push(fmtAlias);
+    }
+
+    let aliasValue = undefined;
+    let found = false;
+    for (const alias of formattedAliases) {
+      if (alias in options) {
+        aliasValue = options[alias];
+        found = true;
+        break;
+      }
+    }
+
+    if (found == false) {
+      return null;
+    }
+
+    const aliasedOptions = {};
+    for (const alias of formattedAliases) {
+      aliasedOptions[alias] = aliasValue;
+    }
+
+    return aliasedOptions;
+  };
+
+  const helpUsages = {
+    '-h | --help': 'Print help usages.',
+  }
+
   let options = {
     unparsed: []
   };
@@ -19,7 +102,7 @@ function parseArguments(beginWithHyphen = true)
       value = true;
     }
     if (key.startsWith('-') == false) {
-      if (beginWithHyphen) {
+      if (withoutUnparsed) {
         console.error('Failed to parse argument: ' + argu);
         process.exit(1);
       } else {
@@ -28,21 +111,34 @@ function parseArguments(beginWithHyphen = true)
       }
     }
 
-    let formattedKey = key.replace(/^-*/, '');
-    formattedKey = formattedKey.replace(/-(.)/g, (x) => x[1].toUpperCase())
- 
-    let formattedValue = value;
-    if (value === undefined
-    || value === null
-    || value === 'undefined'
-    || value === 'null'
-    || value === '') {
-      formattedValue = null;
-    }
-
+    let formattedKey = formatKey(key);
+    let formattedValue = formatValue(value);
     options[formattedKey] = formattedValue;
   }
 
+  for (const checker in helpUsages) {
+    const checkerList = checker.split('|');
+    const aliasedOptions = checkAliases(checkerList, options);
+    if (aliasedOptions) {
+      printArgumentsUsages(requiredUsages, optionalUsages, helpUsages);
+      process.exit(0);
+    }
+  }
+  for (const checker in requiredUsages) {
+    const checkerList = checker.split('|');
+    const aliasedOptions = checkAliases(checkerList, options);
+    if (!aliasedOptions) {
+      console.log('JsView Error: Failed to find required option: ' + checkerList);
+      process.exit(-1);
+    }
+    options = { ...options, ...aliasedOptions };
+  }
+  for (const checker in optionalUsages) {
+    const checkerList = checker.split('|');
+    const aliasedOptions = checkAliases(checkerList, options);
+    options = { ...options, ...aliasedOptions };
+  }
+
   return options;
 }
 
@@ -69,7 +165,7 @@ function parseArguments(beginWithHyphen = true)
  * │   │   └── jsview-vue-samples -> ../../../../@shijiu/jsview-vue-samples
  * └── src
  *     └── appConfig
-**************************************************/
+*************************************************/
 function getOptions(framework)
 {
   const options = {};

package/tools/jsview-jsmap-serve.mjs

@@ -111,16 +111,16 @@ function main(argv)
   server.listen(port, '0.0.0.0', () => {
     const ipAddrs = getIPAddress();
 
-    console.log('');
+    console.log();
     console.log('SourceMap base url: ' + context.baseUrl)
-    console.log('');
+    console.log();
     console.log('JsView server running at:');
-    console.log('');
+    console.log();
     console.log(' - Local:   http://localhost:' + port + '/');
     for(const ip of ipAddrs) {
       console.log(' - Network: http://' + ip + ':' + port + '/');
     }
-    console.log('');
+    console.log();
   });
 }
 

package/tools/jsview-post-install.js

@@ -52,7 +52,7 @@ function checkPatches(options, pkgNeedPatch, skipCheckVersion)
   for (const pkgName of pkgNeedPatch) {
     if (skipCheckVersion !== true) {
       const patchPkgDir = path.resolve(options.jsviewPatchModulesDir, pkgName);
-      const patchPkgObj = getPackageObject(options, patchPkgDir);
+      const patchPkgObj = getPackageObject(patchPkgDir);
       console.info('  ' + pkgName + ': ' + patchPkgObj.version);
 
       const modulePkgDir = path.resolve(options.modulesDir, pkgName);
@@ -110,7 +110,7 @@ async function printRevision(options)
             pluginCount++;
           }
         }
-      })
+      }
     }
   }
   console.log(`*    total:${pluginCount}`);
@@ -170,5 +170,11 @@ function main(argv)
   doPostInstall(argv.framework, pkgNeedPatch, argv.skipCheckVersion);
 }
 
-const argv = parseArguments();
+const requiredUsages = {
+  '--framework': 'Select from [vue|react]',
+};
+const optionalUsages = {
+  '--skip-check-version': 'Skip check patches version.'
+};
+const argv = parseArguments(requiredUsages, optionalUsages);
 main(argv);

package/tools/jsview-run-android.js

@@ -63,7 +63,6 @@ function androidStartActivity(options)
     }
 }
 
-const argv = parseArguments(false);
 async function main(argv)
 {
     const options = await getExtraOptions(argv);
@@ -72,4 +71,11 @@ async function main(argv)
 
     androidStartActivity(options);
 }
+
+const requiredUsages = {
+  '--framework': 'Select from [vue|react]',
+};
+const optionalUsages = {
+};
+const argv = parseArguments(requiredUsages, optionalUsages, false);
 main(argv)