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

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTypeOf = getTypeOf;
+exports.isJsFile = exports.isDirRelatedCss = exports.isCssFile = exports.isCss = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isCss = filename => _path.default.extname(filename) === '.css';
+
+exports.isCss = isCss;
+
+const isDirRelatedCss = filename => filename.includes('[dir]');
+
+exports.isDirRelatedCss = isDirRelatedCss;
+
+const isJsFile = file => /\.js$/.test(file);
+
+exports.isJsFile = isJsFile;
+
+const isCssFile = file => /\.css$/.test(file);
+
+exports.isCssFile = isCssFile;
+
+function getTypeOf(value) {
+  return Object.prototype.toString.call(value).split(/\s/)[1].replace(/\]/, '').toLowerCase();
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/object-manipulation.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertObjectToStringGen = convertObjectToStringGen;
+exports.removeKeysFromObject = removeKeysFromObject;
+
+/* eslint-disable no-restricted-syntax */
+function objectPathMatcher(currentKey, objHierarchy = [], keysToBeRemoved = []) {
+  const objPathKey = objHierarchy.length > 0 ? `${objHierarchy.join('.')}.${currentKey}` : currentKey;
+  return keysToBeRemoved.some(key => {
+    const isWildPath = /^\*/.test(key);
+
+    if (isWildPath) {
+      const newKey = key.replace(/\*\.?/, '');
+      return objPathKey.includes(newKey);
+    }
+
+    return key === objPathKey;
+  });
+}
+/*
+    1) *.keyTobeRemoved -> means match every object path, this key will be removed
+    2) keyToBeremoved -> means root object key
+    3) nestedPath.keyToBeRemoved -> means only that nested path key
+    4) don't need to account for array iteration, just object key path is enough in the key to be removed.
+*/
+
+
+function removeKeysFromObject(obj, keysToBeRemoved, prevKeys = []) {
+  if (Array.isArray(obj)) {
+    return obj.map(item => removeKeysFromObject(item, keysToBeRemoved, prevKeys));
+  }
+
+  if (obj && typeof obj === 'object') {
+    const filteredKeyObject = {};
+    const ObjectKeys = Object.keys(obj);
+
+    for (const objectKey of ObjectKeys) {
+      const isKeyToBeRemoved = objectPathMatcher(objectKey, prevKeys, keysToBeRemoved);
+
+      if (!isKeyToBeRemoved) {
+        filteredKeyObject[objectKey] = removeKeysFromObject(obj[objectKey], keysToBeRemoved, [...prevKeys, objectKey]);
+      }
+    }
+
+    return filteredKeyObject;
+  }
+
+  return obj;
+}
+
+function* convertObjectToStringGen(obj) {
+  if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || obj === null) {
+    yield JSON.stringify(obj);
+  } else if (Array.isArray(obj)) {
+    yield '[';
+    let isFirst = true;
+
+    for (let item of obj) {
+      if (item === undefined) {
+        item = null;
+      }
+
+      yield `${isFirst ? '' : ','}`;
+      yield* convertObjectToStringGen(item);
+      isFirst = false;
+    }
+
+    yield ']';
+  } else {
+    yield '{';
+    let isFirst = true;
+    const entries = Object.entries(obj);
+
+    for (const [itemKey, itemValue] of entries) {
+      if (itemValue !== undefined) {
+        yield `${isFirst ? '' : ','}${JSON.stringify(itemKey)}: `;
+        yield* convertObjectToStringGen(itemValue);
+        isFirst = false;
+      }
+    }
+
+    yield '}';
+  }
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/updateArrayWithDefault.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getArrayWithDefault = getArrayWithDefault;
+exports.updateArrayWithDefault = updateArrayWithDefault;
+
+function updateArrayWithDefault(array, defaultoptions = []) {
+  const index = array.indexOf('...');
+
+  if (index === -1) {
+    return array;
+  }
+
+  const newArray = [...array];
+  newArray.splice(index, 1, ...defaultoptions);
+  return newArray;
+}
+
+const isEqualVal = (a, b) => a === b;
+
+function getArrayWithDefault(array, defaultoptions = [], isEqual = isEqualVal) {
+  const index = array.indexOf('...');
+
+  if (index === -1) {
+    return array;
+  }
+
+  const filteredDefaultOptions = defaultoptions.filter(v => !array.some(v1 => isEqual(v, v1)));
+  const newArray = [...array];
+  newArray.splice(index, 1, ...filteredDefaultOptions);
+  return newArray;
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/webpackBuild.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = webpackBuild;
+
+var _webpack = require("webpack");
+
+var _statsConfig = require("./statsConfig");
+
+var _webpackConfig = _interopRequireDefault(require("./webpackConfig"));
+
+var _logger = require("../../../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function webpackBuild(options) {
+  const config = (0, _webpackConfig.default)(options);
+  (0, _webpack.webpack)(config, (err, stats) => {
+    if (err || stats.hasErrors()) {
+      (0, _logger.errorLogger)('err', err);
+    }
+
+    (0, _logger.messageLogger)(stats.toString((0, _statsConfig.statsConfig)(options)));
+  });
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/webpackConfig.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = webpackConfigCreator;
+
+var _entryConfig = require("./entryConfig");
+
+var _outputConfig = require("./outputConfig");
+
+var _jsLoaders = require("./jsLoaders");
+
+var _tsLoaders = require("./tsLoaders");
+
+var _cssLoaders = require("./cssLoaders");
+
+var _assetLoaders = require("./loaderConfigs/assetLoaders");
+
+var _plugins = require("./plugins");
+
+var _resolvers = require("./resolvers");
+
+var _optimizationConfig = require("./optimizationConfig");
+
+var _configHtmlTemplateLoader = require("./loaderConfigs/configHtmlTemplateLoader");
+
+var _configWebWorkerLoader = require("./loaderConfigs/configWebWorkerLoader");
+
+var _statsConfig = require("./statsConfig");
+
+var _devtoolConfig = require("./devtoolConfig");
+
+var _modeUtils = require("./common/modeUtils");
+
+var _externals = require("./externals");
+
+var _configCustomLoaders = require("./configCustomLoaders");
+
+function webpackConfigCreator(options) {
+  return {
+    entry: (0, _entryConfig.entryConfig)(options),
+    mode: (0, _modeUtils.getWebpackMode)(options),
+    output: (0, _outputConfig.outputConfig)(options),
+    devtool: (0, _devtoolConfig.devtoolConfig)(options),
+    stats: (0, _statsConfig.statsConfig)(options),
+    optimization: (0, _optimizationConfig.optimizationConfig)(options),
+    module: {
+      /* strictExportPresence for break the build when imported module not present in respective file */
+      // strictExportPresence: true,
+      rules: [...(0, _jsLoaders.jsLoaders)(options), ...(0, _tsLoaders.tsLoaders)(options), ...(0, _cssLoaders.cssLoaders)(options), (0, _configWebWorkerLoader.configWebWorkerLoader)(options), (0, _configHtmlTemplateLoader.configHtmlTemplateLoader)(options), ...(0, _assetLoaders.assetLoaders)(options), ...(0, _configCustomLoaders.configCustomLoaders)(options)]
+    },
+    plugins: (0, _plugins.plugins)(options),
+    externals: (0, _externals.externals)(options),
+    resolve: (0, _resolvers.moduleResolver)(options),
+    resolveLoader: (0, _resolvers.loaderResolver)(options)
+  };
+}

package/packages/client_build_tool/lib/shared/commands-utils/doBasicRequirementCheck.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.doBasicRequirementCheck = doBasicRequirementCheck;
+
+/* eslint-disable no-throw-literal */
+function doBasicRequirementCheck() {
+  const majorV = Number(process.version.slice(1, 4));
+
+  if (majorV >= 14 && majorV <= 18) {
+    return true;
+  }
+
+  throw `your node version not compatible with this cli please update node version to 14 - 18, and your current version is ${process.version}`;
+}

package/packages/client_build_tool/lib/shared/commands-utils/getCliPath.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCliPath = getCliPath;
+
+var _os = require("os");
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+var _constants = require("../constants");
+
+const isWindows = (0, _os.platform)().toLowerCase() === 'win32';
+const suffixExt = isWindows ? '.cmd' : ''; // function searchForCommandPath(commandName) {
+//   let pathFolders = __dirname.split(sep);
+//   let cliPath;
+//   while (pathFolders.pop()) {
+//     cliPath = join(pathFolders.join(sep), 'node_modules', '.bin', commandName);
+//     if (existsSync(cliPath)) {
+//       return cliPath;
+//     }
+//   }
+//   console.warn(`unable to find command "${commandName}"`);
+//   return join(__dirname, '..', 'node_modules', '.bin', commandName);
+// }
+
+function searchForCommandPath(libName) {
+  const commandPath = (0, _path.join)(_constants.cliNodeModulesPath, '.bin', libName); // TODO: need to check for windows machine reason command with ext added,
+  //  when we use global react-cli package (executable) working or not
+
+  return (0, _fs.existsSync)(commandPath) ? commandPath : libName;
+}
+
+function getCliPath(commandName) {
+  return searchForCommandPath(commandName + suffixExt);
+}

package/packages/client_build_tool/lib/shared/commands-utils/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "doBasicRequirementCheck", {
+  enumerable: true,
+  get: function () {
+    return _doBasicRequirementCheck.doBasicRequirementCheck;
+  }
+});
+Object.defineProperty(exports, "readArgsFormCommandLine", {
+  enumerable: true,
+  get: function () {
+    return _readArgsFormCommandLine.readArgsFormCommandLine;
+  }
+});
+Object.defineProperty(exports, "readOptionFormCommandLine", {
+  enumerable: true,
+  get: function () {
+    return _readOptionFormCommandLine.readOptionFormCommandLine;
+  }
+});
+
+var _readArgsFormCommandLine = require("./readArgsFormCommandLine");
+
+var _readOptionFormCommandLine = require("./readOptionFormCommandLine");
+
+var _doBasicRequirementCheck = require("./doBasicRequirementCheck");

package/packages/client_build_tool/lib/shared/commands-utils/log.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.log = void 0;
+
+let log = (...info) => {
+  let print = console;
+  print.log(...info);
+};
+
+exports.log = log;

package/packages/client_build_tool/lib/shared/commands-utils/readArgsFormCommandLine.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readArgsFormCommandLine = readArgsFormCommandLine;
+const args = process.argv.slice(3);
+
+function readArgsFormCommandLine() {
+  return args;
+}

package/packages/client_build_tool/lib/shared/commands-utils/readOptionFormCommandLine.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readOptionFormCommandLine = readOptionFormCommandLine;
+const [,, option] = process.argv;
+
+function readOptionFormCommandLine() {
+  return option;
+}

package/packages/client_build_tool/lib/shared/commands-utils/spawnSyncIO.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultSpawnSyncOptions = void 0;
+exports.spawnIO = spawnIO;
+exports.spawnSyncIO = spawnSyncIO;
+
+var _child_process = require("child_process");
+
+var _logger = require("../../logger");
+
+var _getCliPath = require("./getCliPath");
+
+const defaultSpawnSyncOptions = {
+  stdio: 'inherit'
+};
+exports.defaultSpawnSyncOptions = defaultSpawnSyncOptions;
+
+function spawnSyncIO(commandName, args, spawnSyncOptions = defaultSpawnSyncOptions) {
+  const command = (0, _getCliPath.getCliPath)(commandName);
+  const result = (0, _child_process.spawnSync)(command, args, spawnSyncOptions);
+
+  if (result.error || result.stderr) {
+    (0, _logger.errorLogger)(result.error || result.stderr);
+  }
+
+  return result;
+}
+
+function spawnIO(commandName, args, cb) {
+  const command = (0, _getCliPath.getCliPath)(commandName); // const result =
+
+  return (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  }, cb); // process.exit(result.status);
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cliRootPath = exports.cliNodeModulesPath = exports.babelrcPath = exports.appPath = exports.appNodeModules = exports.CONFIG_ROOT = exports.BASE_CONFIG_KEY = void 0;
+exports.getTemplatePath = getTemplatePath;
+exports.joinWithAppPath = joinWithAppPath;
+exports.templatesPath = void 0;
+
+var _path = _interopRequireWildcard(require("path"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const BASE_CONFIG_KEY = 'react-cli';
+exports.BASE_CONFIG_KEY = BASE_CONFIG_KEY;
+
+const cliRootPath = _path.default.resolve(__dirname, '..', '..');
+
+exports.cliRootPath = cliRootPath;
+const CONFIG_ROOT = 'client-build-config';
+exports.CONFIG_ROOT = CONFIG_ROOT;
+
+const cliNodeModulesPath = _path.default.resolve(cliRootPath, 'node_modules');
+
+exports.cliNodeModulesPath = cliNodeModulesPath;
+const babelrcPath = (0, _path.join)(cliRootPath, '.babelrc');
+exports.babelrcPath = babelrcPath;
+const appPath = process.cwd();
+exports.appPath = appPath;
+
+function joinWithAppPath(filePath) {
+  // TODO: test in windows
+  return (0, _path.join)(appPath, filePath);
+}
+
+;
+const appNodeModules = joinWithAppPath('node_modules');
+exports.appNodeModules = appNodeModules;
+const templatesPath = (0, _path.join)(__dirname, '..', '..', 'templates');
+exports.templatesPath = templatesPath;
+
+function getTemplatePath(...filePath) {
+  // TODO: test in windows
+  return (0, _path.join)(templatesPath, ...filePath);
+}

package/packages/client_build_tool/lib/shared/fileUtils/copyFile.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyFile = copyFile;
+exports.createParentDir = createParentDir;
+exports.writeFile = writeFile;
+
+var _fs = require("fs");
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createParentDir(filename) {
+  const {
+    dir
+  } = _path.default.parse(filename);
+
+  if (!(0, _fs.existsSync)(dir)) {
+    (0, _fs.mkdirSync)(dir, {
+      recursive: true
+    });
+  }
+}
+
+function copyFile(filename, outputFile) {
+  createParentDir(outputFile);
+  const readStream = (0, _fs.createReadStream)(filename);
+  const writeStream = (0, _fs.createWriteStream)(outputFile);
+  return readStream.pipe(writeStream);
+}
+
+function writeFile(filename, data) {
+  createParentDir(filename);
+  return (0, _fs.writeFileSync)(filename, data);
+}

package/packages/client_build_tool/lib/shared/fileUtils/directoryIterator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.directoryIterator = directoryIterator;
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+function directoryIterator(filename, callback) {
+  if (!(0, _fs.statSync)(filename).isDirectory()) {
+    callback(filename);
+    return;
+  }
+
+  (0, _fs.readdirSync)(filename).forEach(fileOrDir => {
+    directoryIterator((0, _path.join)(filename, fileOrDir), callback);
+  });
+}

package/packages/client_build_tool/lib/shared/fileUtils/watchRun.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.watchRun = watchRun;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _watcher = _interopRequireDefault(require("watcher"));
+
+var _runBabelForJSFile = require("../babel/runBabelForJSFile");
+
+var _runBabelForTsFile = require("../babel/runBabelForTsFile");
+
+var _runPostCssForCssFile = require("../postcss/runPostCssForCssFile");
+
+var _directoryIterator = require("./directoryIterator");
+
+var _copyFile = require("./copyFile");
+
+var _logger = require("../../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isJs = ext => ext === '.js';
+
+const isTs = ext => ext === '.ts' || ext === '.tsx';
+
+const isCss = ext => ext === '.css';
+
+function watchRun({
+  options,
+  src,
+  target,
+  canWatch,
+  mode
+}) {
+  let updatedFileCount = 0;
+
+  function doWorkForSeparateFile(filename) {
+    const outputFile = filename.replace(src, target);
+
+    const {
+      ext
+    } = _path.default.parse(filename);
+
+    if (isJs(ext)) {
+      (0, _runBabelForJSFile.runBabelForJSFile)({
+        filename,
+        outputFile,
+        options,
+        mode
+      });
+    } else if (isCss(ext)) {
+      (0, _runPostCssForCssFile.runPostCssForCssFile)({
+        filename,
+        outputFile,
+        options
+      });
+    } else if (isTs(ext)) {
+      (0, _runBabelForTsFile.runBabelForTSFile)({
+        filename,
+        outputFile,
+        options,
+        mode
+      });
+    } else {
+      (0, _copyFile.copyFile)(filename, outputFile);
+    }
+
+    updatedFileCount++;
+  }
+
+  function doWork(foldername) {
+    updatedFileCount = 0;
+    const startTime = Date.now();
+    (0, _directoryIterator.directoryIterator)(foldername, filename => {
+      try {
+        doWorkForSeparateFile(filename);
+      } catch (error) {
+        (0, _logger.messageLogger)(`ERROR In: ${filename}`);
+        (0, _logger.messageLogger)(error);
+      }
+    });
+    (0, _logger.messageLogger)(`Successfully compiled ${updatedFileCount} files with Babel and Post-CSS (${Date.now() - startTime}ms).`);
+  }
+
+  doWork(src);
+
+  if (canWatch) {
+    const watcher = new _watcher.default(src, {
+      recursive: true,
+      ignoreInitial: true,
+      ignore: filename => filename.indexOf('__tests__') !== -1 // remove the test cases 
+
+    });
+    watcher.on('all', (event, filename) => {
+      if (event === 'unlink' || event === 'unlinkDir') {
+        return;
+      }
+
+      doWork(filename); // This is what the library does internally when you pass it a handler directly
+      //   arguments [0] (event); // => could be any target event: 'add', 'addDir', 'change', 'rename', 'renameDir', 'unlink' or 'unlinkDir'
+      //   arguments [1] (filename); // => the file system path where the event took place, this is always provided
+      //   arguments [2] (targetPathNext); // => the file system path "targetPath" got renamed to, this is only provided on 'rename'/'renameDir' events
+    });
+    watcher.on('error', error => {
+      (0, _logger.messageLogger)(error); // => true, "Error" instances are always provided on "error"
+    });
+  }
+}