@zohodesk/react-cli 0.0.1-beta.16 → 0.0.1-beta.160

package/lib/utils/cssURLReplacer.js

@@ -1,70 +1,72 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.cssUrlReplacer = exports.getUrls = exports.getFileType = undefined;
+exports.cssUrlReplacer = exports.getUrls = exports.getFileType = 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 _path2 = _interopRequireDefault(_path);
-
-var _crypto = require('crypto');
-
-var _crypto2 = _interopRequireDefault(_crypto);
+var _crypto = _interopRequireDefault(require("crypto"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var urlRegex = /url\(.*?\)/g;
+let urlRegex = /url\(.*?\)/g;
 
-var getHash = function getHash(file) {
-  var isPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var needSubStr = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+let getHash = (file, isPath = false, needSubStr = true) => {
+  let hash = _crypto.default.createHash('md5');
 
-  var hash = _crypto2.default.createHash('md5');
   if (isPath) {
-    hash.update(_fs2.default.readFileSync(file));
+    hash.update(_fs.default.readFileSync(file));
   } else {
     hash.update(file);
   }
+
   hash = hash.digest('hex');
   return hash ? needSubStr ? hash.substring(0, 20) : hash : null;
 };
 
-var getFileType = exports.getFileType = function getFileType(file) {
-  var _path$parse = _path2.default.parse(file),
-      ext = _path$parse.ext;
+let getFileType = file => {
+  let {
+    ext
+  } = _path.default.parse(file);
 
   if (ext === '.gif' || ext === '.png' || ext === '.jpg' || ext === '.jpeg' || ext === '.ico') {
     return 'image';
   } else if (ext === '.svg' || ext === '.woff' || ext === '.eot' || ext === '.ttf' || ext === '.woff2') {
     return 'font';
+  } else if (ext === '.js') {
+    return 'js';
+  } else if (ext === '.css') {
+    return 'css';
   }
+
   return null;
 };
 
-var formatUrl = function formatUrl(str) {
-  var char = str.includes('"') ? '"' : str.includes('\'') ? '\'' : '(';
-  var statingIdx = str.indexOf(char) + 1;
-  var substr = str.substring(statingIdx, str.length);
+exports.getFileType = getFileType;
+
+let formatUrl = str => {
+  let char = str.includes('"') ? '"' : str.includes('\'') ? '\'' : '(';
+  let statingIdx = str.indexOf(char) + 1;
+  let substr = str.substring(statingIdx, str.length);
   char = char === '(' ? ')' : char;
   return substr.substring(0, substr.indexOf(char));
 };
 
-var getUrls = exports.getUrls = function getUrls(css) {
-  var urlMatches = css.match(urlRegex);
-  var src = css;
+let getUrls = css => {
+  let urlMatches = css.match(urlRegex);
+  let src = css;
+
   if (urlMatches) {
-    var patterns = {};
-    urlMatches.forEach(function (pattern) {
-      var url = formatUrl(pattern);
-      var hash = getHash(url);
+    let patterns = {};
+    urlMatches.forEach(pattern => {
+      let url = formatUrl(pattern);
+      let hash = getHash(url);
       patterns[url] = hash;
-      var regex = new RegExp(pattern.replace(/([<>*()?${}|])/g, '\\$1'), 'g');
+      let regex = new RegExp(pattern.replace(/([<>*()?${}|])/g, '\\$1'), 'g');
       src = src.replace(regex, hash);
     });
     return {
@@ -74,17 +76,19 @@ var getUrls = exports.getUrls = function getUrls(css) {
   }
 };
 
-var cssUrlReplacer = exports.cssUrlReplacer = function cssUrlReplacer(css, domains) {
-  var chunkHash = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+exports.getUrls = getUrls;
+
+let cssUrlReplacer = (css, domains, chunkHash = {}) => {
+  let obj = getUrls(css);
+  let src = css;
 
-  var obj = getUrls(css);
-  var src = css;
   if (obj) {
-    var patterns = obj.urls;
+    let patterns = obj.urls;
     src = obj.css;
-    Object.keys(patterns).forEach(function (pattern) {
-      var urlParts = pattern.split('/');
-      var fileName = urlParts.pop();
+    Object.keys(patterns).forEach(pattern => {
+      let urlParts = pattern.split('/');
+      let fileName = urlParts.pop();
+
       if (fileName.includes('#')) {
         if (fileName.includes('?')) {
           fileName = fileName.replace(/\?.*#/g, '#');
@@ -92,32 +96,41 @@ var cssUrlReplacer = exports.cssUrlReplacer = function cssUrlReplacer(css, domai
       } else {
         fileName = fileName.replace(/\?.*$/g, '');
       }
-      var hash = patterns[pattern];
-      var filename = fileName.replace(/(\?|#).*?$/g, '');
-      var regex = new RegExp(hash, 'g');
-      var hashedName = chunkHash[filename] || fileName;
-      if (domains) {
-        var font = domains.font,
-            image = domains.image;
-
-        var type = getFileType(filename);
-        var customPath = type === 'image' ? image : type === 'font' ? font : urlParts.join('/');
+
+      let hash = patterns[pattern];
+      let filename = fileName.replace(/(\?|#).*?$/g, '');
+      let regex = new RegExp(hash, 'g');
+      let {
+        hashedName
+      } = chunkHash[filename] || fileName;
+
+      if (domains && typeof urlParts[0] === 'string' && !urlParts[0].includes('http')) {
+        let {
+          font,
+          image
+        } = domains;
+        let type = getFileType(filename);
+        let customPath = type === 'image' ? `${image}/images` : type === 'font' ? `${font}/fonts` : urlParts.join('/');
         urlParts = customPath.split('/');
       }
 
       if (hashedName) {
         if (fileName.includes('#')) {
           if (fileName.includes('?')) {
-            hashedName = hashedName + '?' + fileName.split('?')[1];
+            hashedName = `${hashedName}?${fileName.split('?')[1]}`;
           } else {
-            hashedName = hashedName + '#' + fileName.split('#')[1];
+            hashedName = `${hashedName}#${fileName.split('#')[1]}`;
           }
         }
       }
+
       urlParts.push(hashedName || fileName);
       urlParts = urlParts.join('/');
-      src = src.replace(regex, 'url(\'' + urlParts + '\')');
+      src = src.replace(regex, `url('${urlParts}')`);
     });
   }
+
   return src;
-};
+};
+
+exports.cssUrlReplacer = cssUrlReplacer;

package/lib/utils/dependencyPostPublish.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _child_process = require("child_process");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _request = _interopRequireDefault(require("./request"));
+
+var _index = require("./index");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let changeset = (0, _child_process.execSync)('git rev-parse HEAD', {
+  cwd: process.cwd()
+}).toString() || '';
+changeset = changeset.trim();
+
+if (!changeset) {
+  throw new Error('Changeset doesn\'t exists');
+}
+
+(0, _index.log)(changeset, 'changeset');
+
+let {
+  version,
+  name
+} = require(_path.default.join(process.cwd(), './package.json'));
+
+(0, _request.default)({
+  url: `${'ht'}${'tp'}://tsi-desk-mock.tsi.zohocorpin.com:8080/Hbase/addKey?method=addkey`,
+  method: 'POST',
+  payload: {
+    tablename: `${name.replace('@', '').replace(/\//g, '_')}_changesets`,
+    row: 'dependencies_changesets',
+    column: version,
+    value: changeset
+  }
+}).then(res => {
+  (0, _index.log)(`changeset push done --> ${res.body}`);
+}).catch(e => {
+  throw e;
+});

package/lib/utils/fileUtils.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copy = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _index = require("./index");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let removeDirectory = dirPath => {
+  _fs.default.readdirSync(dirPath).forEach(fileOrDir => {
+    let fileOrDirPath = _path.default.join(dirPath, fileOrDir);
+
+    if (_fs.default.statSync(fileOrDirPath).isDirectory()) {
+      removeDirectory(fileOrDirPath);
+    } else {
+      _fs.default.unlinkSync(fileOrDirPath);
+    }
+  });
+
+  _fs.default.rmdirSync(dirPath);
+};
+
+let copyFile = (srcPath, targetPath, isCopy = true, changeExt) => {
+  let {
+    ext,
+    dir,
+    name,
+    root
+  } = _path.default.parse(targetPath);
+
+  if (changeExt[ext]) {
+    ext = changeExt[ext];
+    targetPath = _path.default.format({
+      ext,
+      dir,
+      name,
+      root
+    }); //eslint-disable-line
+  }
+
+  let readStream = _fs.default.createReadStream(srcPath);
+
+  let writeStream = _fs.default.createWriteStream(targetPath);
+
+  readStream.pipe(writeStream);
+  writeStream.on('finish', () => {
+    if (!isCopy) {
+      _fs.default.unlinkSync(srcPath);
+    }
+  });
+};
+
+let iterateDirectory = (srcPath, targetPath, isCopy, extensions, flatten, changeExt) => {
+  _fs.default.readdirSync(srcPath).forEach(fileOrDir => {
+    let fromPath = _path.default.join(srcPath, fileOrDir);
+
+    let toPath = targetPath;
+
+    if (flatten !== 'flatten' || !_fs.default.statSync(fromPath).isDirectory()) {
+      toPath = _path.default.join(targetPath, fileOrDir);
+    }
+
+    if (_fs.default.statSync(fromPath).isDirectory()) {
+      if (!_fs.default.existsSync(toPath)) {
+        _fs.default.mkdirSync(toPath);
+      }
+
+      iterateDirectory(fromPath, toPath, isCopy, extensions, flatten, changeExt);
+    } else {
+      if (extensions) {
+        let {
+          ext
+        } = _path.default.parse(fromPath);
+
+        if (extensions.indexOf(ext) !== -1) {
+          copyFile(fromPath, toPath, true, changeExt);
+        }
+      } else {
+        copyFile(fromPath, toPath, true, changeExt);
+      }
+    }
+  });
+};
+
+let copy = (srcPath, targetPath, isCopy, exts, flatten, changeExt = {}) => {
+  if (_fs.default.statSync(srcPath).isDirectory()) {
+    if (!_fs.default.existsSync(targetPath)) {
+      _fs.default.mkdirSync(targetPath);
+    }
+
+    let {
+      name
+    } = _path.default.parse(srcPath);
+
+    let originPath = targetPath;
+
+    if (flatten !== 'flatten') {
+      originPath = _path.default.join(targetPath, name);
+
+      if (!_fs.default.existsSync(originPath)) {
+        _fs.default.mkdirSync(originPath);
+      }
+    }
+
+    iterateDirectory(srcPath, originPath, isCopy, exts, flatten, changeExt);
+  } else {
+    /* direct file copy issue there but that feature not needed i think*/
+    copyFile(srcPath, targetPath, isCopy, changeExt);
+  }
+
+  if (!isCopy) {
+    removeDirectory(srcPath);
+  }
+
+  (0, _index.log)(isCopy ? 'Folder/file are copied!' : 'Folder/file are moved!');
+};
+
+exports.copy = copy;

package/lib/utils/folderIterator.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let iterateDirectory = (srcPath, targetPath, extensions, flatten, cb) => {
+  _fs.default.readdirSync(srcPath).forEach(fileOrDir => {
+    let fromPath = _path.default.join(srcPath, fileOrDir);
+
+    let toPath = targetPath;
+
+    if (flatten !== 'flatten' || !_fs.default.statSync(fromPath).isDirectory()) {
+      toPath = _path.default.join(targetPath, fileOrDir);
+    }
+
+    if (_fs.default.statSync(fromPath).isDirectory()) {
+      if (!_fs.default.existsSync(toPath)) {
+        _fs.default.mkdirSync(toPath);
+      }
+
+      iterateDirectory(fromPath, toPath, extensions, flatten, cb);
+    } else {
+      if (extensions) {
+        let {
+          ext
+        } = _path.default.parse(fromPath);
+
+        if (extensions.indexOf(ext) !== -1) {
+          cb(fromPath, toPath);
+        }
+      } else {
+        cb(fromPath, toPath);
+      }
+    }
+  });
+};
+
+var _default = iterateDirectory;
+exports.default = _default;

package/lib/utils/getComponents.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+let eliminateDuplicates = inputList => {
+  let outputList = [];
+  let tempObj = {};
+
+  for (let i = 0; i < inputList.length; i++) {
+    tempObj[inputList[i]] = 1;
+  }
+
+  for (let j in tempObj) {
+    if (tempObj[j]) {
+      outputList.push(j);
+    }
+  }
+
+  outputList = outputList.filter(item => item);
+  return outputList;
+};
+
+let removeExtn = componentObjectList => {
+  let fileNameArray = [];
+  componentObjectList.forEach(fileObject => {
+    let filename = fileObject.name.includes('.docs.js') ? fileObject.name.replace('.docs.js', '') : fileObject.name.replace('.js', '');
+    fileNameArray.push(filename);
+  });
+  return fileNameArray;
+};
+
+let getChangedFileName = impactedObject => {
+  let changedComponentsList = [];
+
+  if (impactedObject.ADDED && impactedObject.ADDED.length) {
+    changedComponentsList = changedComponentsList.concat(removeExtn(impactedObject.ADDED));
+  }
+
+  if (impactedObject.UPDATED && impactedObject.UPDATED.length) {
+    changedComponentsList = changedComponentsList.concat(removeExtn(impactedObject.UPDATED));
+  }
+
+  if (impactedObject.REMOVED && impactedObject.REMOVED.length) {
+    changedComponentsList = changedComponentsList.concat(removeExtn(impactedObject.REMOVED));
+  }
+
+  return changedComponentsList;
+};
+
+let referencedbyList = [];
+
+let getReferencedBy = (moduleDataObject, fileName) => {
+  if (moduleDataObject[fileName]) {
+    let referenceObject = moduleDataObject[fileName];
+    let referencedbyObject = referenceObject.referencedby;
+
+    if (referencedbyObject.length) {
+      if (!referencedbyList.includes(referenceObject.docsName)) {
+        referencedbyList.push(referenceObject.docsName);
+      }
+
+      referencedbyObject.forEach(referencedByFile => {
+        if (!referencedbyList.includes(moduleDataObject[referencedByFile].docsName)) {
+          let result = getReferencedBy(moduleDataObject, referencedByFile);
+
+          if (typeof result === 'string') {
+            referencedbyList.push(result);
+          }
+        }
+      });
+    } else {
+      return fileName;
+    }
+  }
+
+  return referencedbyList;
+};
+
+let checkDocs = AppComponentObject => {
+  let unDocsComponentNameList = [];
+  Object.keys(AppComponentObject).forEach(actionKey => {
+    AppComponentObject[actionKey].forEach(compObj => {
+      if (compObj.FILEPATH.includes('/src/components/')) {
+        if (compObj.name.includes('.js') || compObj.name.includes('.css')) {
+          if (!compObj.name.includes('.docs.')) {
+            if (!compObj.FILEPATH.includes('/src/components/docs/')) {
+              unDocsComponentNameList.push(process.cwd() + compObj.FILEPATH.replace('jsapps/supportapp', ''));
+            }
+          }
+        }
+      }
+    });
+  });
+  return unDocsComponentNameList;
+};
+
+var _default = (mDataStr, ComponentObj) => {
+  let mDataObject = JSON.parse(mDataStr);
+  let impactedComponentList = [];
+  let unDocsComList = [];
+  Object.keys(ComponentObj).forEach(libraryName => {
+    if (libraryName === 'AppSource') {
+      unDocsComList = checkDocs(ComponentObj[libraryName]);
+    }
+
+    let totalChangedFilesList = getChangedFileName(ComponentObj[libraryName]);
+    totalChangedFilesList.forEach(changedFileName => {
+      let referencedByComponents = getReferencedBy(mDataObject, changedFileName);
+
+      if (Array.isArray(referencedByComponents)) {
+        impactedComponentList = impactedComponentList.concat(referencedByComponents);
+      } else if (typeof referencedByComponents === 'string') {
+        impactedComponentList.push(referencedByComponents);
+      }
+    });
+  });
+  return {
+    impactedComponentList: eliminateDuplicates(impactedComponentList),
+    unDocsComList: unDocsComList
+  };
+};
+
+exports.default = _default;

package/lib/utils/getCurrentBranch.js

@@ -1,35 +1,29 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+var _child_process = require("child_process");
 
-var _child_process = require('child_process');
+var _default = (type = 'git', cwd = process.cwd()) => {
+  let results;
 
-exports.default = function () {
-  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'git';
-  var cwd = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : __dirname;
-
-  var results = void 0;
   if (type === 'git') {
     results = (0, _child_process.spawnSync)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
       encoding: 'utf8',
-      cwd: cwd
+      cwd
     });
   } else if (type === 'hg') {
     results = (0, _child_process.spawnSync)('hg', ['identify', '-b'], {
       encoding: 'utf8',
-      cwd: cwd
+      cwd
     });
   }
 
-  var _results$output$filte = results.output.filter(function (d) {
-    return d;
-  }),
-      _results$output$filte2 = _slicedToArray(_results$output$filte, 1),
-      currentBranch = _results$output$filte2[0];
-
+  let [currentBranch] = results.output.filter(d => d);
   return currentBranch.replace(/(\r\n|\n|\r)/gm, '');
-};
+};
+
+exports.default = _default;