@zohodesk/react-cli 0.0.1-beta.99 → 0.0.1-betaa.138.2

package/lib/utils/pullOrigin.js

@@ -1,25 +1,28 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 
-var _child_process = require('child_process');
+var _child_process = require("child_process");
 
-var _utils = require('../utils');
+var _utils = require("../utils");
 
-exports.default = function () {
-  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'git';
-  var branchName = arguments[1];
-  return new Promise(function (resolve) {
-    if (type === 'git') {
-      (0, _child_process.spawnSync)('git', ['pull', 'origin', branchName], { encoding: 'utf8' });
-      (0, _utils.log)(branchName, 'Branch Pulled!');
-      resolve();
-    } else if (type === 'hg') {
-      (0, _child_process.spawnSync)('hg', ['pull'], { encoding: 'utf8' });
-      (0, _utils.log)(branchName, 'Branch Pulled!');
-      resolve();
-    }
-  });
-};
+var _default = (type = 'git', branchName) => new Promise(resolve => {
+  if (type === 'git') {
+    (0, _child_process.spawnSync)('git', ['pull', 'origin', branchName], {
+      encoding: 'utf8'
+    });
+    (0, _utils.log)(branchName, 'Branch Pulled!');
+    resolve();
+  } else if (type === 'hg') {
+    (0, _child_process.spawnSync)('hg', ['pull'], {
+      encoding: 'utf8'
+    });
+    (0, _utils.log)(branchName, 'Branch Pulled!');
+    resolve();
+  }
+});
+
+exports.default = _default;

package/lib/utils/reinstallDependencies.js

@@ -1,118 +1,99 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.reinstallDependencies = exports.reinstallDependencies1 = exports.collectPackageDiff = undefined;
+exports.reinstallDependencies1 = exports.reinstallDependencies = exports.collectPackageDiff = void 0;
 
-var _fs = require('fs');
+var _fs = _interopRequireDefault(require("fs"));
 
-var _fs2 = _interopRequireDefault(_fs);
+var _path = _interopRequireDefault(require("path"));
 
-var _path = require('path');
+var _child_process = require("child_process");
 
-var _path2 = _interopRequireDefault(_path);
+var _gitRootDir = _interopRequireDefault(require("git-root-dir"));
 
-var _child_process = require('child_process');
-
-var _gitRootDir = require('git-root-dir');
-
-var _gitRootDir2 = _interopRequireDefault(_gitRootDir);
-
-var _index = require('./index');
+var _index = require("./index");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var packageJsons = {};
+let packageJsons = {};
 
-var packageDiffChecker = function packageDiffChecker(pre, current) {
-  var _current$dependencies = current.dependencies,
-      dependencies = _current$dependencies === undefined ? {} : _current$dependencies,
-      _current$devDependenc = current.devDependencies,
-      devDependencies = _current$devDependenc === undefined ? {} : _current$devDependenc;
+let packageDiffChecker = (pre, current) => {
+  let {
+    dependencies = {},
+    devDependencies = {}
+  } = current;
+  let diffs = {};
+  Object.keys(dependencies).forEach(pack => {
+    let version = dependencies[pack];
 
-  var diffs = {};
-  Object.keys(dependencies).forEach(function (pack) {
-    var version = dependencies[pack];
     if (version !== pre.dependencies && pre.dependencies[pack]) {
       diffs[pack] = version;
     }
   });
+  Object.keys(devDependencies).forEach(pack => {
+    let version = devDependencies[pack];
 
-  Object.keys(devDependencies).forEach(function (pack) {
-    var version = devDependencies[pack];
     if (version !== pre.devDependencies && pre.devDependencies[pack]) {
       diffs[pack] = version;
     }
   });
-
   return diffs;
 };
 
-var collectPackageDiff = exports.collectPackageDiff = function collectPackageDiff(pathToSubProjects) {
-  return new Promise(function (resolve) {
-    (0, _gitRootDir2.default)(process.cwd()).then(function (rootDir) {
-      var projects = _fs2.default.readdirSync(_path2.default.join(rootDir, pathToSubProjects));
-      projects.forEach(function (project) {
-        var packageJson = _path2.default.join(_path2.default.join(rootDir, pathToSubProjects), project, 'package.json');
-        if (_fs2.default.existsSync(packageJson)) {
-          packageJsons[project] = require(packageJson);
-        }
-      });
-      resolve();
+let collectPackageDiff = pathToSubProjects => new Promise(resolve => {
+  (0, _gitRootDir.default)(process.cwd()).then(rootDir => {
+    let projects = _fs.default.readdirSync(_path.default.join(rootDir, pathToSubProjects));
+
+    projects.forEach(project => {
+      let packageJson = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project, 'package.json');
+
+      if (_fs.default.existsSync(packageJson)) {
+        packageJsons[project] = require(packageJson);
+      }
     });
+    resolve();
   });
-};
+});
+
+exports.collectPackageDiff = collectPackageDiff;
+
+let reinstallDependencies1 = pathToSubProjects => {
+  (0, _gitRootDir.default)(process.cwd()).then(rootDir => {
+    let projects = _fs.default.readdirSync(_path.default.join(rootDir, pathToSubProjects));
+
+    projects.forEach(project => {
+      let prePackageJson = packageJsons[project];
+      let currentPackageJson;
 
-var reinstallDependencies1 = exports.reinstallDependencies1 = function reinstallDependencies1(pathToSubProjects) {
-  (0, _gitRootDir2.default)(process.cwd()).then(function (rootDir) {
-    var projects = _fs2.default.readdirSync(_path2.default.join(rootDir, pathToSubProjects));
-    projects.forEach(function (project) {
-      var prePackageJson = packageJsons[project];
-      var currentPackageJson = void 0;
       if (prePackageJson) {
-        currentPackageJson = _path2.default.join(_path2.default.join(rootDir, pathToSubProjects), project, 'package.json');
-        if (_fs2.default.existsSync(currentPackageJson)) {
+        currentPackageJson = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project, 'package.json');
+
+        if (_fs.default.existsSync(currentPackageJson)) {
           currentPackageJson = require(currentPackageJson);
         }
       }
-      var projPath = _path2.default.join(_path2.default.join(rootDir, pathToSubProjects), project);
-      var diffs = packageDiffChecker(prePackageJson, currentPackageJson);
+
+      let projPath = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project);
+
+      let diffs = packageDiffChecker(prePackageJson, currentPackageJson);
+
       if (Object.keys(diffs).length) {
-        (0, _index.log)(diffs, 'package diffs between branches for ' + project + ' project');
+        (0, _index.log)(diffs, `package diffs between branches for ${project} project`);
         (0, _child_process.spawnSync)('rm', ['-rf', 'package-lock.json'], {
           cwd: projPath,
           stdio: 'inherit'
         });
-        var packages = Object.keys(diffs);
-        var dummy = [];
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-          for (var _iterator = packages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var name = _step.value;
-
-            var version = diffs[name];
-            dummy.push(name + '@' + version);
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
+        let packages = Object.keys(diffs);
+        let dummy = [];
+
+        for (let name of packages) {
+          let version = diffs[name];
+          dummy.push(`${name}@${version}`);
         }
 
-        (0, _index.log)('npm ' + ['install'].concat(dummy).join(' '));
+        (0, _index.log)(`npm ${['install'].concat(dummy).join(' ')}`);
         (0, _child_process.spawnSync)('npm', ['install'].concat(dummy), {
           cwd: projPath,
           stdio: 'inherit'
@@ -122,21 +103,31 @@ var reinstallDependencies1 = exports.reinstallDependencies1 = function reinstall
           cwd: projPath,
           stdio: 'inherit'
         });
-        (0, _child_process.spawnSync)('npm', ['install'], { cwd: projPath, stdio: 'inherit' });
+        (0, _child_process.spawnSync)('npm', ['install'], {
+          cwd: projPath,
+          stdio: 'inherit'
+        });
       }
     });
   });
 };
 
-var reinstallDependencies = exports.reinstallDependencies = function reinstallDependencies(pathToSubProjects) {
-  return new Promise(function (resolve) {
-    (0, _gitRootDir2.default)(process.cwd()).then(function (rootDir) {
-      var projects = _fs2.default.readdirSync(_path2.default.join(rootDir, pathToSubProjects));
-      projects.forEach(function (project) {
-        var projPath = _path2.default.join(_path2.default.join(rootDir, pathToSubProjects), project);
-        (0, _child_process.spawnSync)('npm', ['install'], { cwd: projPath, stdio: 'inherit' });
-        resolve();
+exports.reinstallDependencies1 = reinstallDependencies1;
+
+let reinstallDependencies = pathToSubProjects => new Promise(resolve => {
+  (0, _gitRootDir.default)(process.cwd()).then(rootDir => {
+    let projects = _fs.default.readdirSync(_path.default.join(rootDir, pathToSubProjects));
+
+    projects.forEach(project => {
+      let projPath = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project);
+
+      (0, _child_process.spawnSync)('npm', ['install'], {
+        cwd: projPath,
+        stdio: 'inherit'
       });
+      resolve();
     });
   });
-};
+});
+
+exports.reinstallDependencies = reinstallDependencies;

package/lib/utils/removeAttributes.js

@@ -1,32 +1,34 @@
-'use strict';
+"use strict";
 
-var _getOptions = require('./getOptions');
-
-var _getOptions2 = _interopRequireDefault(_getOptions);
+var _getOptions = _interopRequireDefault(require("./getOptions"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var options = (0, _getOptions2.default)();
+let options = (0, _getOptions.default)();
+let {
+  app: {
+    attrbuteNames
+  }
+} = options;
 
-var attrbuteNames = options.app.attrbuteNames;
+module.exports = () => ({
+  visitor: {
+    Program(path, state) {
+      let properties = state.opts.properties || [];
 
+      if (properties.length === 0) {
+        properties = properties.concat(attrbuteNames);
+      }
 
-module.exports = function () {
-  return {
-    visitor: {
-      Program: function Program(path, state) {
-        var properties = state.opts.properties || [];
-        if (properties.length === 0) {
-          properties = properties.concat(attrbuteNames);
-        }
-        path.traverse({
-          JSXIdentifier: function JSXIdentifier(path2) {
-            if (properties.indexOf(path2.node.name.toLowerCase()) > -1) {
-              path2.parentPath.remove();
-            }
+      path.traverse({
+        JSXIdentifier(path2) {
+          if (properties.indexOf(path2.node.name.toLowerCase()) > -1) {
+            path2.parentPath.remove();
           }
-        });
-      }
+        }
+
+      });
     }
-  };
-};
+
+  }
+});

package/lib/utils/repoClone.js

@@ -1,88 +1,89 @@
-'use strict';
+"use strict";
 
-var _os = require('os');
+var _os = require("os");
 
-var _path = require('path');
+var _path = _interopRequireDefault(require("path"));
 
-var _path2 = _interopRequireDefault(_path);
+var _fs = _interopRequireDefault(require("fs"));
 
-var _fs = require('fs');
+var _child_process = require("child_process");
 
-var _fs2 = _interopRequireDefault(_fs);
-
-var _child_process = require('child_process');
-
-var _index = require('./index');
+var _index = require("./index");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var options = (0, _index.getOptions)();
-
-var _options$clone = options.clone,
-    type = _options$clone.type,
-    url = _options$clone.url,
-    branch = _options$clone.branch,
-    revision = _options$clone.revision,
-    projectName = _options$clone.projectName,
-    cacheDir = _options$clone.cacheDir,
-    remoteName = _options$clone.remoteName,
-    shouldDelete = _options$clone.shouldDelete;
-
+let options = (0, _index.getOptions)();
+let {
+  clone: {
+    type,
+    url,
+    branch,
+    revision,
+    projectName,
+    cacheDir,
+    remoteName,
+    shouldDelete
+  }
+} = options;
 
 if (type && (type === 'git' || type === 'hg')) {
-  (0, _index.log)('Going to clone ' + type + ' repository');
+  (0, _index.log)(`Going to clone ${type} repository`);
 } else {
   throw new Error('You must give valid type to clone a repository');
 }
 
 if (!cacheDir) {
-  cacheDir = _path2.default.join((0, _os.homedir)(), '.react-cli');
+  cacheDir = _path.default.join((0, _os.homedir)(), '.react-cli');
 } else {
-  cacheDir = _path2.default.join(process.cwd(), cacheDir);
+  cacheDir = _path.default.join(process.cwd(), cacheDir);
 }
 
 if (!projectName) {
-  var _path$parse = _path2.default.parse(url),
-      name = _path$parse.name;
+  let {
+    name
+  } = _path.default.parse(url);
 
   projectName = name;
 }
 
-var projectPath = _path2.default.join(cacheDir, projectName);
+let projectPath = _path.default.join(cacheDir, projectName);
 
-var cloneRepo = function cloneRepo() {
-  if (!_fs2.default.existsSync(cacheDir)) {
-    _fs2.default.mkdirSync(cacheDir);
+let cloneRepo = () => {
+  if (!_fs.default.existsSync(cacheDir)) {
+    _fs.default.mkdirSync(cacheDir);
   }
-  var revisionOrBranch = void 0;
+
+  let revisionOrBranch;
 
   if (type === 'git') {
-    revisionOrBranch = '-b' + branch;
+    revisionOrBranch = `-b${branch}`;
   } else {
     if (revision) {
-      revisionOrBranch = '-r' + revision;
+      revisionOrBranch = `-r${revision}`;
     } else {
-      revisionOrBranch = '-b' + branch;
+      revisionOrBranch = `-b${branch}`;
     }
   }
-  (0, _index.log)('Going to clone ' + url + ' repo to ' + cacheDir + ' path');
+
+  (0, _index.log)(`Going to clone ${url} repo to ${cacheDir} path`);
   (0, _child_process.spawnSync)(type, ['clone', url, revisionOrBranch, projectName], {
     cwd: cacheDir,
     stdio: 'inherit'
   });
 
-  _fs2.default.writeFileSync(_path2.default.join(projectPath, type === 'hg' ? '.hg' : '.git', 'remoteUrl'), url);
+  _fs.default.writeFileSync(_path.default.join(projectPath, type === 'hg' ? '.hg' : '.git', 'remoteUrl'), url);
 
   (0, _index.log)('Repository cloned!');
 };
 
-var getRemoteURL = function getRemoteURL() {
-  var remoteUrl = _fs2.default.readFileSync(_path2.default.join(projectPath, type === 'hg' ? '.hg' : '.git', 'remoteUrl')).toString();
+let getRemoteURL = () => {
+  let remoteUrl = _fs.default.readFileSync(_path.default.join(projectPath, type === 'hg' ? '.hg' : '.git', 'remoteUrl')).toString();
+
   return remoteUrl.trim();
 };
 
-if (_fs2.default.existsSync(projectPath)) {
-  var remoteUrl = getRemoteURL();
+if (_fs.default.existsSync(projectPath)) {
+  let remoteUrl = getRemoteURL();
 
   if (remoteUrl === url) {
     if (type === 'git') {
@@ -91,12 +92,14 @@ if (_fs2.default.existsSync(projectPath)) {
         stdio: 'inherit'
       });
     } else {
-      var revisionOrBranch = void 0;
+      let revisionOrBranch;
+
       if (revision) {
-        revisionOrBranch = '-r' + revision;
+        revisionOrBranch = `-r${revision}`;
       } else {
-        revisionOrBranch = '-b' + branch;
+        revisionOrBranch = `-b${branch}`;
       }
+
       (0, _child_process.spawnSync)(type, ['pull', revisionOrBranch, '-u', url], {
         cwd: projectPath,
         stdio: 'inherit'
@@ -107,7 +110,6 @@ if (_fs2.default.existsSync(projectPath)) {
       cwd: cacheDir,
       stdio: 'inherit'
     });
-
     (0, _index.log)('Existing repository deleted!');
     cloneRepo();
   }

package/lib/utils/request.js

@@ -1,93 +1,80 @@
-'use strict';
+"use strict";
 
-var https = require('https');
-var http = require('http');
-var url = require('url');
-var querystring = require('querystring');
+const https = require('https');
 
-var isObject = function isObject(data) {
-  return data && data.toString && data.toString() === '[object Object]';
-};
+const http = require('http');
 
-var isArray = function isArray(data) {
-  return data && Array.isArray(data);
-};
+const url = require('url');
 
-process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+const querystring = require('querystring');
 
-var callback = function callback(resolve) {
-  return function (res) {
-    res.setEncoding('utf8');
-    var str = '';
+let isObject = data => data && data.toString && data.toString() === '[object Object]';
 
-    res.on('data', function (chunk) {
-      str += chunk;
-    });
+let isArray = data => data && Array.isArray(data);
 
-    res.on('end', function () {
-      resolve({
-        body: str,
-        response: res
-      });
-    });
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 
-    res.on('error', function (err) {
-      process.stdout.write(err);
+let callback = resolve => res => {
+  res.setEncoding('utf8');
+  let str = '';
+  res.on('data', chunk => {
+    str += chunk;
+  });
+  res.on('end', () => {
+    resolve({
+      body: str,
+      response: res
     });
-  };
+  });
+  res.on('error', err => {
+    process.stdout.write(err);
+  });
 };
 
-var request = function request(options) {
-  return new Promise(function (resolve, reject) {
-    var _url$parse = url.parse(options.url),
-        protocol = _url$parse.protocol,
-        hostname = _url$parse.hostname,
-        path = _url$parse.path,
-        port = _url$parse.port;
-
-    var _options$method = options.method,
-        method = _options$method === undefined ? 'GET' : _options$method,
-        _options$headers = options.headers,
-        headers = _options$headers === undefined ? {} : _options$headers,
-        _options$payload = options.payload,
-        payload = _options$payload === undefined ? null : _options$payload,
-        _options$formdata = options.formdata,
-        formdata = _options$formdata === undefined ? null : _options$formdata;
-
-
-    var newOptions = {
-      host: hostname,
-      port: port,
-      path: path,
-      method: method,
-      headers: headers
-    };
-    var req = void 0;
-
-    if (protocol === 'https:') {
-      req = https.request(newOptions, callback(resolve));
-    } else if (protocol === 'http:') {
-      req = http.request(newOptions, callback(resolve));
-    }
-
-    if (method.toUpperCase() === 'POST') {
-      if (isObject(payload) || isArray(payload)) {
-        payload = JSON.stringify(payload);
-        req.write(payload);
-      } else if (isObject(formdata)) {
-        formdata = querystring.stringify(formdata);
-        req.write(formdata);
-      }
+let request = options => new Promise((resolve, reject) => {
+  let {
+    protocol,
+    hostname,
+    path,
+    port
+  } = url.parse(options.url);
+  let {
+    method = 'GET',
+    headers = {},
+    payload = null,
+    formdata = null
+  } = options;
+  let newOptions = {
+    host: hostname,
+    port: port,
+    path: path,
+    method: method,
+    headers: headers
+  };
+  let req;
+
+  if (protocol === 'https:') {
+    req = https.request(newOptions, callback(resolve));
+  } else if (protocol === 'http:') {
+    req = http.request(newOptions, callback(resolve));
+  }
+
+  if (method.toUpperCase() === 'POST') {
+    if (isObject(payload) || isArray(payload)) {
+      payload = JSON.stringify(payload);
+      req.write(payload);
+    } else if (isObject(formdata)) {
+      formdata = querystring.stringify(formdata);
+      req.write(formdata);
     }
+  }
 
-    req.on('error', function (err) {
-      //eslint-disable-next-line
-      console.log(err);
-      reject();
-    });
-
-    req.end();
+  req.on('error', err => {
+    //eslint-disable-next-line
+    console.log(err);
+    reject();
   });
-};
+  req.end();
+});
 
 module.exports = request;