@zohodesk/react-cli 1.1.27 → 1.1.28

package/packages/client_build_tool/lib/schemas/defaultConfigValuesOnly.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _os = require("os");
+
+// NOTE: Don't use 'config_file' as cli option it was reserved
+var _default = {
+  context: 'app',
+  devtool: 'hidden-cheap-source-map',
+  enableFileNameHashing: false,
+  bundleAnalyze: false,
+  enableMockReplace: false,
+  noPublicPath: false,
+  output: 'build',
+  mode: null,
+  printProgress: false,
+  server: {
+    httpsCerts: '@zohodesk-private/client_dev_cert',
+    host: (0, _os.hostname)(),
+    port: 9090,
+    domain: 'tsi',
+    disableContextURL: false
+  },
+  mockServer: {
+    enable: false,
+    separateSeverPort: 5000,
+    disableNodemon: false,
+    mockEntryFile: 'mockapi/index.js',
+    mockPrefix: '/api/'
+  },
+  css: {
+    classNameOptions: {
+      customizations: [{
+        enable: true,
+        blob: '[local]',
+        patterns: ['*.plain.css']
+      }, {
+        enable: true,
+        blob: '[prefix]-[filename]-[local]',
+        patterns: []
+      }],
+      classNamePrefix: 'zd'
+    },
+    // NOTE: Suggestions
+    // Name Suggestions  `customizations` this will be easier then `plugin` to understand for developers
+    plugins: {
+      rtlSplit: {
+        enableRTLSplit: false,
+        templateLabel: '{{--dir}}',
+        disableMinifySelector: false,
+        dirVarName: 'document.dir'
+      },
+      selectorWeight: {
+        enable: false,
+        patterns: [],
+        configFile: null,
+        defaultSelector: '',
+        customFileDetails: '',
+        excludeStrings: []
+      },
+      selectorReplace: {
+        enable: false,
+        patterns: [],
+        before: [],
+        after: []
+      },
+      hoverActive: {
+        enable: false,
+        patterns: [],
+        hover: '(hover: hover)',
+        active: '(hover: none)'
+      },
+      cssVariableReplacement: {
+        enable: false,
+        patterns: [],
+        configFile: null
+      },
+      rtl: {
+        enable: false,
+        patterns: []
+      } // postcss - plugins end
+
+    },
+    customPlugins: []
+  },
+  i18nChunkSplit: {
+    chunkSplitEnable: false,
+    disableDefault: false,
+    templateLabel: '{{--user-locale}}',
+    localeVarName: 'document.documentElement.lang',
+    jsonpFunc: 'console.log',
+    jsResource: null,
+    propertiesFolder: null
+  },
+  publicFolders: ['...', {
+    source: './deskapp/tp/',
+    target: './tp/'
+  }],
+  app: {
+    entryFile: 'src/index.js',
+    tpFolder: null,
+    moduleResolvePath: 'node_modules'
+  },
+  resolve: {
+    preferLocalFirst: false,
+    defaultAlias: true,
+    moduleResolvePath: 'node_modules',
+    alias: null
+  },
+  // EFC means Embedded Functional Components
+  efc: {
+    hasEFC: false,
+    entryPointName: 'efc',
+    entryFile: 'src/efc.js',
+    version: 'v1',
+    createSDkFile: false,
+    templateFilePath: 'efcTemplate.js',
+    outputFile: 'efc-sdk-[version].js',
+    resourceCleanup: false
+  },
+  createSeparateSMap: false,
+  babelCustomizations: {
+    browserList: null,
+    removeAttribute: {
+      enable: false,
+      options: {
+        attributeNames: ['data-testid']
+      }
+    },
+    removePropTypes: {
+      enable: false,
+      options: {
+        mode: 'remove',
+        removeImport: true
+      }
+    },
+    devConsoleExclude: {
+      enable: false,
+      options: {
+        exclude: ['error']
+      }
+    },
+    // NOTE: need to consider
+    // presets: [],
+    plugins: []
+  },
+  webpackPlugins: [],
+  vendorPatterns: [],
+  customChunks: [{
+    name: 'styles',
+    patterns: ['*.css']
+  }],
+  htmlTemplate: {
+    templateFile: 'src/index.html',
+    minify: null,
+    inject: true
+  },
+  // CDN means Content Delivery Network
+  cdnMapping: {
+    isCdnEnabled: false,
+    variableName: '',
+    cssTemplate: '',
+    jsTemplate: '',
+    i18nTemplate: ''
+  },
+  manifestJson: {
+    enable: true
+  },
+  changeRuntimeChunkChar: '~',
+  serviceWorker: {
+    enable: false,
+    templateFilePath: 'sw.js',
+    outputFilePath: '/v1.js',
+    replaceText: '//<!--AssetsFromBuild -->'
+  },
+  stats: {
+    enable: false,
+    fileName: null,
+    options: null,
+    excludeKeys: null
+  }
+};
+exports.default = _default;

package/packages/client_build_tool/lib/schemas/deprecatedOptionsHandler.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deprecatedOptionsHandler = deprecatedOptionsHandler;
+
+var _logger = require("../logger");
+
+function nestedSelect(obj, key) {
+  let temp = obj;
+  const keys = key.split('.');
+
+  for (let i = 0; i < keys.length && temp; i++) {
+    const element = keys[i];
+    temp = temp[element];
+  }
+
+  return temp;
+}
+
+function nestedUpdate(obj, key, value) {
+  let temp = obj;
+  const keys = key.split('.');
+  let i = 0;
+
+  for (; i < keys.length - 1 && temp; i++) {
+    const element = keys[i];
+    temp = temp[element];
+  }
+
+  if (temp) {
+    temp[keys[i]] = value;
+  }
+}
+
+function deprecatedOptionsHandler(options) {
+  function checkAndUpdateAndPrintWaring(oldKey, newkey) {
+    const oldVal = nestedSelect(options, oldKey);
+    const newVal = nestedSelect(options, newkey); // console.log({ oldVal, newVal });
+
+    if (oldVal !== undefined && newVal === undefined) {
+      nestedUpdate(options, newkey, newVal);
+      (0, _logger.warnLogger)(`"${oldKey}" deprecated use "${newkey}" instead`);
+    }
+  } // return;
+
+
+  checkAndUpdateAndPrintWaring('app.context', 'context'); // TODO handle deprecations  here
+  // we will finish this logic later when options are confirmed
+
+  if (nestedSelect(options, 'app.hasRTL') === true) {
+    nestedUpdate(options, 'app.plugins.hasRTL', true);
+  }
+
+  if (nestedSelect(options, 'docs.hasRTL') === true) {
+    nestedUpdate(options, 'docs.plugins.hasRTL', true);
+  }
+
+  if (nestedSelect(options, 'app.rtlExclude.length') > 0) {
+    nestedUpdate(options, 'app.exclude.rtl', nestedSelect(options, 'app.rtlExclude'));
+  }
+
+  if (nestedSelect(options, 'docs.rtlExclude.length') > 0) {
+    nestedUpdate(options, 'docs.exclude.rtl', nestedSelect(options, 'docs.rtlExclude'));
+  }
+}

package/packages/client_build_tool/lib/schemas/getNpmVersion.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNpmVersion = getNpmVersion;
+
+var _child_process = require("child_process");
+
+var _logger = require("../logger");
+
+function getNpmVersion() {
+  let vers = '6';
+
+  try {
+    [vers] = (0, _child_process.execSync)('npm -v').toString().trim().split('.');
+  } catch (error) {
+    (0, _logger.messageLogger)(error);
+  }
+
+  return vers;
+}

package/packages/client_build_tool/lib/schemas/giveDefaultValue.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.giveDefaultValue = giveDefaultValue;
+
+function giveDefaultValue(value) {
+  if (value === true || value === 'true') {
+    return true;
+  }
+
+  if (value === false || value === 'false' || value === '') {
+    return false;
+  }
+
+  return value;
+}

package/packages/client_build_tool/lib/schemas/npmConfigToObject.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.npmConfigToObject = npmConfigToObject;
+
+var _logger = require("../logger");
+
+const NPM_CONFIG_PREFIX = 'npm_config_'; // TODO: we have to do option parse logic little better
+// if user use react-cli strictly without using npm scripts options won't work,
+//  So  we have to write our own option parse logic or some other library
+// console.log('type', process.argv,  process.env.npm_config_check,  process.env.npm_config_clone_type, process.env.npm_config_clone_url);
+// console.log('Object.keys(process.env).filter(s => s.startsWith(\'npm_config_\') && s.includes(\'clone\')', Object.keys(process.env).filter(s => s.startsWith('npm_config_') && s.includes('clone')));
+
+function npmConfigToObject() {
+  // // clone:type
+  const processEnv = {};
+  const keysWithColon = [];
+  Object.keys(process.env).filter(key => key.startsWith(NPM_CONFIG_PREFIX)).forEach(key => {
+    const nKey = key.slice(NPM_CONFIG_PREFIX.length);
+    processEnv[nKey] = process.env[key];
+    nKey.includes(':') && keysWithColon.push(nKey);
+  });
+  keysWithColon.forEach(key => {
+    const nKey = key.replace(/:/g, '_');
+
+    if (processEnv[nKey]) {
+      (0, _logger.warnLogger)('there is some options conflict', key, nKey);
+    }
+
+    processEnv[nKey] = processEnv[key];
+  });
+  return processEnv;
+}

package/packages/client_build_tool/lib/schemas/readOptions.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOptions = exports.args = void 0;
+
+var _applyValuesToSchema = require("./applyValuesToSchema");
+
+var _cliArgsToObject = require("./cliArgsToObject");
+
+var _defaultConfigValues = _interopRequireDefault(require("./defaultConfigValues"));
+
+var _deprecatedOptionsHandler = require("./deprecatedOptionsHandler");
+
+var _getNpmVersion = require("./getNpmVersion");
+
+var _npmConfigToObject = require("./npmConfigToObject");
+
+var _readOptionsForConfigFile = require("./readOptionsForConfigFile");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const args = process.argv.slice(2);
+exports.args = args;
+const processEnv = (0, _npmConfigToObject.npmConfigToObject)();
+const cliArgsObject = (0, _cliArgsToObject.cliArgsToObject)(args);
+Object.assign(processEnv, cliArgsObject);
+let reactCLIOptions = null;
+
+const getOptions = () => {
+  if (reactCLIOptions) {
+    return reactCLIOptions;
+  }
+
+  const appPath = process.cwd();
+  const userSchemas = (0, _readOptionsForConfigFile.readOptionsForPackageJson)(appPath); // NOTE: Only config File option will with cli option  config_file
+
+  const configFileSchemas = (0, _readOptionsForConfigFile.readOptionsForConfigFile)(appPath, cliArgsObject.config_file || 'cbt.config.js');
+  const options = (0, _applyValuesToSchema.applyValuesToSchema)(_defaultConfigValues.default, configFileSchemas || userSchemas || {}, processEnv);
+  (0, _deprecatedOptionsHandler.deprecatedOptionsHandler)(options); // for future may be for npm 8 edge cases
+
+  options.npmVersion = (0, _getNpmVersion.getNpmVersion)();
+  options.cwd = appPath;
+  options.packageVersion = process.env.npm_package_version;
+  options.extraArgs = process.argv.slice(3); // eslint-disable-next-line prefer-destructuring
+
+  options.commandOption = process.argv[2];
+  reactCLIOptions = options; // console.log({ options });
+
+  return options;
+};
+
+exports.getOptions = getOptions;

package/packages/client_build_tool/lib/schemas/readOptionsForConfigFile.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readOptionsForConfigFile = readOptionsForConfigFile;
+exports.readOptionsForPackageJson = readOptionsForPackageJson;
+
+var _fs = require("fs");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _constants = require("../shared/constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import { CONFIG_ROOT } from "../constants";
+function readOptionsForPackageJson(appPath) {
+  const packagePath = _path.default.join(appPath, 'package.json');
+
+  if ((0, _fs.existsSync)(packagePath)) {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(packagePath)[_constants.BASE_CONFIG_KEY] || {};
+  }
+
+  return {};
+}
+
+function readOptionsForConfigFile(appPath, configFile) {
+  if (!configFile) {
+    return null;
+  }
+
+  const packagePath = _path.default.join(appPath, configFile);
+
+  if ((0, _fs.existsSync)(packagePath)) {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(packagePath).config;
+  }
+
+  return null;
+}

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/Map.test.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Map', () => {
+  const inputCode = `const fruits = new Map([
+["apples", 500],
+["bananas", 300],
+["oranges", 200]
+]);`;
+  const outputCode = 'const fruits = new Map([["apples", 500], ["bananas", 300], ["oranges", 200]]);';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/MathAndNumberMethod.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Math methods', () => {
+  const inputCode = `Math.trunc(4.9);
+Math.sign(4);
+Math.cbrt(125);
+Math.log2(2);
+Math.log10(10);`;
+  const outputCode = `Math.trunc(4.9);
+Math.sign(4);
+Math.cbrt(125);
+Math.log2(2);
+Math.log10(10);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Number methods', () => {
+  const inputCode = `Number.isInteger(10); 
+Number.isSafeInteger(10);
+isFinite(10/0);
+isNaN("Hello");`;
+  const outputCode = `Number.isInteger(10);
+Number.isSafeInteger(10);
+isFinite(10 / 0);
+isNaN("Hello");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/ObjectAndModules.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Object entries', () => {
+  const inputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+const f = fruits.entries();`;
+  const outputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+const f = fruits.entries();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Import from named exports', () => {
+  const inputCode = 'import { name, age } from "./person.js"; ';
+  const outputCode = 'import { name, age } from "./person.js";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Import from default exports', () => {
+  const inputCode = 'import message from "./message.js"; ';
+  const outputCode = 'import message from "./message.js";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('super method', () => {
+  const inputCode = `let obj = {
+  say() {
+    return "Hello";
+  },
+};
+
+let obj2 = {
+  say() {
+    return super.say() + "World!";
+  },
+};`;
+  const outputCode = `let obj = {
+  say() {
+    return "Hello";
+  }
+};
+let obj2 = {
+  say() {
+    return super.say() + "World!";
+  }
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/Sets.test.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Sets', () => {
+  const inputCode = `const letters = new Set();
+
+letters.add("a");
+letters.add("b");
+letters.add("c");`;
+  const outputCode = `const letters = new Set();
+letters.add("a");
+letters.add("b");
+letters.add("c");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/Symbol.test.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Symbol', () => {
+  const inputCode = `const person = {
+  firstName: "John",
+  lastName: "Doe",
+  age: 50,
+  eyeColor: "blue"
+};
+let id = Symbol('id');
+person[id] = 140353;`;
+  const outputCode = `const person = {
+  firstName: "John",
+  lastName: "Doe",
+  age: 50,
+  eyeColor: "blue"
+};
+let id = Symbol('id');
+person[id] = 140353;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/arrowFunction.test.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('arrow function', () => {
+  const inputCode = 'const x = (x, y) => x * y;';
+  const outputCode = 'const x = (x, y) => x * y;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('array.map method', () => {
+  const inputCode = 'const double = [1, 2, 3].map(num => num * 2);';
+  const outputCode = 'const double = [1, 2, 3].map(num => num * 2);';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('for each', () => {
+  const inputCode = `
+var bob = {
+    _name: "Bob",
+    _friends: ["Sally", "Tom"],
+    printFriends() {
+       this._friends.forEach(f => console.log(this._name + " knows " + f));
+    },
+};`;
+  const outputCode = `var bob = {
+  _name: "Bob",
+  _friends: ["Sally", "Tom"],
+  printFriends() {
+    this._friends.forEach(f => console.log(this._name + " knows " + f));
+  }
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/block-scoping.test.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('block', () => {
+  const inputCode = `{
+   let i = 0;
+}
+let i = 0;
+`;
+  const outputCode = `{
+  let i = 0;
+}
+let i = 0;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2015/classes.test.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('class object', () => {
+  const inputCode = `class Car {
+    constructor(name, year) {
+    this.name = name;
+    this.year = year;
+    }
+}`;
+  const outputCode = `class Car {
+  constructor(name, year) {
+    this.name = name;
+    this.year = year;
+  }
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('using class extends', () => {
+  const inputCode = `class Foo extends mixin(Array) { }
+    function mixin(Super) {
+       return class extends Super {
+        mix() { }
+    };
+}`;
+  const outputCode = `class Foo extends mixin(Array) {}
+function mixin(Super) {
+  return class extends Super {
+    mix() {}
+  };
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('new target method', () => {
+  const inputCode = `class Foo {
+  constructor() {
+    console.log(new.target);
+  }
+}
+class Bar extends Foo {}
+new Foo();
+new Bar()`;
+  const outputCode = `class Foo {
+  constructor() {
+    console.log(new.target);
+  }
+}
+class Bar extends Foo {}
+new Foo();
+new Bar();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});