@zohodesk/react-cli 1.1.27 → 1.1.28-exp.1

package/packages/client_build_tool/lib/shared/postcss/custom_postcss_plugins/VariableModificationPlugin/index.js

@@ -0,0 +1,347 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _ErrorHandler = require("../../../bundler/webpack/custom_plugins/VariableConversionCollector/ErrorHandler");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const convertableProps = {
+  'font-size': true,
+  margin: true,
+  'margin-left': true,
+  'margin-right': true,
+  'margin-top': true,
+  'margin-bottom': true,
+  padding: true,
+  'padding-top': true,
+  'padding-bottom': true,
+  'padding-left': true,
+  'padding-right': true,
+  width: true,
+  'min-width': true,
+  'max-width': true,
+  height: true,
+  'min-height': true,
+  'max-height': true,
+  top: true,
+  bottom: true,
+  left: 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,
+  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)) {
+  //     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))');
+      }
+    });
+  });
+  return arr.join(' ');
+}
+
+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 (value == '0px') {
+    value = value.replace('px', '');
+  }
+
+  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')
+
+
+  const errObj = {
+    decl,
+    type: 'RANGE_ERROR',
+    filename,
+    message: `value (${value}) (${typeof value}) not within range (${range.start},${range.end})\r`,
+    path
+  };
+
+  _ErrorHandler.errHandler.errorTable.push(errObj);
+
+  _ErrorHandler.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;
+  // } else {
+  //   console.log('++++++++++++++++++++++rect val!', value);
+  // }
+
+};
+
+var _default = ({
+  configFile
+}) => {
+  const rawdata = _fs.default.readFileSync(configFile);
+
+  const data = JSON.parse(rawdata);
+  const {
+    errorsAllowed,
+    settings: settingsObject // errorLog: errorLogStatus,
+    // errorInConsole: errorConsoleStatus
+
+  } = data; // const keys = Object.keys(settingsObject);
+
+  _ErrorHandler.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(')', '\\)')}`;
+    }
+  });
+  const valRegex = new RegExp(regValStr, 'gi');
+  return {
+    postcssPlugin: 'postcss-variable-report',
+    Once: 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.default.sep).pop(); // if(filename.includes('AddFormResponsive.module.css'){
+          // }
+
+          if (prevNode && prevNode.type === 'comment' && prevNode.text.toLowerCase().includes(commentStr)) {
+            const errObj = {
+              decl,
+              type: 'DECLARATION_IGNORED',
+              filename,
+              message: 'Declaration Ignored',
+              path: fromPath
+            };
+
+            _ErrorHandler.errHandler.errorTable.push(errObj);
+
+            _ErrorHandler.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') && 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, {
+                    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`);
+              const errObj = {
+                decl,
+                filename,
+                unitErrorVal,
+                path: fromPath
+              };
+
+              if (unitErrorVal.trim() === '.') {
+                errObj.type = 'DECIMAL_CHECK';
+                errObj.message = `${unitErrorVal} (Decimal Value) Please check`;
+
+                _ErrorHandler.errHandler.errorTable.push(errObj);
+
+                _ErrorHandler.errHandler.DECIMAL_CHECK(errObj);
+              } else if (unitErrorVal.includes('.') && !unitErrorVal.includes('%')) {
+                errObj.type = 'DECIMAL_REJECT';
+                errObj.message = `${unitErrorVal} (Decimal Value) Not Allowed \r`;
+
+                _ErrorHandler.errHandler.errorTable.push(errObj);
+
+                _ErrorHandler.errHandler.DECIMAL_REJECT(errObj);
+              } else if (!unitErrorVal.includes('%')) {
+                errObj.type = 'UNIT_ERROR';
+                errObj.message = `${unitErrorVal} (Unit) Not Allowed`;
+
+                _ErrorHandler.errHandler.errorTable.push(errObj);
+
+                _ErrorHandler.errHandler.UNIT_ERROR(errObj);
+              }
+            } else {
+              decl.value = pxToCalc(decl.value);
+            }
+          } else {
+            if (settingsObject[decl.prop] && decl.value && decl.value.includes('px') && decl.value.includes('var(--')) {
+              const valArr = decl.value.split(' ');
+              const settings = settingsObject[decl.prop];
+              const {
+                range
+              } = settings;
+              const convertedVals = valArr.map(val => {
+                if (val.includes('px')) {
+                  const convertedVal = singleConvertor(val, settings.replacements.px, {
+                    decl,
+                    filename,
+                    path: fromPath
+                  }, range);
+                  return convertedVal || val;
+                }
+
+                return val;
+              });
+              decl.value = convertedVals.join(' ');
+            }
+
+            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')) {
+              const errObj = {
+                decl,
+                type: 'VARIABLE_PRESENT',
+                filename,
+                message: `value (${decl.value}) has var in it, kindly check`,
+                path: fromPath
+              };
+
+              _ErrorHandler.errHandler.errorTable.push(errObj);
+
+              _ErrorHandler.errHandler.VARIABLE_PRESENT(errObj);
+            }
+          }
+        });
+      });
+    }
+  };
+};
+
+exports.default = _default;

package/packages/client_build_tool/lib/shared/postcss/filterPluginsAllowedForSpecficFile.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterCustomPluginsAllowedForSpecificFile = filterCustomPluginsAllowedForSpecificFile;
+exports.filterPluginsAllowedForSpecificFile = filterPluginsAllowedForSpecificFile;
+exports.getEnabledPlugins = getEnabledPlugins;
+exports.mapDefaultSupportedPlugins = mapDefaultSupportedPlugins;
+
+var _checkIsPatternsMatchFilename = require("../bundler/webpack/loaderConfigs/checkIsPatternsMatchFilename");
+
+var _getSpecificPostCssPlugin = require("./getSpecificPostCssPlugin");
+
+/* eslint-disable no-use-before-define */
+function mapDefaultSupportedPlugins(pluginsOptions) {
+  return _getSpecificPostCssPlugin.supportedPluginsOptionNames.map(pluginName => ({ ...pluginsOptions[pluginName],
+    pluginName
+  }));
+}
+
+function getEnabledPlugins(pluginsOptions) {
+  function isEnabled(pluginName) {
+    return pluginsOptions[pluginName].enable;
+  }
+
+  return _getSpecificPostCssPlugin.supportedPluginsOptionNames.filter(isEnabled).map(pluginName => ({ ...pluginsOptions[pluginName],
+    pluginName
+  }));
+}
+
+function filterPluginsAllowedForSpecificFile(plugins, filename) {
+  return plugins.filter(pluginOption => checkIsPluginAllowed(pluginOption, filename)).map(pluginOption => (0, _getSpecificPostCssPlugin.getSpecificPostCssPlugin)(pluginOption)).filter(Boolean);
+}
+
+function checkIsPluginAllowed(pluginOption, filename) {
+  return (0, _checkIsPatternsMatchFilename.checkIsPatternsMatchFilename)(pluginOption.patterns, filename);
+}
+
+function getCustomPlugins(pluginOption) {
+  if (typeof pluginOption.plugin === 'string') {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(pluginOption.plugin).plugin(pluginOption);
+  }
+
+  if (typeof pluginOption.plugin === 'function') {
+    return pluginOption.plugin(pluginOption);
+  }
+
+  return null;
+}
+
+function filterCustomPluginsAllowedForSpecificFile(customPlugins, filename) {
+  return customPlugins.filter(pluginOption => checkIsPluginAllowed(pluginOption, filename)).map(getCustomPlugins).filter(Boolean);
+}

package/packages/client_build_tool/lib/shared/postcss/getAllowedPostCssPlugins.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllowedPostCssPlugins = getAllowedPostCssPlugins;
+exports.postcssPluginGetter = postcssPluginGetter;
+
+var _filterPluginsAllowedForSpecficFile = require("./filterPluginsAllowedForSpecficFile");
+
+function getAllowedPostCssPlugins(filename, enabledPlugins, enabledCustomPlugins) {
+  const neededPostCssPlugins = (0, _filterPluginsAllowedForSpecficFile.filterPluginsAllowedForSpecificFile)(enabledPlugins, filename);
+  const neededCustomPlugins = (0, _filterPluginsAllowedForSpecficFile.filterCustomPluginsAllowedForSpecificFile)(enabledCustomPlugins, filename);
+  return {
+    plugins: [...neededPostCssPlugins, ...neededCustomPlugins]
+  };
+}
+
+function postcssPluginGetter(options) {
+  const pluginsOptions = options.css.plugins;
+  const {
+    customPlugins = []
+  } = options.css;
+  const enabledPlugins = (0, _filterPluginsAllowedForSpecficFile.getEnabledPlugins)(pluginsOptions);
+  const enabledCustomPlugins = customPlugins.filter(conf => conf.enable);
+  return filename => {
+    const allowedPostCssPlugins = getAllowedPostCssPlugins(filename, enabledPlugins, enabledCustomPlugins);
+    return allowedPostCssPlugins;
+  };
+}

package/packages/client_build_tool/lib/shared/postcss/getSpecificPostCssPlugin.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configPostCssRtl = configPostCssRtl;
+exports.getSpecificPostCssPlugin = getSpecificPostCssPlugin;
+exports.supportedPluginsOptionNames = void 0;
+
+var _fs = require("fs");
+
+var _postcssRtl = _interopRequireDefault(require("postcss-rtl"));
+
+var _SelectorReplace = _interopRequireDefault(require("./custom_postcss_plugins/SelectorReplace"));
+
+var _ValueReplacer = _interopRequireDefault(require("./custom_postcss_plugins/ValueReplacer"));
+
+var _HoverActivePlugin = _interopRequireDefault(require("./custom_postcss_plugins/HoverActivePlugin"));
+
+var _VariableModificationPlugin = _interopRequireDefault(require("./custom_postcss_plugins/VariableModificationPlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-use-before-define */
+function getSpecificPostCssPlugin(pluginOption) {
+  return postcssPluginMapper[pluginOption.pluginName]?.(pluginOption);
+} // eslint-disable-next-line no-unused-vars
+
+
+function configPostCssRtl(pluginOption) {
+  return (0, _postcssRtl.default)({
+    addPrefixToSelector: function addPrefixToSelector(selector, prefix) {
+      if (prefix === '[dir]') {
+        return selector;
+      }
+
+      return `${prefix} ${selector}`; // Make selectors like [dir=rtl] > .selector
+    }
+  });
+} // NOTE: we have keeping array because we need to maintain order (Just In Cases For Future)
+
+
+const supportedPluginsOptionNames = ['rtl', 'valueReplacer', 'selectorReplace', 'hoverActive', 'cssVariableReplacement'];
+exports.supportedPluginsOptionNames = supportedPluginsOptionNames;
+const postcssPluginMapper = {
+  rtl: configPostCssRtl,
+  selectorReplace: pluginOption => (0, _SelectorReplace.default)(pluginOption),
+  valueReplacer: pluginOption => (0, _ValueReplacer.default)(pluginOption.config),
+  hoverActive: pluginOption => (0, _HoverActivePlugin.default)(pluginOption),
+  cssVariableReplacement: configCssVariableReplacement
+};
+
+function configCssVariableReplacement(pluginOption) {
+  const {
+    configFile
+  } = pluginOption;
+  return configFile && (0, _fs.existsSync)(configFile) && (0, _VariableModificationPlugin.default)(pluginOption);
+}

package/packages/client_build_tool/lib/shared/postcss/runPostCssForCssFile.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runPostCssForCssFile = runPostCssForCssFile;
+
+var _postcss = _interopRequireDefault(require("postcss"));
+
+var _fs = require("fs");
+
+var _getAllowedPostCssPlugins = require("./getAllowedPostCssPlugins");
+
+var _copyFile = require("../fileUtils/copyFile");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function runPostCssForCssFile({
+  filename,
+  outputFile,
+  options
+}) {
+  const getAllowedPostCssPlugins = (0, _getAllowedPostCssPlugins.postcssPluginGetter)(options);
+  const allowedPostCssPlugins = getAllowedPostCssPlugins(filename);
+
+  if (allowedPostCssPlugins.length === 0) {
+    return;
+  }
+
+  const css = (0, _fs.readFileSync)(filename).toString();
+  (0, _postcss.default)(allowedPostCssPlugins).process(css, {
+    from: filename,
+    to: outputFile
+  }).then(result => {
+    (0, _copyFile.writeFile)(outputFile, result.css);
+  });
+}

package/packages/client_build_tool/lib/shared/pre_process/runPreProcess.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runPreProcess = runPreProcess;
+
+var _path = require("path");
+
+var _fs = require("fs");
+
+var _spawnSyncIO = require("../commands-utils/spawnSyncIO");
+
+var _logger = require("../../logger");
+
+var _constants = require("../constants");
+
+function runPreProcess(options, runnerCli = 'node') {
+  const {
+    preProcess
+  } = options;
+  const {
+    enable,
+    runner,
+    stopNodemon
+  } = preProcess;
+
+  if (!enable || !runner) {
+    return null;
+  }
+
+  const preprocessorPath = (0, _constants.joinWithAppPath)(runner);
+  let result = null;
+
+  if ((0, _fs.existsSync)(preprocessorPath)) {
+    const preprocessorDirPath = (0, _path.dirname)(preprocessorPath);
+    const watchOptions = ['--watch', preprocessorDirPath];
+    const preprocessCli = stopNodemon ? 'node' : runnerCli;
+
+    if (preprocessCli === 'node') {
+      result = (0, _spawnSyncIO.spawnSyncIO)(preprocessCli, [preprocessorPath], {
+        stdio: 'inherit',
+        cwd: preprocessorDirPath
+      });
+      (0, _logger.messageLogger)('pre_processor ran successfully');
+    } else {
+      result = (0, _spawnSyncIO.spawnIO)(preprocessCli, [preprocessorPath, ...watchOptions], {
+        stdio: 'inherit',
+        cwd: preprocessorDirPath
+      });
+    }
+  } else {
+    (0, _logger.errorLogger)(`preProcessor not exists ${preprocessorPath}`);
+    process.exit(0);
+  }
+
+  return result;
+}

package/packages/client_build_tool/lib/shared/server/configWebpackDevMiddleware.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configWebpackDevMiddleware = configWebpackDevMiddleware;
+exports.webpackDevMiddlewareConfig = webpackDevMiddlewareConfig;
+
+var _webpack = require("webpack");
+
+var _webpackDevMiddleware = _interopRequireDefault(require("webpack-dev-middleware"));
+
+var _statsConfig = require("../bundler/webpack/statsConfig");
+
+var _webpackConfig = _interopRequireDefault(require("../bundler/webpack/webpackConfig"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function webpackDevMiddlewareConfig(options) {
+  const {
+    publicPath
+  } = options;
+  return {
+    stats: (0, _statsConfig.statsConfig)(options),
+    index: 'index.html',
+    publicPath,
+    headers: {
+      'Access-Control-Allow-Origin': '*'
+    }
+  };
+}
+
+function configWebpackDevMiddleware(app, options) {
+  const config = (0, _webpackConfig.default)(options);
+  const compiler = (0, _webpack.webpack)(config);
+  const devMiddleware = (0, _webpackDevMiddleware.default)(compiler, webpackDevMiddlewareConfig(options));
+  app.use(devMiddleware);
+  return {
+    compiler
+  };
+}

package/packages/client_build_tool/lib/shared/server/corsHandling.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.corsHandling = corsHandling;
+
+// eslint-disable-next-line no-unused-vars
+function corsHandling(app, options) {
+  app.use((req, res, next) => {
+    // console.log('origin', req.get('origin'));
+    res.setHeader('Access-Control-Allow-Origin', req.get('origin') || '*'); // res.setHeader('Access-Control-Allow-Origin', req.get('origin'));
+
+    res.setHeader('Access-Control-Allow-Private-Network', true);
+    res.setHeader('Access-Control-Allow-Credentials', true);
+
+    if (req.get('Access-Control-Request-Headers')) {
+      res.setHeader('Access-Control-Allow-Headers', req.get('Access-Control-Request-Headers'));
+    }
+
+    if (req.get('Access-Control-Request-Method')) {
+      res.setHeader('Access-Control-Allow-Methods', req.get('Access-Control-Request-Method'));
+    }
+
+    next();
+  });
+  app.options('/*', (req, res) => {
+    res.send('Ok');
+  });
+}

package/packages/client_build_tool/lib/shared/server/getIp.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIp = getIp;
+
+var _os = _interopRequireDefault(require("os"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getIp() {
+  const ifaces = _os.default.networkInterfaces();
+
+  let ips = [];
+  Object.keys(ifaces).forEach(ifname => {
+    const a = ifaces[ifname].map(iface => {
+      if (iface.family !== 'IPv4' || iface.internal !== false) {
+        return null;
+      }
+
+      return iface.address;
+    }).filter(a => a);
+    ips = ips.concat(a);
+  });
+  ips.push('127.0.0.1');
+  return ips[0];
+}
+
+;