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

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startHttpsServer = startHttpsServer;
+
+var _https = _interopRequireDefault(require("https"));
+
+var _logger = require("../../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function startHttpsServer(app, options) {
+  const {
+    httpsOptions,
+    serverExtras
+  } = options;
+  const {
+    httpsPort,
+    httpsUrl
+  } = serverExtras;
+
+  if (!httpsOptions) {
+    return null;
+  }
+
+  const httpsServer = _https.default.createServer(httpsOptions, app);
+
+  httpsServer.listen(httpsPort, err => {
+    if (err) {
+      throw err;
+    }
+
+    (0, _logger.messageLogger)(`Listening at ${httpsUrl}`);
+  });
+  return httpsServer;
+}

package/packages/client_build_tool/lib/shared/server/unwanted/addHttp2Server.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addHttp2Server = addHttp2Server;
+
+var _utils = require("../../../src/utils");
+
+var _httpsOptions = require("../../../src/servers/httpsOptions");
+
+function addHttp2Server(http2Port, host, domain, contextURL) {
+  const isCompatableHttp2 = Number(process.version.slice(1).split('.')[0]) >= 8;
+
+  if (isCompatableHttp2) {
+    const http2 = require('http2');
+
+    const http2Server = http2.createSecureServer(_httpsOptions.httpsOptions); // eslint-disable-next-line no-unused-vars
+
+    http2Server.on('stream', (stream, headers) => {
+      stream.respond({
+        'content-type': 'text/html',
+        ':status': 200
+      });
+      stream.end('<h1>Hello World! <br>Working with http2</h1>');
+    });
+    http2Server.listen(http2Port, err => {
+      if (err) {
+        throw err;
+      }
+
+      (0, _utils.log)(`Listening at ${(0, _utils.getServerURL)({
+        host,
+        domain,
+        port: http2Port
+      }, 'htt' + 'ps')}${contextURL}/`, 'http2 server');
+    });
+  } else {
+    (0, _utils.log)('Your node version didn\'t adopted http2 support. Kindly update that to 8 LTS or above you can engage the http2');
+  }
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configWebpackDevMiddleware = configWebpackDevMiddleware;
+
+var _webpackDevMiddleware = _interopRequireDefault(require("webpack-dev-middleware"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configWebpackDevMiddleware({
+  publicPath,
+  writeToDisk,
+  enableDevCache,
+  disableWatch,
+  compress,
+  compiler
+}) {
+  let webpackServerOptions = {
+    logLevel: 'error',
+    publicPath,
+    headers: {
+      'Access-Control-Allow-Origin': '*'
+    },
+    compress
+  };
+
+  if (enableDevCache) {
+    webpackServerOptions.headers['Cache-Control'] = 'public, max-age=604800';
+  }
+
+  if (disableWatch) {
+    webpackServerOptions.watchOptions = {
+      ignored: /./
+    };
+  }
+
+  if (writeToDisk) {
+    webpackServerOptions.writeToDisk = true;
+  }
+
+  return (0, _webpackDevMiddleware.default)(compiler, webpackServerOptions);
+}

package/packages/client_build_tool/lib/shared/server/unwanted/mockApiSupport.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mockApiSupport = mockApiSupport;
+
+var _httpProxyMiddleware = require("http-proxy-middleware");
+
+function mockApiSupport(app, server) {
+  const {
+    mockPrefix,
+    mockPort
+  } = server;
+  app.use(mockPrefix, (0, _httpProxyMiddleware.createProxyMiddleware)({
+    target: 'ht' + `tp://localhost:${mockPort}`,
+    changeOrigin: true
+  }));
+}

package/packages/client_build_tool/lib/shared/server/unwanted/websocketMockSetup.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.websocketMockSetup = websocketMockSetup;
+
+var _ws = _interopRequireDefault(require("ws"));
+
+var _logger = require("../../../logger");
+
+var _constants = require("../../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function websocketMockSetup(app, httpsServer) {
+  app.use('/wms/*', (req, res) => {
+    res.sendFile((0, _constants.getTemplatePath)('wms', 'index.html'));
+  });
+  const wss = new _ws.default.Server({
+    server: httpsServer
+  });
+  let wsPool = [];
+  wss.on('connection', ws => {
+    wsPool.push(ws);
+    ws.on('close', () => {
+      wsPool = wsPool.filter(ws1 => ws1 !== ws);
+    });
+    ws.on('message', message => {
+      (0, _logger.messageLogger)('received: %s', message);
+    });
+    ws.send('something');
+  });
+  app.post('/wmsmockapi', (req, res) => {
+    wsPool.forEach(ws => {
+      const {
+        body
+      } = req;
+
+      try {
+        ws.send(JSON.stringify(body));
+      } catch (e) {
+        (0, _logger.messageLogger)(e, body);
+      }
+    });
+    res.send('success');
+  });
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.urlConcat = urlConcat;
+
+/* eslint-disable no-use-before-define */
+
+/**
+ *
+ * @param {String} url
+ * @param {String} path
+ */
+function urlConcat(url, path) {
+  const slashRemovedUrl = removeLastSlash(url);
+  const slashRemovedPath = removeFrontSlash(path);
+
+  if (slashRemovedUrl === '') {
+    return path;
+  }
+
+  return `${slashRemovedUrl}/${slashRemovedPath}`;
+}
+
+function removeLastSlash(url) {
+  return url.replace(/\/+$/, '');
+}
+
+function removeFrontSlash(url) {
+  return url.replace(/^\/+/, '');
+}

package/packages/client_build_tool/lib/shared/utils/requireLocalOrGlobal.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.globalNodeModules = void 0;
+exports.requireAllPossible = requireAllPossible;
+exports.requireGlobal = requireGlobal;
+exports.requireInFolder = requireInFolder;
+exports.requireLocal = requireLocal;
+exports.requireLocalOrGlobal = requireLocalOrGlobal;
+
+var _child_process = require("child_process");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _constants = require("../constants");
+
+var _logger = require("../../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const globalNodeModules = _path.default.join(`${(0, _child_process.execSync)('npm config get prefix')}`.trim(), 'lib');
+
+exports.globalNodeModules = globalNodeModules;
+
+function requireLocalOrGlobal(moduleName, opts = {}) {
+  let {
+    global = true
+  } = opts;
+  const {
+    local = true
+  } = opts;
+  const isRelativePath = moduleName[0] === '.'; // NOTE: if starts with . then it only mean local
+
+  if (isRelativePath) {
+    global = false;
+  }
+
+  const paths = [local && _constants.appPath, global && globalNodeModules].filter(Boolean); // eslint-disable-next-line no-use-before-define
+
+  return requireInFolder(moduleName, paths);
+}
+
+function requireInFolder(moduleName, paths) {
+  try {
+    const moduleResolvePath = require.resolve(moduleName, {
+      paths
+    }); // eslint-disable-next-line import/no-dynamic-require, global-require
+
+
+    return require(moduleResolvePath);
+  } catch (error) {
+    // NOTE: since we return null we can check out side
+    (0, _logger.verboseLogger)('Re validate: ', error);
+    return null;
+  }
+}
+
+function requireLocal(moduleName) {
+  return requireInFolder(moduleName, [_constants.appPath]);
+}
+
+function requireGlobal(moduleName) {
+  const isRelativePath = moduleName[0] === '.'; // NOTE: if starts with . then it only mean local
+
+  if (isRelativePath) {
+    return null;
+  }
+
+  return requireInFolder(moduleName, [globalNodeModules]);
+}
+
+function requireAllPossible(moduleName) {
+  const localP = requireLocal(moduleName);
+  const globalP = localP ? null : requireGlobal(moduleName);
+  return {
+    local: localP,
+    global: globalP
+  };
+}

package/packages/client_build_tool/lib/shared/utils/utils.js

@@ -0,0 +1 @@
+"use strict";

package/packages/client_build_tool/lib/shared/utils/versionPrint.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.versionPrint = versionPrint;
+
+var _child_process = require("child_process");
+
+var _logger = require("../../logger");
+
+var _package = _interopRequireDefault(require("../../../package.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function versionPrint(logger = _logger.messageLogger) {
+  logger(`Client Build Tool Version : ${_package.default.version}`);
+  logger(`Node Js Version : ${process.version}`);
+  logger(`Npm Version : ${(0, _child_process.execSync)('npm --version')}`);
+}