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

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];
+}
+
+;

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getServerDomain = getServerDomain;
+exports.getServerUrl = getServerUrl;
+
+function getServerDomain(serverInfo) {
+  const {
+    host,
+    domain,
+    k8s
+  } = serverInfo;
+
+  if (domain && !k8s) {
+    return `${host}.${domain}.zohocorpin.com`;
+  }
+
+  return host;
+}
+
+function getServerUrl({
+  domain,
+  k8s,
+  port,
+  protocol = 'http'
+}) {
+  const prefix = protocol ? `${protocol}:` : '';
+
+  if (k8s) {
+    return `${prefix}//${domain}`;
+  }
+
+  return `${prefix}//${domain}:${port}/`;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.httpsOptionsWithUserFriendlyError = httpsOptionsWithUserFriendlyError;
+
+var _logger = require("../../logger");
+
+var _requireLocalOrGlobal = require("../utils/requireLocalOrGlobal");
+
+const defaultCertNpm = '@zohodesk-private/client_dev_cert';
+
+function httpsOptionsWithUserFriendlyError(options) {
+  const {
+    httpsCerts
+  } = options.server;
+
+  if (typeof httpsCerts === 'string' && httpsCerts) {
+    const certificate = (0, _requireLocalOrGlobal.requireAllPossible)(httpsCerts);
+
+    if (certificate.local) {
+      (0, _logger.verboseLogger)(`Local '${httpsCerts}' package taken as HTTPS certificate`);
+      return certificate.local.httpsOptions;
+    }
+
+    if (certificate.global) {
+      (0, _logger.messageLogger)(`Global '${httpsCerts}' package taken as HTTPS certificate`);
+      return certificate.global.httpsOptions;
+    }
+
+    (0, _logger.errorLogger)(`
+        You have given 'server.httpsCerts' as "${httpsCerts}".
+        But it seems that file path have some problem;`);
+    process.exit(0);
+  }
+
+  const globalCertificate = (0, _requireLocalOrGlobal.requireGlobal)(defaultCertNpm);
+
+  if (globalCertificate) {
+    (0, _logger.messageLogger)(`Global '${defaultCertNpm}' package taken as HTTPS certificate`);
+    return globalCertificate.httpsOptions;
+  }
+
+  return null;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initExpressApp = initExpressApp;
+
+var _express = _interopRequireDefault(require("express"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function initExpressApp() {
+  const app = (0, _express.default)();
+  app.use(_express.default.json());
+  app.use(_express.default.urlencoded({
+    extended: true
+  }));
+  return app;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialHTMLHandling = initialHTMLHandling;
+
+var _logger = require("../../logger");
+
+/* eslint-disable no-use-before-define */
+function initialHTMLHandling(compiler, app, options) {
+  const {
+    enableMockReplace
+  } = options;
+  const {
+    i18nChunkSplit
+  } = options;
+  const {
+    rtlSplit
+  } = options.css.plugins;
+  const {
+    httpsUrl,
+    httpUrl,
+    contextURL
+  } = options.serverExtras;
+  let initialHTML;
+  compiler.hooks.afterCompile.tap('ReactCLI', compilation => {
+    const indexHtml = compilation.assets['index.html']; // compiler.outputFileSystem.readFileSync("build/index.html");
+
+    if (indexHtml) {
+      initialHTML = indexHtml.source();
+    }
+  });
+  compiler.hooks.compile.tap('ReactCLI', () => {
+    (0, _logger.messageLogger)('Webpack re-building .......');
+  });
+  app.use(`${contextURL}/*`, (req, res) => {
+    const newHTML = modifyInitialHTML({
+      initialHTML,
+      options,
+      enableMockReplace,
+      req
+    });
+    res.send(newHTML);
+  });
+
+  function modifyInitialHTML({
+    initialHTML,
+    enableMockReplace,
+    req
+  }) {
+    let newHTML = enableMockReplace && initialHTML ? mockReplace(initialHTML, req.query) : initialHTML;
+
+    if (req.protocol === 'http') {
+      newHTML = newHTML.replaceAll(httpsUrl, httpUrl);
+    }
+
+    return newHTML;
+  }
+
+  function mockReplace(inputHTML, query) {
+    const {
+      dir,
+      locale
+    } = query || {};
+    let newHTML = inputHTML;
+
+    if (i18nChunkSplit.chunkSplitEnable) {
+      newHTML = replaceWithRandomLocale(newHTML, i18nChunkSplit.templateLabel, locale);
+    }
+
+    if (rtlSplit.enableRTLSplit) {
+      newHTML = replaceWithRandomDir(newHTML, rtlSplit.templateLabel, dir);
+    }
+
+    return newHTML;
+  }
+
+  function replaceWithRandomLocale(initialHTML, templateLabel, queryLocale) {
+    const locales = ['ar_EG', 'da_DK', 'de_DE', 'en_US', 'es_AR', 'es_ES', 'fr_FR', 'hi_IN', 'in_ID', 'it_IT', 'iw_IL', 'ja_JP', 'nl_NL', 'pl_PL', 'pt_BR', 'pt_PT', 'ro_RO', 'ru_RU', 'sv_SE', 'ta_IN', 'te_IN', 'tr_TR', 'zh_CN', 'zh_TW']; // app.use(`/desk/*`, (req, res) => {
+    // const locale = 'ta_IN';
+
+    const locale = queryLocale || locales[Math.floor(Math.random() * locales.length)];
+    (0, _logger.verboseLogger)({
+      locale
+    });
+    return initialHTML.replaceAll(templateLabel, locale);
+  }
+
+  function replaceWithRandomDir(initialHTML, templateLabel, queryDir) {
+    const dirs = ['ltr', 'rtl']; // const dir = 'rtl';
+
+    const dir = queryDir || dirs[Math.floor(Math.random() * dirs.length)];
+    (0, _logger.verboseLogger)({
+      dir
+    });
+    return initialHTML.replaceAll(templateLabel, dir);
+  }
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleMockApi = handleMockApi;
+exports.mockApiHandler = mockApiHandler;
+
+var _fs = require("fs");
+
+var _httpProxyMiddleware = require("http-proxy-middleware");
+
+var _constants = require("../constants");
+
+var _logger = require("../../logger");
+
+function mockApiHandler(app, options) {
+  const {
+    enable,
+    separateSeverPort,
+    mockEntryFile,
+    mockPrefix
+  } = options.mockServer;
+
+  if (!enable) {
+    return;
+  }
+
+  if (separateSeverPort) {
+    app.use(mockPrefix, (0, _httpProxyMiddleware.createProxyMiddleware)({
+      // eslint-disable-next-line no-useless-concat
+      target: 'ht' + `tp://localhost:${separateSeverPort}`,
+      changeOrigin: true
+    }));
+    (0, _logger.messageLogger)(`Please make sure you run mock Server separately in specified port (${separateSeverPort})`);
+    (0, _logger.messageLogger)(`If not running already you can run "cbt mock:server --mock_port=${separateSeverPort}"`);
+  } else {
+    // eslint-disable-next-line no-use-before-define
+    handleMockApi(mockEntryFile, app);
+  }
+}
+
+function handleMockApi(mockEntryFile, app) {
+  const entryFilePath = (0, _constants.joinWithAppPath)(mockEntryFile); // eslint-disable-next-line no-use-before-define
+
+  const mockFunc = safeRequire(entryFilePath);
+  mockFunc?.mockApi?.(app);
+} // function handleMockApi(params) {
+// }
+
+
+function safeRequire(entryFilePath) {
+  if (!(0, _fs.existsSync)(entryFilePath)) {
+    (0, _logger.errorLogger)(`${entryFilePath} file not exists for mockapi, Please check the file presence`);
+    return null;
+  } // eslint-disable-next-line import/no-dynamic-require, global-require
+
+
+  return require(entryFilePath);
+}

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+
+var _readOptions = require("../../schemas/readOptions");
+
+var _corsHandling = require("./corsHandling");
+
+var _getServerURL = require("./getServerURL");
+
+var _initExpressApp = require("./initExpressApp");
+
+var _mockApiHandler = require("./mockApiHandler");
+
+var _startHttpServer = require("./startHttpServer");
+
+function getMockServerExtras(options) {
+  const {
+    separateSeverPort
+  } = options.mockServer;
+  const httpPort = Number(separateSeverPort);
+  const httpUrl = (0, _getServerURL.getServerUrl)({
+    domain: 'localhost',
+    port: httpPort,
+    protocol: 'http'
+  });
+  return {
+    httpPort,
+    httpUrl,
+    isHttps: false
+  };
+}
+
+const options = (0, _readOptions.getOptions)();
+const {
+  mockEntryFile
+} = options.mockServer;
+options.serverExtras = getMockServerExtras(options);
+const app = (0, _initExpressApp.initExpressApp)();
+(0, _corsHandling.corsHandling)(app, options);
+(0, _startHttpServer.startHttpServer)(app, options);
+(0, _mockApiHandler.handleMockApi)(mockEntryFile, app);

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serveContextFiles = serveContextFiles;
+
+var _express = _interopRequireDefault(require("express"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function serveContextFiles(app, options) {
+  const {
+    context,
+    contextFolderPath
+  } = options;
+  const {
+    contextURL
+  } = options.serverExtras;
+  app.use(`${contextURL}/fonts`, _express.default.static(`${context}/fonts`));
+
+  if (contextURL) {
+    app.use(contextURL, _express.default.static(contextFolderPath));
+  } else {
+    app.use(_express.default.static(context));
+  }
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+
+var _corsHandling = require("./corsHandling");
+
+var _initExpressApp = require("./initExpressApp");
+
+var _configWebpackDevMiddleware = require("./configWebpackDevMiddleware");
+
+var _startHttpsServer = require("./startHttpsServer");
+
+var _initialHTMLHandling = require("./initialHTMLHandling");
+
+var _startHttpServer = require("./startHttpServer");
+
+var _mockApiHandler = require("./mockApiHandler");
+
+// import { serveContextFiles } from './serveContextFiles';
+// import { startHttpServer } from './startHttpServer';
+function run(options) {
+  const app = (0, _initExpressApp.initExpressApp)();
+  (0, _corsHandling.corsHandling)(app, options);
+  (0, _mockApiHandler.mockApiHandler)(app, options);
+  const {
+    compiler
+  } = (0, _configWebpackDevMiddleware.configWebpackDevMiddleware)(app, options); // serveContextFiles(app, options);
+
+  (0, _startHttpsServer.startHttpsServer)(app, options);
+  (0, _startHttpServer.startHttpServer)(app, options);
+  (0, _initialHTMLHandling.initialHTMLHandling)(compiler, app, options);
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startHttpServer = startHttpServer;
+
+var _logger = require("../../logger");
+
+function startHttpServer(app, options) {
+  const {
+    serverExtras
+  } = options;
+  const {
+    httpPort,
+    httpUrl
+  } = serverExtras;
+  app.listen(httpPort, err => {
+    if (err) {
+      throw err;
+    }
+
+    (0, _logger.messageLogger)(`Listening at ${httpUrl}`);
+  });
+  return app;
+}