@zohodesk/react-cli 0.0.1-exp.175.0 → 0.0.1-exp.176.1

package/lib/postcss-plugins/hoverActivePlugin.js

@@ -4,9 +4,9 @@ var _postcss = _interopRequireDefault(require("postcss"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/**
- * we have give support for ignore(exclude) comments
- * These are the comments' keyword
+/**
+ * we have give support for ignore(exclude) comments
+ * These are the comments' keyword
  */
 const hoverIgnoreQuery = 'Hover:ignore',
       activeIgnoreQuery = 'Active:ignore',

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

@@ -8,30 +8,53 @@ exports.ErrorHandler = void 0;
 class ErrorHandler {
   constructor(allowedErrs) {
     this.errors = [];
+    this.errorTable = [];
     this.allowedErrs = allowedErrs;
+    Object.assign(this, {
+      DECLARATION_IGNORED: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : Declaration Ignored`),
+      DECIMAL_CHECK: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n unit : ${errObj.unitErrorVal} ,\n message : ${errObj.message}`),
+      DECIMAL_REJECT: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n unit : ${errObj.unitErrorVal} ,\n message : ${errObj.message}`),
+      UNIT_ERROR: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n unit : ${errObj.unitErrorVal} ,\n message : ${errObj.message}`),
+      RANGE_ERROR: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : ${errObj.message}\r`),
+      VARIABLE_PRESENT: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : ${errObj.message}`),
+      MULTIPLE_OCCURANCES: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : ${errObj.message}`)
+    });
+  }
+
+  setAllowedErrs(allErrs) {
+    this.allowedErrs = allErrs;
+    ['DECLARATION_IGNORED', 'DECIMAL_CHECK', 'DECIMAL_REJECT', 'UNIT_ERROR', 'RANGE_ERROR', 'VARIABLE_PRESENT', 'MULTIPLE_OCCURANCES'].forEach(err => {
+      if (!this.allowedErrs[err]) {
+        this[err] = () => null;
+      }
+    });
   }
 
   addError(errstr) {
     this.errors.push(`{\n${errstr}\n}\n`);
   }
 
-  errorFunction(errStr, type) {
-    const {
-      addError,
-      allowedErrs
-    } = this;
-
-    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);
+  errorFunction(errObj) {
+    if (errObj.type && this.allowedErrs[errObj.type] && errObj.decl.prop && errObj.decl.value) {
+      console.log(this.allowedErrs[errObj.type]);
+      this[errObj.type](errObj);
     }
   }
 
+  printError(errObj) {
+    console.log('{');
+    Object.keys(errObj).sort().forEach(key => {
+      if (key !== 'decl') {
+        console.log(`${key} : ${errObj[key]}`);
+      } else {
+        console.log(`prop : ${errObj.decl.prop}`);
+        console.log(`value : ${errObj.decl.value}`);
+        console.log(`linenum : ${errObj.decl.source.start.line}`);
+      }
+    });
+    console.log('}\n');
+  }
+
 }
 
 exports.ErrorHandler = ErrorHandler;

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

@@ -6,8 +6,13 @@ 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,
@@ -29,19 +34,37 @@ 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'));
+  }
+
+  if (value.includes('rect')) {
+    return parseInt(value.replace('rect(', '').replace(')', '').replace(',', ''));
   } // Not need for this dum loop
   // allowed.forEach(alwdUnit => {
   //   if (value.includes(alwdUnit)) {
@@ -71,22 +94,6 @@ 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,
@@ -94,6 +101,13 @@ const singleConvertor = (value, changeVal, details, range) => {
     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'));
 
@@ -102,147 +116,192 @@ const singleConvertor = (value, changeVal, details, range) => {
     }
 
     return retVal;
-  } // if(unitErrorVal && unitErrorVal != '0' ){
+  } // 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);
-
-  fs.writeFileSync('./css_error.log', '');
-  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;
-        }
+    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
 
-        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 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,
+  errHandler
+};

package/lib/schemas/index.js

@@ -91,10 +91,6 @@ var _default = {
     cssDirStatement: null
   },
   app: {
-    moduleResolvePath: {
-      value: '',
-      cli: 'module_resolve_path'
-    },
     // this option only for impact testing
     devCssFileBountry: {
       value: '',
@@ -141,10 +137,6 @@ var _default = {
         value: 'dev',
         cli: 'app_mode'
       },
-      httpsCerts: {
-        value: '',
-        cli: 'https_certs'
-      },
       branch: {
         value: 'master',
         cli: 'app_branch'
@@ -225,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'
@@ -315,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/docsServerCore.js

@@ -29,29 +29,28 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 // import fs from 'fs';
 var _default = isSSTest => {
-  const options = (0, _utils.getOptions)();
-  const httpsOptions = (0, _httpsOptions.httpsOptionsWithUserFriendlyError)(options);
-  const {
+  let options = (0, _utils.getOptions)();
+  let {
     docs: {
       server
     }
   } = options;
-  const {
+  let {
     port,
     branch,
     host,
     domain,
     iphost
   } = server;
-  const appPath = process.cwd();
+  let appPath = process.cwd();
   const app = (0, _express.default)();
   app.use(_express.default.json());
   app.use(_express.default.urlencoded({
     extended: true
   }));
-  const docsConfig = (0, _webpackDocs.default)(isSSTest);
-  const compiler = (0, _webpack.default)(docsConfig);
-  const wdm = (0, _webpackDevMiddleware.default)(compiler, {
+  let docsConfig = (0, _webpackDocs.default)(isSSTest);
+  let compiler = (0, _webpack.default)(docsConfig);
+  let wdm = (0, _webpackDevMiddleware.default)(compiler, {
     logLevel: 'error',
     publicPath: docsConfig.output.publicPath,
     headers: {
@@ -68,7 +67,7 @@ var _default = isSSTest => {
     res.sendFile(_path.default.join(__dirname, '..', '..', 'templates', 'docs', 'index.html'));
   });
   app.use('/author/get', (req, res) => {
-    const {
+    let {
       query: {
         componentName = ''
       }
@@ -85,7 +84,7 @@ var _default = isSSTest => {
 
   if (branch) {
     app.post('/repo/merge', (req, res) => {
-      const {
+      let {
         ref
       } = req.body;
 
@@ -99,7 +98,7 @@ var _default = isSSTest => {
     });
   }
 
-  const httpsServer = _https.default.createServer(httpsOptions, app);
+  const httpsServer = _https.default.createServer(_httpsOptions.httpsOptions, app);
 
   if (!isSSTest) {
     httpsServer.listen(port, err => {
@@ -111,8 +110,8 @@ var _default = isSSTest => {
     });
   }
 
-  const httpPort = Number(port) + 1;
-  const http = app.listen(httpPort, err => {
+  let httpPort = Number(port) + 1;
+  let http = app.listen(httpPort, err => {
     if (err) {
       throw err;
     }