@zohodesk/react-cli 0.0.1-exp.175.1 → 0.0.1-exp.176.11

package/lib/postcss-plugins/variableModificationPlugin/index.js

@@ -1,10 +1,18 @@
 "use strict";
 
 const postcss = require('postcss');
+
 const fs = require('fs');
+
 const path = require('path');
+
+const {
+  ErrorHandler
+} = require('./ErrorHandler');
+
 const errors = [];
-let allowedErrs = {};
+const errorTable = [];
+const errHandler = new ErrorHandler();
 const convertableProps = {
   'font-size': true,
   margin: true,
@@ -26,37 +34,58 @@ const convertableProps = {
   top: true,
   bottom: true,
   left: true,
-  right: true
+  right: true,
+  'text-indent': true,
+  clip: true,
+  'flex-basis': true,
+  'row-gap': true,
+  gap: true,
+  'column-gap': true,
+  flex: true
 };
 const constantValues = {
   inherit: true,
   initial: true,
   auto: true,
   'fit-content': true,
-  unset: true
+  unset: true,
+  cover: true,
+  contain: true,
+  top: true,
+  bottom: true,
+  left: true,
+  center: true,
+  right: true
 };
+
 function getNumericValue(value) {
   if (value.includes('var')) {
     return parseInt(value.replace(/var\(--zd_size(\d+)\)/gi, '$1').replace(/var\(--zd_font_size(\d+)\)/gi, '$1'));
   }
 
-  // Not need for this dum loop
+  if (value.includes('rect')) {
+    return parseInt(value.replace('rect(', '').replace(')', '').replace(',', ''));
+  } // Not need for this dum loop
   // allowed.forEach(alwdUnit => {
   //   if (value.includes(alwdUnit)) {
   //     return parseInt(value);
   //   }
   // });
 
+
   if (constantValues[value.toLowerCase()]) {
     return 1;
   }
+
   return parseInt(value);
 }
+
 function pxToCalc(value) {
   const arr = value.split(' ');
   arr.forEach((val, index) => {
     ['px'].forEach(unit => {
       const valWithUnit = new RegExp(`(\\d+)${unit}`, 'gi');
+
       if (valWithUnit.test(val)) {
         arr[index] = val.replace(valWithUnit, '(var(--zd_size$1))');
       }
@@ -64,169 +93,214 @@ function pxToCalc(value) {
   });
   return arr.join(' ');
 }
-const addError = errstr => {
-  errors.push(`{\n${errstr}\n}\n`);
-};
-const errorFunction = (errStr, type) => {
-  if (type === 'DECLARATION_IGNORED' && allowedErrs.DECLARATION_IGNORED) {
-    addError(errStr);
-  } else if (type === 'UNIT_ERROR' && allowedErrs.UNIT_ERROR) {
-    addError(errStr);
-  } else if (type === 'RANGE_ERROR' && allowedErrs.RANGE_ERROR) {
-    addError(errStr);
-  } else if (type === 'VARIABLE_PRESENT' && allowedErrs.VARIABLE_PRESENT) {
-    addError(errStr);
-  }
-};
+
 const singleConvertor = (value, changeVal, details, range) => {
   const {
     path,
     filename,
     decl
   } = details;
+
+  if (decl.prop === 'background-position') {
+    if (isNaN(parseInt(value))) {
+      // console.log(`${value} skipped`);
+      return;
+    }
+  }
+
   if (getNumericValue(value) >= range.start && getNumericValue(value) <= range.end || getNumericValue(value) === 0) {
     let retVal = value.replace(/(\d+)px/gi, changeVal.replace('$$', '$1'));
+
     if (/^-var/.test(retVal)) {
       retVal = `calc( ${retVal.substring(1)} * -1 )`;
     }
+
     return retVal;
-  }
+  } // if (!value.includes('rect')) {
   // if(unitErrorVal && unitErrorVal != '0' ){
   // console.log(value, 'not within range')
-  errorFunction(` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${path} ,\n line : ${decl.source.start.line} ,\n message : value (${value}) (${typeof value}) not within range (${range.start},${range.end})\r`, 'RANGE_ERROR');
+
+
+  let errObj = {
+    decl,
+    type: 'RANGE_ERROR',
+    filename,
+    message: `value (${value}) (${typeof value}) not within range (${range.start},${range.end})\r`,
+    path: path
+  };
+  errHandler.errorTable.push(errObj);
+  errHandler.errorFunction(errObj); // errorFunction(
+  //   {
+  //     decl,
+  //     type: 'RANGE_ERROR',
+  //     filename,
+  //     message: `value (${value}) (${typeof value}) not within range (${
+  //       range.start
+  //     },${range.end})\r`,
+  //     path: path
+  //   },
+  //   'RANGE_ERROR'
+  // );
   // }
   // addError(` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${path} ,\n line : ${decl.source.start.line} ,\n message : value (${value}) not within range (${range.start},${range.end})\r`)
-  return value;
+  //   return value;
+  // } else {
+  //   console.log('++++++++++++++++++++++rect val!', value);
+  // }
 };
-module.exports = postcss.plugin('postcss-variable-report', cssVariableReplacementConfig => {
-  const rawdata = fs.readFileSync(cssVariableReplacementConfig);
-  const data = JSON.parse(rawdata);
-  const {
-    errorsAllowed,
-    settings: settingsObject,
-    errorLog: errorLogStatus,
-    errorInConsole: errorConsoleStatus
-  } = data;
-  // const keys = Object.keys(settingsObject);
-  allowedErrs = errorsAllowed;
-  const replacementArray = [];
-  Object.keys(settingsObject).forEach(key => {
-    Object.values(settingsObject[key].replacements).forEach(val => {
-      if (!replacementArray.includes(val)) {
-        replacementArray.push(val);
+
+module.exports = {
+  plugin: postcss.plugin('postcss-variable-report', cssVariableReplacementConfig => {
+    const rawdata = fs.readFileSync(cssVariableReplacementConfig);
+    const data = JSON.parse(rawdata);
+    const {
+      errorsAllowed,
+      settings: settingsObject // errorLog: errorLogStatus,
+      // errorInConsole: errorConsoleStatus
+
+    } = data; // const keys = Object.keys(settingsObject);
+
+    errHandler.setAllowedErrs(errorsAllowed);
+    const replacementArray = [];
+    Object.keys(settingsObject).forEach(key => {
+      Object.values(settingsObject[key].replacements).forEach(val => {
+        if (!replacementArray.includes(val)) {
+          replacementArray.push(val);
+        }
+      });
+    });
+    let regValStr = '';
+    replacementArray.forEach((val, index) => {
+      if (index !== replacementArray.length - 1) {
+        regValStr += `${val.replace('$$', '\\d+').replace('(', '\\(').replace(')', '\\)')}|`;
+      } else {
+        regValStr += `${val.replace('$$', '\\d+').replace('(', '\\(').replace(')', '\\)')}`;
       }
     });
-  });
-  let regValStr = '';
-  replacementArray.forEach((val, index) => {
-    if (index !== replacementArray.length - 1) {
-      regValStr += `${val.replace('$$', '\\d+').replace('(', '\\(').replace(')', '\\)')}|`;
-    } else {
-      regValStr += `${val.replace('$$', '\\d+').replace('(', '\\(').replace(')', '\\)')}`;
-    }
-  });
-  const valRegex = new RegExp(regValStr, 'gi');
-  return rootOriginal => {
-    rootOriginal.walkRules(rule => {
-      // rule.nodes[-1] = {}
-      // need map, forEach fine less memory
-      rule.nodes.forEach((decl, position) => {
-        // case font-size
-        const commentStr = 'variable:ignore';
-        const prevNode = rule.nodes[position - 1];
-        const fromPath = rootOriginal.source.input.from;
-        // this will be problem for linux and mac use require('path').sep
-        // split not need use slice and lastIndexOf less memory
-        const filename = fromPath.split(path.sep).pop();
-        if (prevNode && prevNode.type === 'comment' && prevNode.text.toLowerCase().includes(commentStr)) {
-          const errStr = ` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${fromPath} ,\n line : ${decl.source.start.line} ,\n message : Declaration Ignored \r`;
-          errorFunction(errStr, 'DECLARATION_IGNORED');
-          return;
-        }
-        if (settingsObject[decl.prop] && !decl.value.includes('var(--')) {
-          const settings = settingsObject[decl.prop];
-          // console.log(settings)
-          const {
-            allowed,
-            range
-          } = settings;
-          // suggestion filter  !decl.value.includes('calc')
-          // Reason below some of logic happen based on this
-          const unit = decl.value.toString()
-          // no need round braket since you do not need group for less memory
-          .replace(/\d+/gi, '').replace('var(--zd_size)', 'px').replace('var(--zd_font_size)', 'px').split(' ').filter(x => x !== '');
-          // unit = unit.replace(unit, unit.replace('-',''))
-          // console.log('unit : ');
-          // console.log(unit);
-          unit.forEach((val, index) => {
-            allowed.forEach(alwdVal => {
-              if (val.includes(alwdVal)) {
-                // ## for what purpose
-                unit[index] = val.replace(`-${alwdVal}`, `${alwdVal}`).replace(`-.${alwdVal}`, `${alwdVal}`);
-              }
+    const valRegex = new RegExp(regValStr, 'gi');
+    return rootOriginal => {
+      rootOriginal.walkRules(rule => {
+        // rule.nodes[-1] = {}
+        // need map, forEach fine less memory
+        rule.nodes.forEach((decl, position) => {
+          // case font-size
+          const commentStr = 'variable:ignore';
+          const prevNode = rule.nodes[position - 1];
+          const fromPath = rootOriginal.source.input.from; // this will be problem for linux and mac use require('path').sep
+          // split not need use slice and lastIndexOf less memory
+
+          const filename = fromPath.split(path.sep).pop();
+
+          if (prevNode && prevNode.type === 'comment' && prevNode.text.toLowerCase().includes(commentStr)) {
+            let errObj = {
+              decl,
+              type: 'DECLARATION_IGNORED',
+              filename,
+              message: 'Declaration Ignored',
+              path: fromPath
+            };
+            errHandler.errorTable.push(errObj);
+            errHandler.DECLARATION_IGNORED(errObj);
+            return;
+          }
+
+          if (settingsObject[decl.prop] && !decl.value.includes('var(--')) {
+            const settings = settingsObject[decl.prop]; // console.log(settings)
+
+            const {
+              allowed,
+              range
+            } = settings; // suggestion filter  !decl.value.includes('calc')
+            // Reason below some of logic happen based on this
+
+            const unit = decl.value.toString() // no need round braket since you do not need group for less memory
+            .replace(/\d+/gi, '').replace('var(--zd_size)', 'px').replace('var(--zd_font_size)', 'px').replace('rect(', '').replace(')', '').replace('px,', 'px').replace(',', '').split(' ').filter(x => x !== ''); // unit = unit.replace(unit, unit.replace('-',''))
+            // console.log('unit : ');
+            // console.log(unit);
+
+            unit.forEach((val, index) => {
+              allowed.forEach(alwdVal => {
+                if (val.includes(alwdVal)) {
+                  // ## for what purpose
+                  unit[index] = val // .replace(new RegExp('(\\d+).(\\d+)(\\w+)', 'gi'), '$3')
+                  .replace(`-${alwdVal}`, `${alwdVal}`).replace(`-.${alwdVal}`, `${alwdVal}`).replace(`${alwdVal},`, `${alwdVal}`);
+                }
+              });
             });
-          });
-          let unitError = false;
-          let unitErrorVal = '';
-          unit.forEach(val => {
-            if (!val.includes('calc')) {
-              if (!allowed.includes(val.toString())) {
-                unitError = true;
-                unitErrorVal = val;
+            let unitError = false;
+            let unitErrorVal = '';
+            unit.forEach(val => {
+              if (!val.includes('calc') && decl.prop !== 'clip') {
+                if (!allowed.includes(val.toString())) {
+                  unitError = true;
+                  unitErrorVal = val;
+                }
               }
-            }
-          });
-          // console.log(allowed, replacements, range)
-          if (!unitError) {
-            // use variable decl.value.split(' ')
-            if (range) {
-              // console.log('multiple :', decl.value)
-              let newVal = '';
-              decl.value.split(' ').forEach(singleVal => {
-                newVal += `${singleConvertor(singleVal, settings.replacements.px, {
+            }); // console.log(allowed, replacements, range)
+
+            if (!unitError) {
+              // use variable decl.value.split(' ')
+              if (range) {
+                // console.log('multiple :', decl.value)
+                let newVal = '';
+                decl.value.split(' ').forEach(singleVal => {
+                  newVal += `${singleConvertor(singleVal, settings.replacements.px, {
+                    decl,
+                    filename,
+                    path: fromPath
+                  }, range)} `;
+                });
+                decl.value = newVal;
+              }
+            } else {
+              if (!decl.value.includes('calc')) {
+                // addError(` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${path} ,\n line : ${decl.source.start.line} ,\n unit : ${unitErrorVal} ,\n message : ${unitErrorVal} (Unit) Not Allowed \r`);
+                let errObj = {
                   decl,
                   filename,
+                  unitErrorVal: unitErrorVal,
                   path: fromPath
-                }, range)} `;
-              });
-              decl.value = newVal;
+                };
+
+                if (unitErrorVal.trim() === '.') {
+                  errObj.type = 'DECIMAL_CHECK';
+                  errObj.message = `${unitErrorVal} (Decimal Value) Please check`;
+                  errHandler.errorTable.push(errObj);
+                  errHandler.DECIMAL_CHECK(errObj);
+                } else if (unitErrorVal.includes('.') && !unitErrorVal.includes('%')) {
+                  errObj.type = 'DECIMAL_REJECT';
+                  errObj.message = `${unitErrorVal} (Decimal Value) Not Allowed \r`;
+                  errHandler.errorTable.push(errObj);
+                  errHandler.DECIMAL_REJECT(errObj);
+                } else {
+                  if (!unitErrorVal.includes('%')) {
+                    errObj.type = 'UNIT_ERROR';
+                    errObj.message = `${unitErrorVal} (Unit) Not Allowed`;
+                    errHandler.errorTable.push(errObj);
+                    errHandler.UNIT_ERROR(errObj);
+                  }
+                }
+              } else {
+                decl.value = pxToCalc(decl.value);
+              }
             }
           } else {
-            if (!decl.value.includes('calc')) {
-              // addError(` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${path} ,\n line : ${decl.source.start.line} ,\n unit : ${unitErrorVal} ,\n message : ${unitErrorVal} (Unit) Not Allowed \r`);
-              errorFunction(` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${fromPath} ,\n line : ${decl.source.start.line} ,\n unit : ${unitErrorVal} ,\n message : ${unitErrorVal} (Unit) Not Allowed \r`, 'UNIT_ERROR');
-            } else {
-              decl.value = pxToCalc(decl.value);
+            if (decl.prop && decl.value && !decl.prop.includes('--') && valRegex.test(decl.value) && (settingsObject[decl.prop] || convertableProps[decl.prop]) && decl.value.includes('var') && !decl.value.includes('calc')) {
+              let errObj = {
+                decl,
+                type: 'VARIABLE_PRESENT',
+                filename,
+                message: `value (${decl.value}) has var in it, kindly check`,
+                path: fromPath
+              };
+              errHandler.errorTable.push(errObj);
+              errHandler.VARIABLE_PRESENT(errObj);
             }
           }
-        } else {
-          if (decl.prop && decl.value && !decl.prop.includes('--') && valRegex.test(decl.value) && (settingsObject[decl.prop] || convertableProps[decl.prop]) && decl.value.includes('var') && !decl.value.includes('calc')) {
-            errorFunction(` prop: ${decl.prop} ,\n value : ${decl.value} ,\n filename : ${filename} ,\n filepath : ${fromPath} ,\n line : ${decl.source.start.line} ,\n message : value (${decl.value}) has var in it, kindly check`, 'VARIABLE_PRESENT');
-          }
-        }
-      });
-    });
-    // console.log(filename)
-    // console.log('Done!')
-    // console.log('----------------------------------------------------------------------------------------------------------------------')
-    if (errorLogStatus) {
-      fs.writeFileSync('./css_error.log', '');
-      if (errors.length > 0) {
-        errors.forEach(err => {
-          fs.appendFileSync('./css_error.log', err);
         });
-        // console.log('----------------------------------------------------------------------------------------------------------------------')
-      }
-    }
-
-    if (errorConsoleStatus) {
-      if (errors.length > 0) {
-        errors.forEach(err => {
-          // fs.appendFileSync('./css_error.log', err);
-          console.log(err);
-        });
-        console.log('----------------------------------------------------------------------------------------------------------------------');
-      }
-    }
-  };
-});
+      });
+    };
+  }),
+  errors: errHandler.errors,
+  errTable: errHandler.errorTable
+};

package/lib/postcss-plugins/variableModifier.js

@@ -1,15 +1,21 @@
 "use strict";
 
 const postcss = require('postcss');
+
 const path = require('path');
+
 const fs = require('fs');
+
 function populateArray(start, end) {
   let temp = [];
+
   for (var i = start; i < end; i++) {
     temp.push(i);
   }
+
   return temp;
 }
+
 let allwdVars = {
   'font-size': ['px', 'em']
 };
@@ -78,9 +84,11 @@ let numberObject = {
     }
   }
 };
+
 function hasIgnoreComment(node) {
   return node ? node.type == 'comment' ? node.text == 'Variable:Ignore' ? true : false : false : false;
 }
+
 let errors = [];
 module.exports = postcss.plugin('postcss-variable-report', () => rootOriginal => {
   // console.log('inside postcss plugin')
@@ -99,20 +107,21 @@ module.exports = postcss.plugin('postcss-variable-report', () => rootOriginal =>
           let path = rootOriginal.source.input.from;
           let filename = path.split('\\');
           filename = filename[filename.length - 1];
+
           if (decl.prop === 'font-size' || decl.prop === 'margin-left' || decl.prop === 'margin-right' || decl.prop === 'margin-top' || decl.prop === 'margin-bottom') {
             let {
               allowed,
               replacements,
               available
             } = settings;
+
             if (!rootOriginal.source.input.from.includes('node_modules')) {
               if (unit != 0) {
                 if (allowed.includes(unit)) {
                   // console.log(available, parseInt(decl.value))
                   if (available.includes(parseInt(decl.value))) {
                     // replacementValues[unit].push({[decl.value] : replacements[unit].replace('$$', parseInt(decl.value))})
-                    decl.value = replacements[unit].replace('$$', parseInt(decl.value));
-                    //console.log("replacements:")
+                    decl.value = replacements[unit].replace('$$', parseInt(decl.value)); //console.log("replacements:")
                   } else {
                     let err = {
                       prop: decl.prop,
@@ -144,16 +153,17 @@ module.exports = postcss.plugin('postcss-variable-report', () => rootOriginal =>
               allowed,
               replacements,
               available
-            } = settings;
-            //console.log(decl.prop + "  " + decl.value)
-            let valArr = decl.value.split(' ');
-            //console.log(valArr)
+            } = settings; //console.log(decl.prop + "  " + decl.value)
+
+            let valArr = decl.value.split(' '); //console.log(valArr)
             //console.log(allowed, replacements, available)
+
             let hasError = false;
             let newVal = '';
             valArr.forEach(val => {
               let unit = val.replace(parseInt(val), '');
               let numVal = parseInt(val);
+
               if (unit != 0) {
                 if (allowed.includes(unit)) {
                   if (available.includes(numVal)) {
@@ -194,31 +204,29 @@ module.exports = postcss.plugin('postcss-variable-report', () => rootOriginal =>
                 }
               }
             });
+
             if (!hasError) {
               decl.value = newVal;
             }
           }
         }
       });
-    });
-    //fs.writeFile('./src/trial.json', JSON.stringify(variables) ,(err) =>{
+    }); //fs.writeFile('./src/trial.json', JSON.stringify(variables) ,(err) =>{
     //    if(err)console.log(err);
     //    else{
     //        console.log('updated successfully');
     //    }
     // })
     // console.log(errors)
+
     let errorArr = [];
     errors.forEach(errStr => {
       errorArr.push(` prop: ${errStr.prop} ,\n value : ${errStr.value} ,\n filename : ${errStr.filename} ,\n filepath : ${errStr.filepath} ,\n line : ${errStr.line} ,\n unit : ${errStr.unit} ,\n message : ${errStr.message} \r`);
-    });
-
-    //fs.writeFile('./css_error.log','', (err) =>{
+    }); //fs.writeFile('./css_error.log','', (err) =>{
     //    if(err){
     //        console.log(err);
     //    }
     //});
-
     // errorArr.forEach(err => {
     //   let data = `\n{\n${err}\n},\n`;
     //   //fs.appendFile('./css_error.log',data,(err)=>{
@@ -228,7 +236,6 @@ module.exports = postcss.plugin('postcss-variable-report', () => rootOriginal =>
     //   //})
     // });
     // fs.writeFileSync('./css_error.log','');
-
     //  errorArr.forEach(err => {
     //    let data = `\n{\n${err}\n},\n`;
     //    fs.appendFileSync('./css_error.log',data);

package/lib/schemas/index.js

@@ -4,10 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var _os = require("os");
+
 var _getIp = _interopRequireDefault(require("../utils/getIp"));
+
 var _getCurrentBranch = _interopRequireDefault(require("../utils/getCurrentBranch"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 // TODO move deprecated options to separate file and manage seperately
 var _default = {
   cliRootPath: null,
@@ -212,15 +217,22 @@ var _default = {
       hasRTL: false,
       hoverActive: false,
       combinerMediaQuery: false,
-      cssVariableReplacement: false
+      cssVariableReplacement: false,
+      selectorWeight: false
     },
     exclude: {
       rtl: [],
       hoverActive: [],
       combinerMediaQuery: [],
-      cssVariableReplacement: []
+      cssVariableReplacement: [],
+      selectorWeight: []
     },
     cssVariableReplacementConfig: '',
+    selectorWeightConfig: {
+      defaultSelector: '',
+      customFileDetails: '',
+      excludeStrings: []
+    },
     seperateCssModules: {
       value: false,
       cli: 'sep_cssmodules'
@@ -302,15 +314,22 @@ var _default = {
       hasRTL: false,
       hoverActive: false,
       combinerMediaQuery: false,
-      cssVariableReplacement: false
+      cssVariableReplacement: false,
+      selectorWeight: false
     },
     exclude: {
       rtl: [],
       hoverActive: [],
       combinerMediaQuery: [],
-      cssVariableReplacement: []
+      cssVariableReplacement: [],
+      selectorWeight: []
     },
     cssVariableReplacementConfig: '',
+    selectorWeightConfig: {
+      defaultSelector: '',
+      customFileDetails: '',
+      excludeStrings: []
+    },
     cssHashSelectors: {
       filenames: [],
       packages: []

package/lib/servers/clusterHubServer.js

@@ -1,10 +1,15 @@
 "use strict";
 
 var _path = _interopRequireDefault(require("path"));
+
 var _fs = _interopRequireDefault(require("fs"));
+
 var _express = _interopRequireDefault(require("express"));
+
 var _utils = require("../utils");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 let options = (0, _utils.getOptions)();
 let {
   cluster: {
@@ -13,13 +18,17 @@ let {
 } = options;
 let app = (0, _express.default)();
 let appPath = process.cwd();
+
 let clusterConfigPath = _path.default.join(appPath, 'clusterConfig.js');
+
 let config;
+
 if (_fs.default.existsSync(clusterConfigPath)) {
   config = require(clusterConfigPath);
 } else {
   throw new Error(`clusterConfig.js doen't exist under following path - ${clusterConfigPath}`);
 }
+
 app.get('/clusterhub/nodes', (req, res) => {
   res.send(JSON.stringify(config.cluster));
 });
@@ -28,5 +37,6 @@ app.listen(server.port, err => {
   if (err) {
     throw err;
   }
+
   (0, _utils.log)(`Listening at ${(0, _utils.getServerURL)(server, 'ht' + 'tp')}/clusterhub/`);
 });