@zohodesk/react-cli 1.1.19-exp.12 → 1.1.19-exp.13

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

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

@@ -0,0 +1,18 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('default values as params', () => {
+  const inputCode = `function myFunction(x, y = 10) {
+  return x + y;
+}
+myFunction(5);`;
+  const outputCode = `function myFunction(x) {
+  let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+  return x + y;
+}
+myFunction(5);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,82 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('computed-properties', () => {
+  const inputCode = `var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar",
+};`;
+  const outputCode = `var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar"
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('unicode', () => {
+  const inputCode = `var string = "foo💩bar";
+var match = string.match(/foo(.)bar/u);`;
+  const outputCode = `var string = "foo💩bar";
+var match = string.match(/foo(.)bar/u);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('destructuring', () => {
+  const inputCode = `let { x, y } = obj;
+let [a, b, ...rest] = arr;`;
+  const outputCode = `let {
+  x,
+  y
+} = obj;
+let [a, b, ...rest] = arr;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('duplicate-keys', () => {
+  const inputCode = `var x = { a: 5, a: 6};
+var y = {
+  get a() {},
+  set a(x) {},
+  a: 3,
+};`;
+  const outputCode = `var x = {
+  a: 5,
+  a: 6
+};
+var y = {
+  get a() {},
+  set a(x) {},
+  a: 3
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('instance of', () => {
+  const inputCode = 'foo instanceof Bar;';
+  const outputCode = 'foo instanceof Bar;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('function name', () => {
+  const inputCode = 'let number = x => x;';
+  const outputCode = 'let number = x => x;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('template literals', () => {
+  // eslint-disable-next-line no-template-curly-in-string
+  const inputCode = '`foo${bar}`'; // eslint-disable-next-line no-template-curly-in-string
+
+  const outputCode = '`foo${bar}`;';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('shorthand properties', () => {
+  const inputCode = 'var o = { a, b, c };';
+  const outputCode = `var o = {
+  a,
+  b,
+  c
+};`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('for of loop', () => {
+  const inputCode = `const cars = ["BMW", "Volvo", "Mini"];
+let text = "";
+
+for (let x of cars) {
+  text += x + " ";
+}`;
+  const outputCode = `const cars = ["BMW", "Volvo", "Mini"];
+let text = "";
+for (let x of cars) {
+  text += x + " ";
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,22 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Promises', () => {
+  const inputCode = `const myPromise = new Promise(function(myResolve, myReject) {
+  myResolve();
+  myReject(); 
+});
+myPromise.then(
+  function(value) { /* code if successful */ },
+  function(error) { /* code if some error */ }
+);`;
+  const outputCode = `const myPromise = new Promise(function (myResolve, myReject) {
+  myResolve();
+  myReject();
+});
+myPromise.then(function (value) {/* code if successful */}, function (error) {/* code if some error */});`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('spread Ooperator', () => {
+  const inputCode = `const q1 = ["Jan", "Feb", "Mar"];
+const q2 = ["Apr", "May", "Jun"];
+const q3 = ["Jul", "Aug", "Sep"];
+const q4 = ["Oct", "Nov", "May"];
+
+const year = [...q1, ...q2, ...q3, ...q4];`;
+  const outputCode = `const q1 = ["Jan", "Feb", "Mar"];
+const q2 = ["Apr", "May", "Jun"];
+const q3 = ["Jul", "Aug", "Sep"];
+const q4 = ["Oct", "Nov", "May"];
+const year = [...q1, ...q2, ...q3, ...q4];`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Function Rest Parameter', () => {
+  const inputCode = `function sum(...args) {
+  let sum = 0;
+  for (let arg of args) sum += arg;
+  return sum;
+}
+let x = sum(4, 9, 16, 25, 29, 100, 66, 77);`;
+  const outputCode = `function sum() {
+  let sum = 0;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  for (let arg of args) sum += arg;
+  return sum;
+}
+let x = sum(4, 9, 16, 25, 29, 100, 66, 77);`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,67 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('string.includes() method', () => {
+  const inputCode = `let text = "Hello world, welcome to the universe.";
+text.includes("world")`;
+  const outputCode = `let text = "Hello world, welcome to the universe.";
+text.includes("world");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('string.startsWith() method', () => {
+  const inputCode = `let text = "Hello world, welcome to the universe.";
+text.startsWith("Hello")`;
+  const outputCode = `let text = "Hello world, welcome to the universe.";
+text.startsWith("Hello");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('string.endsWith() method', () => {
+  const inputCode = `var text = "John Doe";
+text.endsWith("Doe")`;
+  const outputCode = `var text = "John Doe";
+text.endsWith("Doe");`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array.from method', () => {
+  const inputCode = 'Array.from("ABCDEFG")  ';
+  const outputCode = 'Array.from("ABCDEFG");';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array.keys method', () => {
+  const inputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+const keys = fruits.keys();`;
+  const outputCode = `const fruits = ["Banana", "Orange", "Apple", "Mango"];
+const keys = fruits.keys();`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array. finf method', () => {
+  const inputCode = ` const numbers = [4, 9, 16, 25, 29];
+let first = numbers.find(myFunction);
+
+function myFunction(value, index, array) {
+  return value > 18;
+}`;
+  const outputCode = `const numbers = [4, 9, 16, 25, 29];
+let first = numbers.find(myFunction);
+function myFunction(value, index, array) {
+  return value > 18;
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Array.findIndex() method', () => {
+  const inputCode = `const numbers = [4, 9, 16, 25, 29];
+let first = numbers.findIndex(myFunction);
+
+function myFunction(value, index, array) {
+  return value > 18;
+} `;
+  const outputCode = `const numbers = [4, 9, 16, 25, 29];
+let first = numbers.findIndex(myFunction);
+function myFunction(value, index, array) {
+  return value > 18;
+}`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

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

@@ -0,0 +1,21 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('keyword var', () => {
+  const inputCode = 'var name = "sam"';
+  const outputCode = 'var name = "sam";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('keyword let', () => {
+  const inputCode = 'let name = "sam"';
+  const outputCode = 'let name = "sam";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('keyword const', () => {
+  const inputCode = 'const name = "sam"';
+  const outputCode = 'const name = "sam";';
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2016/array-includes.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Exponentation operator', () => {
+  const inputCode = `let array =[1,2,4];
+console.log(array.includes(2));`;
+  const outputCode = `let array = [1, 2, 4];
+console.log(array.includes(2));`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});

package/packages/client_build_tool/lib/shared/babel/__test__/es2016/exponentationOperator.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const {
+  convertCode
+} = require('../utilities');
+
+test('Exponentation operator', () => {
+  const inputCode = `let x = 5;
+let z = x ** 2;`;
+  const outputCode = `let x = 5;
+let z = x ** 2;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});
+test('Exponentation assignment operator', () => {
+  const inputCode = `let x = 5;
+x **=2;`;
+  const outputCode = `let x = 5;
+x **= 2;`;
+  expect(convertCode(inputCode)).toBe(outputCode);
+});